Merge tag 'lsm-pr-20240105' of git://git.kernel.org/pub/scm/linux/kernel/git/pcmoore/lsm

Pull security module updates from Paul Moore: - Add three new syscalls: lsm_list_modules(), lsm_get_self_attr(), and lsm_set_self_attr(). The first syscall simply lists the LSMs enabled, while the second and third get and set the current process' LSM attributes. Yes, these syscalls may provide similar functionality to what can be found under /proc or /sys, but they were designed to support multiple, simultaneaous (stacked) LSMs from the start as opposed to the current /proc based solutions which were created at a time when only one LSM was allowed to be active at a given time. We have spent considerable time discussing ways to extend the existing /proc interfaces to support multiple, simultaneaous LSMs and even our best ideas have been far too ugly to support as a kernel API; after +20 years in the kernel, I felt the LSM layer had established itself enough to justify a handful of syscalls. Support amongst the individual LSM developers has been nearly unanimous, with a single objection coming from Tetsuo (TOMOYO) as he is worried that the LSM_ID_XXX token concept will make it more difficult for out-of-tree LSMs to survive. Several members of the LSM community have demonstrated the ability for out-of-tree LSMs to continue to exist by picking high/unused LSM_ID values as well as pointing out that many kernel APIs rely on integer identifiers, e.g. syscalls (!), but unfortunately Tetsuo's objections remain. My personal opinion is that while I have no interest in penalizing out-of-tree LSMs, I'm not going to penalize in-tree development to support out-of-tree development, and I view this as a necessary step forward to support the push for expanded LSM stacking and reduce our reliance on /proc and /sys which has occassionally been problematic for some container users. Finally, we have included the linux-api folks on (all?) recent revisions of the patchset and addressed all of their concerns. - Add a new security_file_ioctl_compat() LSM hook to handle the 32-bit ioctls on 64-bit systems problem. This patch includes support for all of the existing LSMs which provide ioctl hooks, although it turns out only SELinux actually cares about the individual ioctls. It is worth noting that while Casey (Smack) and Tetsuo (TOMOYO) did not give explicit ACKs to this patch, they did both indicate they are okay with the changes. - Fix a potential memory leak in the CALIPSO code when IPv6 is disabled at boot. While it's good that we are fixing this, I doubt this is something users are seeing in the wild as you need to both disable IPv6 and then attempt to configure IPv6 labeled networking via NetLabel/CALIPSO; that just doesn't make much sense. Normally this would go through netdev, but Jakub asked me to take this patch and of all the trees I maintain, the LSM tree seemed like the best fit. - Update the LSM MAINTAINERS entry with additional information about our process docs, patchwork, bug reporting, etc. I also noticed that the Lockdown LSM is missing a dedicated MAINTAINERS entry so I've added that to the pull request. I've been working with one of the major Lockdown authors/contributors to see if they are willing to step up and assume a Lockdown maintainer role; hopefully that will happen soon, but in the meantime I'll continue to look after it. - Add a handful of mailmap entries for Serge Hallyn and myself. * tag 'lsm-pr-20240105' of git://git.kernel.org/pub/scm/linux/kernel/git/pcmoore/lsm: (27 commits) lsm: new security_file_ioctl_compat() hook lsm: Add a __counted_by() annotation to lsm_ctx.ctx calipso: fix memory leak in netlbl_calipso_add_pass() selftests: remove the LSM_ID_IMA check in lsm/lsm_list_modules_test MAINTAINERS: add an entry for the lockdown LSM MAINTAINERS: update the LSM entry mailmap: add entries for Serge Hallyn's dead accounts mailmap: update/replace my old email addresses lsm: mark the lsm_id variables are marked as static lsm: convert security_setselfattr() to use memdup_user() lsm: align based on pointer length in lsm_fill_user_ctx() lsm: consolidate buffer size handling into lsm_fill_user_ctx() lsm: correct error codes in security_getselfattr() lsm: cleanup the size counters in security_getselfattr() lsm: don't yet account for IMA in LSM_CONFIG_COUNT calculation lsm: drop LSM_ID_IMA LSM: selftests for Linux Security Module syscalls SELinux: Add selfattr hooks AppArmor: Add selfattr hooks Smack: implement setselfattr and getselfattr hooks ...

Linus Torvalds committed 2 years ago

Commit 063a7ce2 parents 9f9310b f1bb47a66 files · +1784 −122Browse files

Unified · Split

66 files

.mailmap +4 −0
Documentation/userspace-api/index.rst +1 −0
Documentation/userspace-api/lsm.rst +73 −0
MAINTAINERS +14 −3
arch/alpha/kernel/syscalls/syscall.tbl +3 −0
arch/arm/tools/syscall.tbl +3 −0
arch/arm64/include/asm/unistd.h +1 −1
arch/arm64/include/asm/unistd32.h +6 −0
arch/m68k/kernel/syscalls/syscall.tbl +3 −0
arch/microblaze/kernel/syscalls/syscall.tbl +3 −0
arch/mips/kernel/syscalls/syscall_n32.tbl +3 −0
arch/mips/kernel/syscalls/syscall_n64.tbl +3 −0
arch/mips/kernel/syscalls/syscall_o32.tbl +3 −0
arch/parisc/kernel/syscalls/syscall.tbl +3 −0
arch/powerpc/kernel/syscalls/syscall.tbl +3 −0
arch/s390/kernel/syscalls/syscall.tbl +3 −0
arch/sh/kernel/syscalls/syscall.tbl +3 −0
arch/sparc/kernel/syscalls/syscall.tbl +3 −0
arch/x86/entry/syscalls/syscall_32.tbl +3 −0
arch/x86/entry/syscalls/syscall_64.tbl +3 −0
arch/xtensa/kernel/syscalls/syscall.tbl +3 −0
fs/ioctl.c +1 −2
fs/proc/base.c +15 −14
fs/proc/internal.h +1 −1
include/linux/lsm_hook_defs.h +6 −0
include/linux/lsm_hooks.h +15 −2
include/linux/security.h +50 −6
include/linux/syscalls.h +6 −0
include/uapi/asm-generic/unistd.h +8 −1
include/uapi/linux/lsm.h +90 −0
kernel/sys_ni.c +3 −0
net/netlabel/netlabel_calipso.c +26 −23
security/Makefile +1 −0
security/apparmor/include/procattr.h +1 −1
security/apparmor/lsm.c +83 −7
security/apparmor/procattr.c +6 −4
security/bpf/hooks.c +8 −1
security/commoncap.c +7 −1
security/landlock/cred.c +1 −1
security/landlock/fs.c +1 −1
security/landlock/net.c +1 −1
security/landlock/ptrace.c +1 −1
security/landlock/setup.c +6 −0
security/landlock/setup.h +1 −0
security/loadpin/loadpin.c +8 −1
security/lockdown/lockdown.c +7 −1
security/lsm_syscalls.c +120 −0
security/safesetid/lsm.c +8 −1
security/security.c +261 −12
security/selinux/hooks.c +145 −28
security/smack/smack_lsm.c +87 −6
security/tomoyo/tomoyo.c +9 −1
security/yama/yama_lsm.c +7 −1
tools/perf/arch/mips/entry/syscalls/syscall_n64.tbl +5 −0
tools/perf/arch/powerpc/entry/syscalls/syscall.tbl +5 −0
tools/perf/arch/s390/entry/syscalls/syscall.tbl +5 −0
tools/perf/arch/x86/entry/syscalls/syscall_64.tbl +5 −0
tools/testing/selftests/Makefile +1 −0
tools/testing/selftests/lsm/.gitignore +1 −0
tools/testing/selftests/lsm/Makefile +17 −0
tools/testing/selftests/lsm/common.c +89 −0
tools/testing/selftests/lsm/common.h +33 −0
tools/testing/selftests/lsm/config +3 −0
tools/testing/selftests/lsm/lsm_get_self_attr_test.c +275 −0
tools/testing/selftests/lsm/lsm_list_modules_test.c +137 −0
tools/testing/selftests/lsm/lsm_set_self_attr_test.c +74 −0

.mailmap+4−0

 Paul E. McKenney <paulmck@kernel.org> <paulmck@us.ibm.com>
 Paul Mackerras <paulus@ozlabs.org> <paulus@samba.org>
 Paul Mackerras <paulus@ozlabs.org> <paulus@au1.ibm.com>
+Paul Moore <paul@paul-moore.com> <paul.moore@hp.com>
+Paul Moore <paul@paul-moore.com> <pmoore@redhat.com>
 Pavankumar Kondeti <quic_pkondeti@quicinc.com> <pkondeti@codeaurora.org>
 Peter A Jonsson <pj@ludd.ltu.se>
 Peter Oruba <peter.oruba@amd.com>
 Sebastian Reichel <sre@kernel.org> <sre@debian.org>
 Sedat Dilek <sedat.dilek@gmail.com> <sedat.dilek@credativ.de>
 Senthilkumar N L <quic_snlakshm@quicinc.com> <snlakshm@codeaurora.org>
+Serge Hallyn <sergeh@kernel.org> <serge.hallyn@canonical.com>
+Serge Hallyn <sergeh@kernel.org> <serue@us.ibm.com>
 Seth Forshee <sforshee@kernel.org> <seth.forshee@canonical.com>
 Shannon Nelson <shannon.nelson@amd.com> <snelson@pensando.io>
 Shannon Nelson <shannon.nelson@amd.com> <shannon.nelson@intel.com>

Documentation/userspace-api/index.rst+1−0

@@ -33,6 +33,7 @@ place where this information is gathered. · 32 unmodified lines
33	sysfs-platform_profile	33	sysfs-platform_profile
34	vduse	34	vduse
35	futex2	35	futex2
		36	lsm
36		37
37	.. only:: subproject and html	38	.. only:: subproject and html
38		39

Documentation/userspace-api/lsm.rst+73−0

@@ -0,0 +1,73 @@
	1	.. SPDX-License-Identifier: GPL-2.0
	2	.. Copyright (C) 2022 Casey Schaufler <casey@schaufler-ca.com>
	3	.. Copyright (C) 2022 Intel Corporation
	4
	5	=====================================
	6	Linux Security Modules
	7	=====================================
	8
	9	:Author: Casey Schaufler
	10	:Date: July 2023
	11
	12	Linux security modules (LSM) provide a mechanism to implement
	13	additional access controls to the Linux security policies.
	14
	15	The various security modules may support any of these attributes:
	16
	17	``LSM_ATTR_CURRENT`` is the current, active security context of the
	18	process.
	19	The proc filesystem provides this value in ``/proc/self/attr/current``.
	20	This is supported by the SELinux, Smack and AppArmor security modules.
	21	Smack also provides this value in ``/proc/self/attr/smack/current``.
	22	AppArmor also provides this value in ``/proc/self/attr/apparmor/current``.
	23
	24	``LSM_ATTR_EXEC`` is the security context of the process at the time the
	25	current image was executed.
	26	The proc filesystem provides this value in ``/proc/self/attr/exec``.
	27	This is supported by the SELinux and AppArmor security modules.
	28	AppArmor also provides this value in ``/proc/self/attr/apparmor/exec``.
	29
	30	``LSM_ATTR_FSCREATE`` is the security context of the process used when
	31	creating file system objects.
	32	The proc filesystem provides this value in ``/proc/self/attr/fscreate``.
	33	This is supported by the SELinux security module.
	34
	35	``LSM_ATTR_KEYCREATE`` is the security context of the process used when
	36	creating key objects.
	37	The proc filesystem provides this value in ``/proc/self/attr/keycreate``.
	38	This is supported by the SELinux security module.
	39
	40	``LSM_ATTR_PREV`` is the security context of the process at the time the
	41	current security context was set.
	42	The proc filesystem provides this value in ``/proc/self/attr/prev``.
	43	This is supported by the SELinux and AppArmor security modules.
	44	AppArmor also provides this value in ``/proc/self/attr/apparmor/prev``.
	45
	46	``LSM_ATTR_SOCKCREATE`` is the security context of the process used when
	47	creating socket objects.
	48	The proc filesystem provides this value in ``/proc/self/attr/sockcreate``.
	49	This is supported by the SELinux security module.
	50
	51	Kernel interface
	52	================
	53
	54	Set a security attribute of the current process
	55	-----------------------------------------------
	56
	57	.. kernel-doc:: security/lsm_syscalls.c
	58	:identifiers: sys_lsm_set_self_attr
	59
	60	Get the specified security attributes of the current process
	61	------------------------------------------------------------
	62
	63	.. kernel-doc:: security/lsm_syscalls.c
	64	:identifiers: sys_lsm_get_self_attr
	65
	66	.. kernel-doc:: security/lsm_syscalls.c
	67	:identifiers: sys_lsm_list_modules
	68
	69	Additional documentation
	70	========================
	71
	72	* Documentation/security/lsm.rst
	73	* Documentation/security/lsm-development.rst

MAINTAINERS+14−3

 F:	Documentation/admin-guide/LSM/LoadPin.rst
 F:	security/loadpin/
+LOCKDOWN SECURITY MODULE
+L:	linux-security-module@vger.kernel.org
+S:	Odd Fixes
+T:	git https://git.kernel.org/pub/scm/linux/kernel/git/pcmoore/lsm.git
+F:	security/lockdown/
 LOCKING PRIMITIVES
 M:	Peter Zijlstra <peterz@infradead.org>
 M:	Ingo Molnar <mingo@redhat.com>
 M:	Paul Moore <paul@paul-moore.com>
 M:	James Morris <jmorris@namei.org>
 M:	"Serge E. Hallyn" <serge@hallyn.com>
-L:	linux-security-module@vger.kernel.org (suggested Cc:)
+L:	linux-security-module@vger.kernel.org
 S:	Supported
-W:	http://kernsec.org/
+Q:	https://patchwork.kernel.org/project/linux-security-module/list
-T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pcmoore/lsm.git
+B:	mailto:linux-security-module@vger.kernel.org
+P:	https://github.com/LinuxSecurityModule/kernel/blob/main/README.md
+T:	git https://git.kernel.org/pub/scm/linux/kernel/git/pcmoore/lsm.git
+F:	include/uapi/linux/lsm.h
 F:	security/
+F:	tools/testing/selftests/lsm/
 X:	security/selinux/
+K:	\bsecurity_[a-z_0-9]\+\b
 SELINUX SECURITY MODULE
 M:	Paul Moore <paul@paul-moore.com>

arch/alpha/kernel/syscalls/syscall.tbl+3−0

@@ -498,3 +498,6 @@ · 497 unmodified lines
498	566 common futex_requeue sys_futex_requeue	498	566 common futex_requeue sys_futex_requeue
499	567 common statmount sys_statmount	499	567 common statmount sys_statmount
500	568 common listmount sys_listmount	500	568 common listmount sys_listmount
		501	569 common lsm_get_self_attr sys_lsm_get_self_attr
		502	570 common lsm_set_self_attr sys_lsm_set_self_attr
		503	571 common lsm_list_modules sys_lsm_list_modules

arch/arm/tools/syscall.tbl+3−0

@@ -472,3 +472,6 @@ · 471 unmodified lines
472	456 common futex_requeue sys_futex_requeue	472	456 common futex_requeue sys_futex_requeue
473	457 common statmount sys_statmount	473	457 common statmount sys_statmount
474	458 common listmount sys_listmount	474	458 common listmount sys_listmount
		475	459 common lsm_get_self_attr sys_lsm_get_self_attr
		476	460 common lsm_set_self_attr sys_lsm_set_self_attr
		477	461 common lsm_list_modules sys_lsm_list_modules

arch/arm64/include/asm/unistd.h+1−1

@@ -39,7 +39,7 @@ · 38 unmodified lines
39	#define __ARM_NR_compat_set_tls (__ARM_NR_COMPAT_BASE + 5)	39	#define __ARM_NR_compat_set_tls (__ARM_NR_COMPAT_BASE + 5)
40	#define __ARM_NR_COMPAT_END (__ARM_NR_COMPAT_BASE + 0x800)	40	#define __ARM_NR_COMPAT_END (__ARM_NR_COMPAT_BASE + 0x800)
41		41
42	#define __NR_compat_syscalls 459	42	#define __NR_compat_syscalls 462
43	#endif	43	#endif
44		44
45	#define __ARCH_WANT_SYS_CLONE	45	#define __ARCH_WANT_SYS_CLONE

arch/arm64/include/asm/unistd32.h+6−0

 __SYSCALL(__NR_statmount, sys_statmount)
 #define __NR_listmount 458
 __SYSCALL(__NR_listmount, sys_listmount)
+#define __NR_lsm_get_self_attr 459
+__SYSCALL(__NR_lsm_get_self_attr, sys_lsm_get_self_attr)
+#define __NR_lsm_set_self_attr 460
+__SYSCALL(__NR_lsm_set_self_attr, sys_lsm_set_self_attr)
+#define __NR_lsm_list_modules 461
+__SYSCALL(__NR_lsm_list_modules, sys_lsm_list_modules)
 /*
  * Please add new compat syscalls above this comment and update

arch/m68k/kernel/syscalls/syscall.tbl+3−0

@@ -458,3 +458,6 @@ · 457 unmodified lines
458	456 common futex_requeue sys_futex_requeue	458	456 common futex_requeue sys_futex_requeue
459	457 common statmount sys_statmount	459	457 common statmount sys_statmount
460	458 common listmount sys_listmount	460	458 common listmount sys_listmount
		461	459 common lsm_get_self_attr sys_lsm_get_self_attr
		462	460 common lsm_set_self_attr sys_lsm_set_self_attr
		463	461 common lsm_list_modules sys_lsm_list_modules

arch/microblaze/kernel/syscalls/syscall.tbl+3−0

@@ -464,3 +464,6 @@ · 463 unmodified lines
464	456 common futex_requeue sys_futex_requeue	464	456 common futex_requeue sys_futex_requeue
465	457 common statmount sys_statmount	465	457 common statmount sys_statmount
466	458 common listmount sys_listmount	466	458 common listmount sys_listmount
		467	459 common lsm_get_self_attr sys_lsm_get_self_attr
		468	460 common lsm_set_self_attr sys_lsm_set_self_attr
		469	461 common lsm_list_modules sys_lsm_list_modules

arch/mips/kernel/syscalls/syscall_n32.tbl+3−0

@@ -397,3 +397,6 @@ · 396 unmodified lines
397	456 n32 futex_requeue sys_futex_requeue	397	456 n32 futex_requeue sys_futex_requeue
398	457 n32 statmount sys_statmount	398	457 n32 statmount sys_statmount
399	458 n32 listmount sys_listmount	399	458 n32 listmount sys_listmount
		400	459 n32 lsm_get_self_attr sys_lsm_get_self_attr
		401	460 n32 lsm_set_self_attr sys_lsm_set_self_attr
		402	461 n32 lsm_list_modules sys_lsm_list_modules

arch/mips/kernel/syscalls/syscall_n64.tbl+3−0

@@ -373,3 +373,6 @@ · 372 unmodified lines
373	456 n64 futex_requeue sys_futex_requeue	373	456 n64 futex_requeue sys_futex_requeue
374	457 n64 statmount sys_statmount	374	457 n64 statmount sys_statmount
375	458 n64 listmount sys_listmount	375	458 n64 listmount sys_listmount
		376	459 n64 lsm_get_self_attr sys_lsm_get_self_attr
		377	460 n64 lsm_set_self_attr sys_lsm_set_self_attr
		378	461 n64 lsm_list_modules sys_lsm_list_modules

arch/mips/kernel/syscalls/syscall_o32.tbl+3−0

@@ -446,3 +446,6 @@ · 445 unmodified lines
446	456 o32 futex_requeue sys_futex_requeue	446	456 o32 futex_requeue sys_futex_requeue
447	457 o32 statmount sys_statmount	447	457 o32 statmount sys_statmount
448	458 o32 listmount sys_listmount	448	458 o32 listmount sys_listmount
		449	459 o32 lsm_get_self_attr sys_lsm_get_self_attr
		450	460 o32 lsm_set_self_attr sys_lsm_set_self_attr
		451	461 o32 lsm_list_modules sys_lsm_list_modules

arch/parisc/kernel/syscalls/syscall.tbl+3−0

@@ -457,3 +457,6 @@ · 456 unmodified lines
457	456 common futex_requeue sys_futex_requeue	457	456 common futex_requeue sys_futex_requeue
458	457 common statmount sys_statmount	458	457 common statmount sys_statmount
459	458 common listmount sys_listmount	459	458 common listmount sys_listmount
		460	459 common lsm_get_self_attr sys_lsm_get_self_attr
		461	460 common lsm_set_self_attr sys_lsm_set_self_attr
		462	461 common lsm_list_modules sys_lsm_list_modules

arch/powerpc/kernel/syscalls/syscall.tbl+3−0

@@ -545,3 +545,6 @@ · 544 unmodified lines
545	456 common futex_requeue sys_futex_requeue	545	456 common futex_requeue sys_futex_requeue
546	457 common statmount sys_statmount	546	457 common statmount sys_statmount
547	458 common listmount sys_listmount	547	458 common listmount sys_listmount
		548	459 common lsm_get_self_attr sys_lsm_get_self_attr
		549	460 common lsm_set_self_attr sys_lsm_set_self_attr
		550	461 common lsm_list_modules sys_lsm_list_modules

arch/s390/kernel/syscalls/syscall.tbl+3−0

@@ -461,3 +461,6 @@ · 460 unmodified lines
461	456 common futex_requeue sys_futex_requeue sys_futex_requeue	461	456 common futex_requeue sys_futex_requeue sys_futex_requeue
462	457 common statmount sys_statmount sys_statmount	462	457 common statmount sys_statmount sys_statmount
463	458 common listmount sys_listmount sys_listmount	463	458 common listmount sys_listmount sys_listmount
		464	459 common lsm_get_self_attr sys_lsm_get_self_attr sys_lsm_get_self_attr
		465	460 common lsm_set_self_attr sys_lsm_set_self_attr sys_lsm_set_self_attr
		466	461 common lsm_list_modules sys_lsm_list_modules sys_lsm_list_modules

arch/sh/kernel/syscalls/syscall.tbl+3−0

@@ -461,3 +461,6 @@ · 460 unmodified lines
461	456 common futex_requeue sys_futex_requeue	461	456 common futex_requeue sys_futex_requeue
462	457 common statmount sys_statmount	462	457 common statmount sys_statmount
463	458 common listmount sys_listmount	463	458 common listmount sys_listmount
		464	459 common lsm_get_self_attr sys_lsm_get_self_attr
		465	460 common lsm_set_self_attr sys_lsm_set_self_attr
		466	461 common lsm_list_modules sys_lsm_list_modules

arch/sparc/kernel/syscalls/syscall.tbl+3−0

@@ -504,3 +504,6 @@ · 503 unmodified lines
504	456 common futex_requeue sys_futex_requeue	504	456 common futex_requeue sys_futex_requeue
505	457 common statmount sys_statmount	505	457 common statmount sys_statmount
506	458 common listmount sys_listmount	506	458 common listmount sys_listmount
		507	459 common lsm_get_self_attr sys_lsm_get_self_attr
		508	460 common lsm_set_self_attr sys_lsm_set_self_attr
		509	461 common lsm_list_modules sys_lsm_list_modules

arch/x86/entry/syscalls/syscall_32.tbl+3−0

@@ -463,3 +463,6 @@ · 462 unmodified lines
463	456 i386 futex_requeue sys_futex_requeue	463	456 i386 futex_requeue sys_futex_requeue
464	457 i386 statmount sys_statmount	464	457 i386 statmount sys_statmount
465	458 i386 listmount sys_listmount	465	458 i386 listmount sys_listmount
		466	459 i386 lsm_get_self_attr sys_lsm_get_self_attr
		467	460 i386 lsm_set_self_attr sys_lsm_set_self_attr
		468	461 i386 lsm_list_modules sys_lsm_list_modules

arch/x86/entry/syscalls/syscall_64.tbl+3−0

 456	common	futex_requeue		sys_futex_requeue
 457	common	statmount		sys_statmount
 458	common	listmount		sys_listmount
+459	common	lsm_get_self_attr	sys_lsm_get_self_attr
+460	common	lsm_set_self_attr	sys_lsm_set_self_attr
+461	common	lsm_list_modules	sys_lsm_list_modules
 #
 # Due to a historical design error, certain syscalls are numbered differently

arch/xtensa/kernel/syscalls/syscall.tbl+3−0

@@ -429,3 +429,6 @@ · 428 unmodified lines
429	456 common futex_requeue sys_futex_requeue	429	456 common futex_requeue sys_futex_requeue
430	457 common statmount sys_statmount	430	457 common statmount sys_statmount
431	458 common listmount sys_listmount	431	458 common listmount sys_listmount
		432	459 common lsm_get_self_attr sys_lsm_get_self_attr
		433	460 common lsm_set_self_attr sys_lsm_set_self_attr
		434	461 common lsm_list_modules sys_lsm_list_modules

fs/ioctl.c+1−2

@@ -920,8 +920,7 @@ COMPAT_SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, · 919 unmodified lines
920	if (!f.file)	920	if (!f.file)
921	return -EBADF;	921	return -EBADF;
922		922
923	/* RED-PEN how should LSM module know it's handling 32bit? */	923	error = security_file_ioctl_compat(f.file, cmd, arg);
924	error = security_file_ioctl(f.file, cmd, arg);
925	if (error)	924	if (error)
926	goto out;	925	goto out;
927		926

fs/proc/base.c+15−14

 #include <linux/resctrl.h>
 #include <linux/cn_proc.h>
 #include <linux/ksm.h>
+#include <uapi/linux/lsm.h>
 #include <trace/events/oom.h>
 #include "internal.h"
 #include "fd.h"
 	NOD(NAME, (S_IFREG|(MODE)),			\
 		NULL, &proc_single_file_operations,	\
 		{ .proc_show = show } )
-#define ATTR(LSM, NAME, MODE)				\
+#define ATTR(LSMID, NAME, MODE)				\
 	NOD(NAME, (S_IFREG|(MODE)),			\
 		NULL, &proc_pid_attr_operations,	\
-		{ .lsm = LSM })
+		{ .lsmid = LSMID })
 /*
  * Count the number of hardlinks for the pid_entry table, excluding the .
 	if (!task)
 		return -ESRCH;
-	length = security_getprocattr(task, PROC_I(inode)->op.lsm,
+	length = security_getprocattr(task, PROC_I(inode)->op.lsmid,
 				      file->f_path.dentry->d_name.name,
 				      &p);
 	put_task_struct(task);
 	if (rv < 0)
 		goto out_free;
-	rv = security_setprocattr(PROC_I(inode)->op.lsm,
+	rv = security_setprocattr(PROC_I(inode)->op.lsmid,
 				  file->f_path.dentry->d_name.name, page,
 				  count);
 	mutex_unlock(&current->signal->cred_guard_mutex);
 #ifdef CONFIG_SECURITY_SMACK
 static const struct pid_entry smack_attr_dir_stuff[] = {
-	ATTR("smack", "current",	0666),
+	ATTR(LSM_ID_SMACK, "current",	0666),
 };
 LSM_DIR_OPS(smack);
 #endif
 #ifdef CONFIG_SECURITY_APPARMOR
 static const struct pid_entry apparmor_attr_dir_stuff[] = {
-	ATTR("apparmor", "current",	0666),
+	ATTR(LSM_ID_APPARMOR, "current",	0666),
-	ATTR("apparmor", "prev",	0444),
+	ATTR(LSM_ID_APPARMOR, "prev",		0444),
-	ATTR("apparmor", "exec",	0666),
+	ATTR(LSM_ID_APPARMOR, "exec",		0666),
 };
 LSM_DIR_OPS(apparmor);
 #endif
 static const struct pid_entry attr_dir_stuff[] = {
-	ATTR(NULL, "current",		0666),
+	ATTR(LSM_ID_UNDEF, "current",	0666),
-	ATTR(NULL, "prev",		0444),
+	ATTR(LSM_ID_UNDEF, "prev",		0444),
-	ATTR(NULL, "exec",		0666),
+	ATTR(LSM_ID_UNDEF, "exec",		0666),
-	ATTR(NULL, "fscreate",		0666),
+	ATTR(LSM_ID_UNDEF, "fscreate",	0666),
-	ATTR(NULL, "keycreate",		0666),
+	ATTR(LSM_ID_UNDEF, "keycreate",	0666),
-	ATTR(NULL, "sockcreate",	0666),
+	ATTR(LSM_ID_UNDEF, "sockcreate",	0666),
 #ifdef CONFIG_SECURITY_SMACK
 	DIR("smack",			0555,
 	    proc_smack_attr_dir_inode_ops, proc_smack_attr_dir_ops),

fs/proc/internal.h+1−1

@@ -92,7 +92,7 @@ union proc_op { · 91 unmodified lines
92	int (proc_show)(struct seq_file m,	92	int (proc_show)(struct seq_file m,
93	struct pid_namespace ns, struct pid pid,	93	struct pid_namespace ns, struct pid pid,
94	struct task_struct *task);	94	struct task_struct *task);
95	const char *lsm;	95	int lsmid;
96	};	96	};
97		97
98	struct proc_inode {	98	struct proc_inode {

include/linux/lsm_hook_defs.h+6−0

 LSM_HOOK(void, LSM_RET_VOID, file_free_security, struct file *file)
 LSM_HOOK(int, 0, file_ioctl, struct file *file, unsigned int cmd,
 	 unsigned long arg)
+LSM_HOOK(int, 0, file_ioctl_compat, struct file *file, unsigned int cmd,
+	 unsigned long arg)
 LSM_HOOK(int, 0, mmap_addr, unsigned long addr)
 LSM_HOOK(int, 0, mmap_file, struct file *file, unsigned long reqprot,
 	 unsigned long prot, unsigned long flags)
 LSM_HOOK(int, 0, netlink_send, struct sock *sk, struct sk_buff *skb)
 LSM_HOOK(void, LSM_RET_VOID, d_instantiate, struct dentry *dentry,
 	 struct inode *inode)
+LSM_HOOK(int, -EOPNOTSUPP, getselfattr, unsigned int attr,
+	 struct lsm_ctx __user *ctx, size_t *size, u32 flags)
+LSM_HOOK(int, -EOPNOTSUPP, setselfattr, unsigned int attr,
+	 struct lsm_ctx *ctx, size_t size, u32 flags)
 LSM_HOOK(int, -EINVAL, getprocattr, struct task_struct *p, const char *name,
 	 char **value)
 LSM_HOOK(int, -EINVAL, setprocattr, const char *name, void *value, size_t size)

include/linux/lsm_hooks.h+15−2

 #ifndef __LINUX_LSM_HOOKS_H
 #define __LINUX_LSM_HOOKS_H
+#include <uapi/linux/lsm.h>
 #include <linux/security.h>
 #include <linux/init.h>
 #include <linux/rculist.h>
 	#undef LSM_HOOK
 } __randomize_layout;
+/**
+ * struct lsm_id - Identify a Linux Security Module.
+ * @lsm: name of the LSM, must be approved by the LSM maintainers
+ * @id: LSM ID number from uapi/linux/lsm.h
+ *
+ * Contains the information that identifies the LSM.
+ */
+struct lsm_id {
+	const char	*name;
+	u64		id;
+};
 /*
  * Security module hook list structure.
  * For use with generic list macros for common operations.
 	struct hlist_node		list;
 	struct hlist_head		*head;
 	union security_list_options	hook;
-	const char			*lsm;
+	const struct lsm_id		*lsmid;
 } __randomize_layout;
 /*
 extern char *lsm_names;
 extern void security_add_hooks(struct security_hook_list *hooks, int count,
-				const char *lsm);
+			       const struct lsm_id *lsmid);
 #define LSM_FLAG_LEGACY_MAJOR	BIT(0)
 #define LSM_FLAG_EXCLUSIVE	BIT(1)

include/linux/security.h+50−6

 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/sockptr.h>
+#include <uapi/linux/lsm.h>
 struct linux_binprm;
 struct cred;
 enum fs_value_type;
 struct watch;
 struct watch_notification;
+struct lsm_ctx;
 /* Default (no) options for the capable function */
 #define CAP_OPT_NONE 0x0
 };
 extern const char *const lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1];
+extern u32 lsm_active_cnt;
+extern const struct lsm_id *lsm_idlist[];
 /* These functions are in security/commoncap.c */
 extern int cap_capable(const struct cred *cred, struct user_namespace *ns,
 /* prototypes */
 extern int security_init(void);
 extern int early_security_init(void);
+extern u64 lsm_name_to_attr(const char *name);
 /* Security operations */
 int security_binder_set_context_mgr(const struct cred *mgr);
 int security_file_alloc(struct file *file);
 void security_file_free(struct file *file);
 int security_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
+int security_file_ioctl_compat(struct file *file, unsigned int cmd,
+			       unsigned long arg);
 int security_mmap_file(struct file *file, unsigned long prot,
 			unsigned long flags);
 int security_mmap_addr(unsigned long addr);
 int security_sem_semop(struct kern_ipc_perm *sma, struct sembuf *sops,
 			unsigned nsops, int alter);
 void security_d_instantiate(struct dentry *dentry, struct inode *inode);
-int security_getprocattr(struct task_struct *p, const char *lsm, const char *name,
+int security_getselfattr(unsigned int attr, struct lsm_ctx __user *ctx,
+			 size_t __user *size, u32 flags);
+int security_setselfattr(unsigned int attr, struct lsm_ctx __user *ctx,
+			 size_t size, u32 flags);
+int security_getprocattr(struct task_struct *p, int lsmid, const char *name,
 			 char **value);
-int security_setprocattr(const char *lsm, const char *name, void *value,
+int security_setprocattr(int lsmid, const char *name, void *value, size_t size);
-			 size_t size);
 int security_netlink_send(struct sock *sk, struct sk_buff *skb);
 int security_ismaclabel(const char *name);
 int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen);
 int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen);
 int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen);
 int security_locked_down(enum lockdown_reason what);
+int lsm_fill_user_ctx(struct lsm_ctx __user *uctx, size_t *uctx_len,
+		      void *val, size_t val_len, u64 id, u64 flags);
 #else /* CONFIG_SECURITY */
 static inline int call_blocking_lsm_notifier(enum lsm_event event, void *data)
 	return 0;
 }
+static inline u64 lsm_name_to_attr(const char *name)
+{
+	return LSM_ATTR_UNDEF;
+}
 static inline void security_free_mnt_opts(void **mnt_opts)
 {
 }
 	return 0;
 }
+static inline int security_file_ioctl_compat(struct file *file,
+					     unsigned int cmd,
+					     unsigned long arg)
+{
+	return 0;
+}
 static inline int security_mmap_file(struct file *file, unsigned long prot,
 				     unsigned long flags)
 {
 					  struct inode *inode)
 { }
-static inline int security_getprocattr(struct task_struct *p, const char *lsm,
+static inline int security_getselfattr(unsigned int attr,
+				       struct lsm_ctx __user *ctx,
+				       size_t __user *size, u32 flags)
+{
+	return -EOPNOTSUPP;
+}
+static inline int security_setselfattr(unsigned int attr,
+				       struct lsm_ctx __user *ctx,
+				       size_t size, u32 flags)
+{
+	return -EOPNOTSUPP;
+}
+static inline int security_getprocattr(struct task_struct *p, int lsmid,
 				       const char *name, char **value)
 {
 	return -EINVAL;
 }
-static inline int security_setprocattr(const char *lsm, char *name,
+static inline int security_setprocattr(int lsmid, char *name, void *value,
-				       void *value, size_t size)
+				       size_t size)
 {
 	return -EINVAL;
 }
 {
 	return 0;
 }
+static inline int lsm_fill_user_ctx(struct lsm_ctx __user *uctx,
+				    size_t *uctx_len, void *val, size_t val_len,
+				    u64 id, u64 flags)
+{
+	return -EOPNOTSUPP;
+}
 #endif	/* CONFIG_SECURITY */
 #if defined(CONFIG_SECURITY) && defined(CONFIG_WATCH_QUEUE)

include/linux/syscalls.h+6−0

 struct open_how;
 struct mount_attr;
 struct landlock_ruleset_attr;
+struct lsm_ctx;
 enum landlock_rule_type;
 struct cachestat_range;
 struct cachestat;
 		struct cachestat_range __user *cstat_range,
 		struct cachestat __user *cstat, unsigned int flags);
 asmlinkage long sys_map_shadow_stack(unsigned long addr, unsigned long size, unsigned int flags);
+asmlinkage long sys_lsm_get_self_attr(unsigned int attr, struct lsm_ctx *ctx,
+				      size_t *size, __u32 flags);
+asmlinkage long sys_lsm_set_self_attr(unsigned int attr, struct lsm_ctx *ctx,
+				      size_t size, __u32 flags);
+asmlinkage long sys_lsm_list_modules(u64 *ids, size_t *size, u32 flags);
 /*
  * Architecture-specific system calls

include/uapi/asm-generic/unistd.h+8−1

 #define __NR_listmount   458
 __SYSCALL(__NR_listmount, sys_listmount)
+#define __NR_lsm_get_self_attr 459
+__SYSCALL(__NR_lsm_get_self_attr, sys_lsm_get_self_attr)
+#define __NR_lsm_set_self_attr 460
+__SYSCALL(__NR_lsm_set_self_attr, sys_lsm_set_self_attr)
+#define __NR_lsm_list_modules 461
+__SYSCALL(__NR_lsm_list_modules, sys_lsm_list_modules)
 #undef __NR_syscalls
-#define __NR_syscalls 459
+#define __NR_syscalls 462
 /*
  * 32 bit systems traditionally used different

include/uapi/linux/lsm.h+90−0

@@ -0,0 +1,90 @@
	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
	2	/*
	3	* Linux Security Modules (LSM) - User space API
	4	*
	5	* Copyright (C) 2022 Casey Schaufler <casey@schaufler-ca.com>
	6	* Copyright (C) 2022 Intel Corporation
	7	*/
	8
	9	#ifndef _UAPI_LINUX_LSM_H
	10	#define _UAPI_LINUX_LSM_H
	11
	12	#include <linux/stddef.h>
	13	#include <linux/types.h>
	14	#include <linux/unistd.h>
	15
	16	/**
	17	* struct lsm_ctx - LSM context information
	18	* @id: the LSM id number, see LSM_ID_XXX
	19	* @flags: LSM specific flags
	20	* @len: length of the lsm_ctx struct, @ctx and any other data or padding
	21	* @ctx_len: the size of @ctx
	22	* @ctx: the LSM context value
	23	*
	24	* The @len field MUST be equal to the size of the lsm_ctx struct
	25	* plus any additional padding and/or data placed after @ctx.
	26	*
	27	* In all cases @ctx_len MUST be equal to the length of @ctx.
	28	* If @ctx is a string value it should be nul terminated with
	29	* @ctx_len equal to `strlen(@ctx) + 1`. Binary values are
	30	* supported.
	31	*
	32	* The @flags and @ctx fields SHOULD only be interpreted by the
	33	* LSM specified by @id; they MUST be set to zero/0 when not used.
	34	*/
	35	struct lsm_ctx {
	36	__u64 id;
	37	__u64 flags;
	38	__u64 len;
	39	__u64 ctx_len;
	40	__u8 ctx[] __counted_by(ctx_len);
	41	};
	42
	43	/*
	44	* ID tokens to identify Linux Security Modules (LSMs)
	45	*
	46	* These token values are used to uniquely identify specific LSMs
	47	* in the kernel as well as in the kernel's LSM userspace API.
	48	*
	49	* A value of zero/0 is considered undefined and should not be used
	50	* outside the kernel. Values 1-99 are reserved for potential
	51	* future use.
	52	*/
	53	#define LSM_ID_UNDEF 0
	54	#define LSM_ID_CAPABILITY 100
	55	#define LSM_ID_SELINUX 101
	56	#define LSM_ID_SMACK 102
	57	#define LSM_ID_TOMOYO 103
	58	#define LSM_ID_APPARMOR 104
	59	#define LSM_ID_YAMA 105
	60	#define LSM_ID_LOADPIN 106
	61	#define LSM_ID_SAFESETID 107
	62	#define LSM_ID_LOCKDOWN 108
	63	#define LSM_ID_BPF 109
	64	#define LSM_ID_LANDLOCK 110
	65
	66	/*
	67	* LSM_ATTR_XXX definitions identify different LSM attributes
	68	* which are used in the kernel's LSM userspace API. Support
	69	* for these attributes vary across the different LSMs. None
	70	* are required.
	71	*
	72	* A value of zero/0 is considered undefined and should not be used
	73	* outside the kernel. Values 1-99 are reserved for potential
	74	* future use.
	75	*/
	76	#define LSM_ATTR_UNDEF 0
	77	#define LSM_ATTR_CURRENT 100
	78	#define LSM_ATTR_EXEC 101
	79	#define LSM_ATTR_FSCREATE 102
	80	#define LSM_ATTR_KEYCREATE 103
	81	#define LSM_ATTR_PREV 104
	82	#define LSM_ATTR_SOCKCREATE 105
	83
	84	/*
	85	* LSM_FLAG_XXX definitions identify special handling instructions
	86	* for the API.
	87	*/
	88	#define LSM_FLAG_SINGLE 0x0001
	89
	90	#endif /* _UAPI_LINUX_LSM_H */

kernel/sys_ni.c+3−0

 COND_SYSCALL(landlock_restrict_self);
 COND_SYSCALL(fadvise64_64);
 COND_SYSCALL_COMPAT(fadvise64_64);
+COND_SYSCALL(lsm_get_self_attr);
+COND_SYSCALL(lsm_set_self_attr);
+COND_SYSCALL(lsm_list_modules);
 /* CONFIG_MMU only */
 COND_SYSCALL(swapon);

net/netlabel/netlabel_calipso.c+26−23

 	[NLBL_CALIPSO_A_MTYPE] = { .type = NLA_U32 },
 };
+static const struct netlbl_calipso_ops *calipso_ops;
+/**
+ * netlbl_calipso_ops_register - Register the CALIPSO operations
+ * @ops: ops to register
+ *
+ * Description:
+ * Register the CALIPSO packet engine operations.
+ *
+ */
+const struct netlbl_calipso_ops *
+netlbl_calipso_ops_register(const struct netlbl_calipso_ops *ops)
+{
+	return xchg(&calipso_ops, ops);
+}
+EXPORT_SYMBOL(netlbl_calipso_ops_register);
+static const struct netlbl_calipso_ops *netlbl_calipso_ops_get(void)
+{
+	return READ_ONCE(calipso_ops);
+}
 /* NetLabel Command Handlers
  */
 /**
  *
  */
 static int netlbl_calipso_add(struct sk_buff *skb, struct genl_info *info)
 {
 	int ret_val = -EINVAL;
 	struct netlbl_audit audit_info;
+	const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
 	if (!info->attrs[NLBL_CALIPSO_A_DOI] ||
 	    !info->attrs[NLBL_CALIPSO_A_MTYPE])
 		return -EINVAL;
+	if (!ops)
+		return -EOPNOTSUPP;
 	netlbl_netlink_auditinfo(&audit_info);
 	switch (nla_get_u32(info->attrs[NLBL_CALIPSO_A_MTYPE])) {
 	case CALIPSO_MAP_PASS:
 	return genl_register_family(&netlbl_calipso_gnl_family);
 }
-static const struct netlbl_calipso_ops *calipso_ops;
-/**
- * netlbl_calipso_ops_register - Register the CALIPSO operations
- * @ops: ops to register
- *
- * Description:
- * Register the CALIPSO packet engine operations.
- *
- */
-const struct netlbl_calipso_ops *
-netlbl_calipso_ops_register(const struct netlbl_calipso_ops *ops)
-{
-	return xchg(&calipso_ops, ops);
-}
-EXPORT_SYMBOL(netlbl_calipso_ops_register);
-static const struct netlbl_calipso_ops *netlbl_calipso_ops_get(void)
-{
-	return READ_ONCE(calipso_ops);
-}
 /**
  * calipso_doi_add - Add a new DOI to the CALIPSO protocol engine
  * @doi_def: the DOI structure

security/Makefile+1−0

@@ -7,6 +7,7 @@ obj-$(CONFIG_KEYS) += keys/ · 6 unmodified lines
7		7
8	# always enable default capabilities	8	# always enable default capabilities
9	obj-y += commoncap.o	9	obj-y += commoncap.o
		10	obj-$(CONFIG_SECURITY) += lsm_syscalls.o
10	obj-$(CONFIG_MMU) += min_addr.o	11	obj-$(CONFIG_MMU) += min_addr.o
11		12
12	# Object file lists	13	# Object file lists

security/apparmor/include/procattr.h+1−1

@@ -11,7 +11,7 @@ · 10 unmodified lines
11	#ifndef __AA_PROCATTR_H	11	#ifndef __AA_PROCATTR_H
12	#define __AA_PROCATTR_H	12	#define __AA_PROCATTR_H
13		13
14	int aa_getprocattr(struct aa_label label, char *string);	14	int aa_getprocattr(struct aa_label label, char *string, bool newline);
15	int aa_setprocattr_changehat(char *args, size_t size, int flags);	15	int aa_setprocattr_changehat(char *args, size_t size, int flags);
16		16
17	#endif /* __AA_PROCATTR_H */	17	#endif /* __AA_PROCATTR_H */

security/apparmor/lsm.c+83−7

@@ -24,6 +24,7 @@ · 23 unmodified lines
24	#include <linux/zstd.h>	24	#include <linux/zstd.h>
25	#include <net/sock.h>	25	#include <net/sock.h>
26	#include <uapi/linux/mount.h>	26	#include <uapi/linux/mount.h>
		27	#include <uapi/linux/lsm.h>
27		28
28	#include "include/apparmor.h"	29	#include "include/apparmor.h"
29	#include "include/apparmorfs.h"	30	#include "include/apparmorfs.h"
@@ -775,6 +776,46 @@ static int apparmor_sb_pivotroot(const struct path *old_path, · 745 unmodified lines
775	return error;	776	return error;
776	}	777	}
777		778
		779	static int apparmor_getselfattr(unsigned int attr, struct lsm_ctx __user *lx,
		780	size_t *size, u32 flags)
		781	{
		782	int error = -ENOENT;
		783	struct aa_task_ctx *ctx = task_ctx(current);
		784	struct aa_label *label = NULL;
		785	char *value;
		786
		787	switch (attr) {
		788	case LSM_ATTR_CURRENT:
		789	label = aa_get_newest_label(cred_label(current_cred()));
		790	break;
		791	case LSM_ATTR_PREV:
		792	if (ctx->previous)
		793	label = aa_get_newest_label(ctx->previous);
		794	break;
		795	case LSM_ATTR_EXEC:
		796	if (ctx->onexec)
		797	label = aa_get_newest_label(ctx->onexec);
		798	break;
		799	default:
		800	error = -EOPNOTSUPP;
		801	break;
		802	}
		803
		804	if (label) {
		805	error = aa_getprocattr(label, &value, false);
		806	if (error > 0)
		807	error = lsm_fill_user_ctx(lx, size, value, error,
		808	LSM_ID_APPARMOR, 0);
		809	kfree(value);
		810	}
		811
		812	aa_put_label(label);
		813
		814	if (error < 0)
		815	return error;
		816	return 1;
		817	}
		818
778	static int apparmor_getprocattr(struct task_struct task, const char name,	819	static int apparmor_getprocattr(struct task_struct task, const char name,
779	char **value)	820	char **value)
780	{	821	{
@@ -794,7 +835,7 @@ static int apparmor_getprocattr(struct task_struct task, const char name, · 13 unmodified lines
794	error = -EINVAL;	835	error = -EINVAL;
795		836
796	if (label)	837	if (label)
797	error = aa_getprocattr(label, value);	838	error = aa_getprocattr(label, value, true);
798		839
799	aa_put_label(label);	840	aa_put_label(label);
800	put_cred(cred);	841	put_cred(cred);
@@ -802,8 +843,7 @@ static int apparmor_getprocattr(struct task_struct task, const char name, · 1 unmodified line
802	return error;	843	return error;
803	}	844	}
804		845
805	static int apparmor_setprocattr(const char name, void value,	846	static int do_setattr(u64 attr, void *value, size_t size)
806	size_t size)
807	{	847	{
808	char command, largs = NULL, *args = value;	848	char command, largs = NULL, *args = value;
809	size_t arg_size;	849	size_t arg_size;
@@ -834,7 +874,7 @@ static int apparmor_setprocattr(const char name, void value, · 24 unmodified lines
834	goto out;	874	goto out;
835		875
836	arg_size = size - (args - (largs ? largs : (char *) value));	876	arg_size = size - (args - (largs ? largs : (char *) value));
837	if (strcmp(name, "current") == 0) {	877	if (attr == LSM_ATTR_CURRENT) {
838	if (strcmp(command, "changehat") == 0) {	878	if (strcmp(command, "changehat") == 0) {
839	error = aa_setprocattr_changehat(args, arg_size,	879	error = aa_setprocattr_changehat(args, arg_size,
840	AA_CHANGE_NOFLAGS);	880	AA_CHANGE_NOFLAGS);
@@ -849,7 +889,7 @@ static int apparmor_setprocattr(const char name, void value, · 8 unmodified lines
849	error = aa_change_profile(args, AA_CHANGE_STACK);	889	error = aa_change_profile(args, AA_CHANGE_STACK);
850	} else	890	} else
851	goto fail;	891	goto fail;
852	} else if (strcmp(name, "exec") == 0) {	892	} else if (attr == LSM_ATTR_EXEC) {
853	if (strcmp(command, "exec") == 0)	893	if (strcmp(command, "exec") == 0)
854	error = aa_change_profile(args, AA_CHANGE_ONEXEC);	894	error = aa_change_profile(args, AA_CHANGE_ONEXEC);
855	else if (strcmp(command, "stack") == 0)	895	else if (strcmp(command, "stack") == 0)
@@ -869,13 +909,42 @@ out: · 13 unmodified lines
869		909
870	fail:	910	fail:
871	ad.subj_label = begin_current_label_crit_section();	911	ad.subj_label = begin_current_label_crit_section();
872	ad.info = name;	912	if (attr == LSM_ATTR_CURRENT)
		913	ad.info = "current";
		914	else if (attr == LSM_ATTR_EXEC)
		915	ad.info = "exec";
		916	else
		917	ad.info = "invalid";
873	ad.error = error = -EINVAL;	918	ad.error = error = -EINVAL;
874	aa_audit_msg(AUDIT_APPARMOR_DENIED, &ad, NULL);	919	aa_audit_msg(AUDIT_APPARMOR_DENIED, &ad, NULL);
875	end_current_label_crit_section(ad.subj_label);	920	end_current_label_crit_section(ad.subj_label);
876	goto out;	921	goto out;
877	}	922	}
878		923
		924	static int apparmor_setselfattr(unsigned int attr, struct lsm_ctx *ctx,
		925	size_t size, u32 flags)
		926	{
		927	int rc;
		928
		929	if (attr != LSM_ATTR_CURRENT && attr != LSM_ATTR_EXEC)
		930	return -EOPNOTSUPP;
		931
		932	rc = do_setattr(attr, ctx->ctx, ctx->ctx_len);
		933	if (rc > 0)
		934	return 0;
		935	return rc;
		936	}
		937
		938	static int apparmor_setprocattr(const char name, void value,
		939	size_t size)
		940	{
		941	int attr = lsm_name_to_attr(name);
		942
		943	if (attr)
		944	return do_setattr(attr, value, size);
		945	return -EINVAL;
		946	}
		947
879	/**	948	/**
880	* apparmor_bprm_committing_creds - do task cleanup on committing new creds	949	* apparmor_bprm_committing_creds - do task cleanup on committing new creds
881	* @bprm: binprm for the exec (NOT NULL)	950	* @bprm: binprm for the exec (NOT NULL)
@@ -1385,6 +1454,11 @@ struct lsm_blob_sizes apparmor_blob_sizes __ro_after_init = { · 503 unmodified lines
1385	.lbs_task = sizeof(struct aa_task_ctx),	1454	.lbs_task = sizeof(struct aa_task_ctx),
1386	};	1455	};
1387		1456
		1457	static const struct lsm_id apparmor_lsmid = {
		1458	.name = "apparmor",
		1459	.id = LSM_ID_APPARMOR,
		1460	};
		1461
1388	static struct security_hook_list apparmor_hooks[] __ro_after_init = {	1462	static struct security_hook_list apparmor_hooks[] __ro_after_init = {
1389	LSM_HOOK_INIT(ptrace_access_check, apparmor_ptrace_access_check),	1463	LSM_HOOK_INIT(ptrace_access_check, apparmor_ptrace_access_check),
1390	LSM_HOOK_INIT(ptrace_traceme, apparmor_ptrace_traceme),	1464	LSM_HOOK_INIT(ptrace_traceme, apparmor_ptrace_traceme),
@@ -1418,6 +1492,8 @@ static struct security_hook_list apparmor_hooks[] __ro_after_init = { · 27 unmodified lines
1418	LSM_HOOK_INIT(file_lock, apparmor_file_lock),	1492	LSM_HOOK_INIT(file_lock, apparmor_file_lock),
1419	LSM_HOOK_INIT(file_truncate, apparmor_file_truncate),	1493	LSM_HOOK_INIT(file_truncate, apparmor_file_truncate),
1420		1494
		1495	LSM_HOOK_INIT(getselfattr, apparmor_getselfattr),
		1496	LSM_HOOK_INIT(setselfattr, apparmor_setselfattr),
1421	LSM_HOOK_INIT(getprocattr, apparmor_getprocattr),	1497	LSM_HOOK_INIT(getprocattr, apparmor_getprocattr),
1422	LSM_HOOK_INIT(setprocattr, apparmor_setprocattr),	1498	LSM_HOOK_INIT(setprocattr, apparmor_setprocattr),
1423		1499
@@ -2202,7 +2278,7 @@ static int __init apparmor_init(void) · 778 unmodified lines
2202	goto buffers_out;	2278	goto buffers_out;
2203	}	2279	}
2204	security_add_hooks(apparmor_hooks, ARRAY_SIZE(apparmor_hooks),	2280	security_add_hooks(apparmor_hooks, ARRAY_SIZE(apparmor_hooks),
2205	"apparmor");	2281	&apparmor_lsmid);
2206		2282
2207	/* Report that AppArmor successfully initialized */	2283	/* Report that AppArmor successfully initialized */
2208	apparmor_initialized = 1;	2284	apparmor_initialized = 1;

security/apparmor/procattr.c+6−4

  * aa_getprocattr - Return the label information for @label
  * @label: the label to print label info about  (NOT NULL)
  * @string: Returns - string containing the label info (NOT NULL)
+ * @newline: indicates that a newline should be added
  *
  * Requires: label != NULL && string != NULL
  *
  *
  * Returns: size of string placed in @string else error code on failure
  */
-int aa_getprocattr(struct aa_label *label, char **string)
+int aa_getprocattr(struct aa_label *label, char **string, bool newline)
 {
 	struct aa_ns *ns = labels_ns(label);
 	struct aa_ns *current_ns = aa_get_current_ns();
 		return len;
 	}
-	(*string)[len] = '\n';
+	if (newline)
-	(*string)[len + 1] = 0;
+		(*string)[len++] = '\n';
+	(*string)[len] = 0;
 	aa_put_ns(current_ns);
-	return len + 1;
+	return len;
 }
 /**

security/bpf/hooks.c+8−1

  */
 #include <linux/lsm_hooks.h>
 #include <linux/bpf_lsm.h>
+#include <uapi/linux/lsm.h>
 static struct security_hook_list bpf_lsm_hooks[] __ro_after_init = {
 	#define LSM_HOOK(RET, DEFAULT, NAME, ...) \
 	LSM_HOOK_INIT(task_free, bpf_task_storage_free),
 };
+static const struct lsm_id bpf_lsmid = {
+	.name = "bpf",
+	.id = LSM_ID_BPF,
+};
 static int __init bpf_lsm_init(void)
 {
-	security_add_hooks(bpf_lsm_hooks, ARRAY_SIZE(bpf_lsm_hooks), "bpf");
+	security_add_hooks(bpf_lsm_hooks, ARRAY_SIZE(bpf_lsm_hooks),
+			   &bpf_lsmid);
 	pr_info("LSM support for eBPF active\n");
 	return 0;
 }

security/commoncap.c+7−1

 #include <linux/binfmts.h>
 #include <linux/personality.h>
 #include <linux/mnt_idmapping.h>
+#include <uapi/linux/lsm.h>
 /*
  * If a non-root user executes a setuid-root binary in
 #ifdef CONFIG_SECURITY
+static const struct lsm_id capability_lsmid = {
+	.name = "capability",
+	.id = LSM_ID_CAPABILITY,
+};
 static struct security_hook_list capability_hooks[] __ro_after_init = {
 	LSM_HOOK_INIT(capable, cap_capable),
 	LSM_HOOK_INIT(settime, cap_settime),
 static int __init capability_init(void)
 {
 	security_add_hooks(capability_hooks, ARRAY_SIZE(capability_hooks),
-				"capability");
+			   &capability_lsmid);
 	return 0;
 }

security/landlock/cred.c+1−1

@@ -42,5 +42,5 @@ static struct security_hook_list landlock_hooks[] __ro_after_init = { · 41 unmodified lines
42	__init void landlock_add_cred_hooks(void)	42	__init void landlock_add_cred_hooks(void)
43	{	43	{
44	security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks),	44	security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks),
45	LANDLOCK_NAME);	45	&landlock_lsmid);
46	}	46	}

security/landlock/fs.c+1−1

@@ -1223,5 +1223,5 @@ static struct security_hook_list landlock_hooks[] __ro_after_init = { · 1222 unmodified lines
1223	__init void landlock_add_fs_hooks(void)	1223	__init void landlock_add_fs_hooks(void)
1224	{	1224	{
1225	security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks),	1225	security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks),
1226	LANDLOCK_NAME);	1226	&landlock_lsmid);
1227	}	1227	}

security/landlock/net.c+1−1

@@ -196,5 +196,5 @@ static struct security_hook_list landlock_hooks[] __ro_after_init = { · 195 unmodified lines
196	__init void landlock_add_net_hooks(void)	196	__init void landlock_add_net_hooks(void)
197	{	197	{
198	security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks),	198	security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks),
199	LANDLOCK_NAME);	199	&landlock_lsmid);
200	}	200	}

security/landlock/ptrace.c+1−1

@@ -116,5 +116,5 @@ static struct security_hook_list landlock_hooks[] __ro_after_init = { · 115 unmodified lines
116	__init void landlock_add_ptrace_hooks(void)	116	__init void landlock_add_ptrace_hooks(void)
117	{	117	{
118	security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks),	118	security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks),
119	LANDLOCK_NAME);	119	&landlock_lsmid);
120	}	120	}

security/landlock/setup.c+6−0

 #include <linux/init.h>
 #include <linux/lsm_hooks.h>
+#include <uapi/linux/lsm.h>
 #include "common.h"
 #include "cred.h"
 	.lbs_superblock = sizeof(struct landlock_superblock_security),
 };
+const struct lsm_id landlock_lsmid = {
+	.name = LANDLOCK_NAME,
+	.id = LSM_ID_LANDLOCK,
+};
 static int __init landlock_init(void)
 {
 	landlock_add_cred_hooks();

security/landlock/setup.h+1−0

@@ -14,5 +14,6 @@ · 13 unmodified lines
14	extern bool landlock_initialized;	14	extern bool landlock_initialized;
15		15
16	extern struct lsm_blob_sizes landlock_blob_sizes;	16	extern struct lsm_blob_sizes landlock_blob_sizes;
		17	extern const struct lsm_id landlock_lsmid;
17		18
18	#endif /* _SECURITY_LANDLOCK_SETUP_H */	19	#endif /* _SECURITY_LANDLOCK_SETUP_H */

security/loadpin/loadpin.c+8−1

 #include <linux/string_helpers.h>
 #include <linux/dm-verity-loadpin.h>
 #include <uapi/linux/loadpin.h>
+#include <uapi/linux/lsm.h>
 #define VERITY_DIGEST_FILE_HEADER "# LOADPIN_TRUSTED_VERITY_ROOT_DIGESTS"
 	return loadpin_check(NULL, (enum kernel_read_file_id) id);
 }
+static const struct lsm_id loadpin_lsmid = {
+	.name = "loadpin",
+	.id = LSM_ID_LOADPIN,
+};
 static struct security_hook_list loadpin_hooks[] __ro_after_init = {
 	LSM_HOOK_INIT(sb_free_security, loadpin_sb_free_security),
 	LSM_HOOK_INIT(kernel_read_file, loadpin_read_file),
 	if (!register_sysctl("kernel/loadpin", loadpin_sysctl_table))
 		pr_notice("sysctl registration failed!\n");
 #endif
-	security_add_hooks(loadpin_hooks, ARRAY_SIZE(loadpin_hooks), "loadpin");
+	security_add_hooks(loadpin_hooks, ARRAY_SIZE(loadpin_hooks),
+			   &loadpin_lsmid);
 	return 0;
 }

security/lockdown/lockdown.c+7−1

 #include <linux/security.h>
 #include <linux/export.h>
 #include <linux/lsm_hooks.h>
+#include <uapi/linux/lsm.h>
 static enum lockdown_reason kernel_locked_down;
 	LSM_HOOK_INIT(locked_down, lockdown_is_locked_down),
 };
+const struct lsm_id lockdown_lsmid = {
+	.name = "lockdown",
+	.id = LSM_ID_LOCKDOWN,
+};
 static int __init lockdown_lsm_init(void)
 {
 #if defined(CONFIG_LOCK_DOWN_KERNEL_FORCE_INTEGRITY)
 	lock_kernel_down("Kernel configuration", LOCKDOWN_CONFIDENTIALITY_MAX);
 #endif
 	security_add_hooks(lockdown_hooks, ARRAY_SIZE(lockdown_hooks),
-			   "lockdown");
+			   &lockdown_lsmid);
 	return 0;
 }

security/lsm_syscalls.c+120−0

@@ -0,0 +1,120 @@
	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/*
	3	* System calls implementing the Linux Security Module API.
	4	*
	5	* Copyright (C) 2022 Casey Schaufler <casey@schaufler-ca.com>
	6	* Copyright (C) 2022 Intel Corporation
	7	*/
	8
	9	#include <asm/current.h>
	10	#include <linux/compiler_types.h>
	11	#include <linux/err.h>
	12	#include <linux/errno.h>
	13	#include <linux/security.h>
	14	#include <linux/stddef.h>
	15	#include <linux/syscalls.h>
	16	#include <linux/types.h>
	17	#include <linux/lsm_hooks.h>
	18	#include <uapi/linux/lsm.h>
	19
	20	/**
	21	* lsm_name_to_attr - map an LSM attribute name to its ID
	22	* @name: name of the attribute
	23	*
	24	* Returns the LSM attribute value associated with @name, or 0 if
	25	* there is no mapping.
	26	*/
	27	u64 lsm_name_to_attr(const char *name)
	28	{
	29	if (!strcmp(name, "current"))
	30	return LSM_ATTR_CURRENT;
	31	if (!strcmp(name, "exec"))
	32	return LSM_ATTR_EXEC;
	33	if (!strcmp(name, "fscreate"))
	34	return LSM_ATTR_FSCREATE;
	35	if (!strcmp(name, "keycreate"))
	36	return LSM_ATTR_KEYCREATE;
	37	if (!strcmp(name, "prev"))
	38	return LSM_ATTR_PREV;
	39	if (!strcmp(name, "sockcreate"))
	40	return LSM_ATTR_SOCKCREATE;
	41	return LSM_ATTR_UNDEF;
	42	}
	43
	44	/**
	45	* sys_lsm_set_self_attr - Set current task's security module attribute
	46	* @attr: which attribute to set
	47	* @ctx: the LSM contexts
	48	* @size: size of @ctx
	49	* @flags: reserved for future use
	50	*
	51	* Sets the calling task's LSM context. On success this function
	52	* returns 0. If the attribute specified cannot be set a negative
	53	* value indicating the reason for the error is returned.
	54	*/
	55	SYSCALL_DEFINE4(lsm_set_self_attr, unsigned int, attr, struct lsm_ctx __user *,
	56	ctx, size_t, size, u32, flags)
	57	{
	58	return security_setselfattr(attr, ctx, size, flags);
	59	}
	60
	61	/**
	62	* sys_lsm_get_self_attr - Return current task's security module attributes
	63	* @attr: which attribute to return
	64	* @ctx: the user-space destination for the information, or NULL
	65	* @size: pointer to the size of space available to receive the data
	66	* @flags: special handling options. LSM_FLAG_SINGLE indicates that only
	67	* attributes associated with the LSM identified in the passed @ctx be
	68	* reported.
	69	*
	70	* Returns the calling task's LSM contexts. On success this
	71	* function returns the number of @ctx array elements. This value
	72	* may be zero if there are no LSM contexts assigned. If @size is
	73	* insufficient to contain the return data -E2BIG is returned and
	74	* @size is set to the minimum required size. In all other cases
	75	* a negative value indicating the error is returned.
	76	*/
	77	SYSCALL_DEFINE4(lsm_get_self_attr, unsigned int, attr, struct lsm_ctx __user *,
	78	ctx, size_t __user *, size, u32, flags)
	79	{
	80	return security_getselfattr(attr, ctx, size, flags);
	81	}
	82
	83	/**
	84	* sys_lsm_list_modules - Return a list of the active security modules
	85	* @ids: the LSM module ids
	86	* @size: pointer to size of @ids, updated on return
	87	* @flags: reserved for future use, must be zero
	88	*
	89	* Returns a list of the active LSM ids. On success this function
	90	* returns the number of @ids array elements. This value may be zero
	91	* if there are no LSMs active. If @size is insufficient to contain
	92	* the return data -E2BIG is returned and @size is set to the minimum
	93	* required size. In all other cases a negative value indicating the
	94	* error is returned.
	95	*/
	96	SYSCALL_DEFINE3(lsm_list_modules, u64 __user , ids, size_t __user , size,
	97	u32, flags)
	98	{
	99	size_t total_size = lsm_active_cnt * sizeof(*ids);
	100	size_t usize;
	101	int i;
	102
	103	if (flags)
	104	return -EINVAL;
	105
	106	if (get_user(usize, size))
	107	return -EFAULT;
	108
	109	if (put_user(total_size, size) != 0)
	110	return -EFAULT;
	111
	112	if (usize < total_size)
	113	return -E2BIG;
	114
	115	for (i = 0; i < lsm_active_cnt; i++)
	116	if (put_user(lsm_idlist[i]->id, ids++))
	117	return -EFAULT;
	118
	119	return lsm_active_cnt;
	120	}

security/safesetid/lsm.c+8−1

 #include <linux/ptrace.h>
 #include <linux/sched/task_stack.h>
 #include <linux/security.h>
+#include <uapi/linux/lsm.h>
 #include "lsm.h"
 /* Flag indicating whether initialization completed */
 	return 0;
 }
+static const struct lsm_id safesetid_lsmid = {
+	.name = "safesetid",
+	.id = LSM_ID_SAFESETID,
+};
 static struct security_hook_list safesetid_security_hooks[] = {
 	LSM_HOOK_INIT(task_fix_setuid, safesetid_task_fix_setuid),
 	LSM_HOOK_INIT(task_fix_setgid, safesetid_task_fix_setgid),
 static int __init safesetid_security_init(void)
 {
 	security_add_hooks(safesetid_security_hooks,
-			   ARRAY_SIZE(safesetid_security_hooks), "safesetid");
+			   ARRAY_SIZE(safesetid_security_hooks),
+			   &safesetid_lsmid);
 	/* Report that SafeSetID successfully initialized */
 	safesetid_initialized = 1;

security/security.c+261−12

@@ -34,6 +34,24 @@ · 33 unmodified lines
34	/* How many LSMs were built into the kernel? */	34	/* How many LSMs were built into the kernel? */
35	#define LSM_COUNT (__end_lsm_info - __start_lsm_info)	35	#define LSM_COUNT (__end_lsm_info - __start_lsm_info)
36		36
		37	/*
		38	* How many LSMs are built into the kernel as determined at
		39	* build time. Used to determine fixed array sizes.
		40	* The capability module is accounted for by CONFIG_SECURITY
		41	*/
		42	#define LSM_CONFIG_COUNT ( \
		43	(IS_ENABLED(CONFIG_SECURITY) ? 1 : 0) + \
		44	(IS_ENABLED(CONFIG_SECURITY_SELINUX) ? 1 : 0) + \
		45	(IS_ENABLED(CONFIG_SECURITY_SMACK) ? 1 : 0) + \
		46	(IS_ENABLED(CONFIG_SECURITY_TOMOYO) ? 1 : 0) + \
		47	(IS_ENABLED(CONFIG_SECURITY_APPARMOR) ? 1 : 0) + \
		48	(IS_ENABLED(CONFIG_SECURITY_YAMA) ? 1 : 0) + \
		49	(IS_ENABLED(CONFIG_SECURITY_LOADPIN) ? 1 : 0) + \
		50	(IS_ENABLED(CONFIG_SECURITY_SAFESETID) ? 1 : 0) + \
		51	(IS_ENABLED(CONFIG_SECURITY_LOCKDOWN_LSM) ? 1 : 0) + \
		52	(IS_ENABLED(CONFIG_BPF_LSM) ? 1 : 0) + \
		53	(IS_ENABLED(CONFIG_SECURITY_LANDLOCK) ? 1 : 0))
		54
37	/*	55	/*
38	* These are descriptions of the reasons that can be passed to the	56	* These are descriptions of the reasons that can be passed to the
39	* security_locked_down() LSM hook. Placing this array here allows	57	* security_locked_down() LSM hook. Placing this array here allows
@@ -245,6 +263,12 @@ static void __init initialize_lsm(struct lsm_info *lsm) · 205 unmodified lines
245	}	263	}
246	}	264	}
247		265
		266	/*
		267	* Current index to use while initializing the lsm id list.
		268	*/
		269	u32 lsm_active_cnt __ro_after_init;
		270	const struct lsm_id *lsm_idlist[LSM_CONFIG_COUNT];
		271
248	/* Populate ordered LSMs list from comma-separated LSM name list. */	272	/* Populate ordered LSMs list from comma-separated LSM name list. */
249	static void __init ordered_lsm_parse(const char order, const char origin)	273	static void __init ordered_lsm_parse(const char order, const char origin)
250	{	274	{
@@ -513,17 +537,29 @@ static int lsm_append(const char new, char *result) · 262 unmodified lines
513	* security_add_hooks - Add a modules hooks to the hook lists.	537	* security_add_hooks - Add a modules hooks to the hook lists.
514	* @hooks: the hooks to add	538	* @hooks: the hooks to add
515	* @count: the number of hooks to add	539	* @count: the number of hooks to add
516	* @lsm: the name of the security module	540	* @lsmid: the identification information for the security module
517	*	541	*
518	* Each LSM has to register its hooks with the infrastructure.	542	* Each LSM has to register its hooks with the infrastructure.
519	*/	543	*/
520	void __init security_add_hooks(struct security_hook_list *hooks, int count,	544	void __init security_add_hooks(struct security_hook_list *hooks, int count,
521	const char *lsm)	545	const struct lsm_id *lsmid)
522	{	546	{
523	int i;	547	int i;
524		548
		549	/*
		550	* A security module may call security_add_hooks() more
		551	* than once during initialization, and LSM initialization
		552	* is serialized. Landlock is one such case.
		553	* Look at the previous entry, if there is one, for duplication.
		554	*/
		555	if (lsm_active_cnt == 0 \|\| lsm_idlist[lsm_active_cnt - 1] != lsmid) {
		556	if (lsm_active_cnt >= LSM_CONFIG_COUNT)
		557	panic("%s Too many LSMs registered.\n", __func__);
		558	lsm_idlist[lsm_active_cnt++] = lsmid;
		559	}
		560
525	for (i = 0; i < count; i++) {	561	for (i = 0; i < count; i++) {
526	hooks[i].lsm = lsm;	562	hooks[i].lsmid = lsmid;
527	hlist_add_tail_rcu(&hooks[i].list, hooks[i].head);	563	hlist_add_tail_rcu(&hooks[i].list, hooks[i].head);
528	}	564	}
529		565
@@ -532,7 +568,7 @@ void __init security_add_hooks(struct security_hook_list *hooks, int count, · 2 unmodified lines
532	* and fix this up afterwards.	568	* and fix this up afterwards.
533	*/	569	*/
534	if (slab_is_available()) {	570	if (slab_is_available()) {
535	if (lsm_append(lsm, &lsm_names) < 0)	571	if (lsm_append(lsmid->name, &lsm_names) < 0)
536	panic("%s - Cannot get early memory.\n", __func__);	572	panic("%s - Cannot get early memory.\n", __func__);
537	}	573	}
538	}	574	}
@@ -734,6 +770,54 @@ static int lsm_superblock_alloc(struct super_block *sb) · 195 unmodified lines
734	return 0;	770	return 0;
735	}	771	}
736		772
		773	/**
		774	* lsm_fill_user_ctx - Fill a user space lsm_ctx structure
		775	* @uctx: a userspace LSM context to be filled
		776	* @uctx_len: available uctx size (input), used uctx size (output)
		777	* @val: the new LSM context value
		778	* @val_len: the size of the new LSM context value
		779	* @id: LSM id
		780	* @flags: LSM defined flags
		781	*
		782	* Fill all of the fields in a userspace lsm_ctx structure.
		783	*
		784	* Returns 0 on success, -E2BIG if userspace buffer is not large enough,
		785	* -EFAULT on a copyout error, -ENOMEM if memory can't be allocated.
		786	*/
		787	int lsm_fill_user_ctx(struct lsm_ctx __user uctx, size_t uctx_len,
		788	void *val, size_t val_len,
		789	u64 id, u64 flags)
		790	{
		791	struct lsm_ctx *nctx = NULL;
		792	size_t nctx_len;
		793	int rc = 0;
		794
		795	nctx_len = ALIGN(struct_size(nctx, ctx, val_len), sizeof(void *));
		796	if (nctx_len > *uctx_len) {
		797	rc = -E2BIG;
		798	goto out;
		799	}
		800
		801	nctx = kzalloc(nctx_len, GFP_KERNEL);
		802	if (nctx == NULL) {
		803	rc = -ENOMEM;
		804	goto out;
		805	}
		806	nctx->id = id;
		807	nctx->flags = flags;
		808	nctx->len = nctx_len;
		809	nctx->ctx_len = val_len;
		810	memcpy(nctx->ctx, val, val_len);
		811
		812	if (copy_to_user(uctx, nctx, nctx_len))
		813	rc = -EFAULT;
		814
		815	out:
		816	kfree(nctx);
		817	*uctx_len = nctx_len;
		818	return rc;
		819	}
		820
737	/*	821	/*
738	* The default value of the LSM hook is defined in linux/lsm_hook_defs.h and	822	* The default value of the LSM hook is defined in linux/lsm_hook_defs.h and
739	* can be accessed with:	823	* can be accessed with:
@@ -2642,6 +2726,24 @@ int security_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg) · 1902 unmodified lines
2642	}	2726	}
2643	EXPORT_SYMBOL_GPL(security_file_ioctl);	2727	EXPORT_SYMBOL_GPL(security_file_ioctl);
2644		2728
		2729	/**
		2730	* security_file_ioctl_compat() - Check if an ioctl is allowed in compat mode
		2731	* @file: associated file
		2732	* @cmd: ioctl cmd
		2733	* @arg: ioctl arguments
		2734	*
		2735	* Compat version of security_file_ioctl() that correctly handles 32-bit
		2736	* processes running on 64-bit kernels.
		2737	*
		2738	* Return: Returns 0 if permission is granted.
		2739	*/
		2740	int security_file_ioctl_compat(struct file *file, unsigned int cmd,
		2741	unsigned long arg)
		2742	{
		2743	return call_int_hook(file_ioctl_compat, 0, file, cmd, arg);
		2744	}
		2745	EXPORT_SYMBOL_GPL(security_file_ioctl_compat);
		2746
2645	static inline unsigned long mmap_prot(struct file *file, unsigned long prot)	2747	static inline unsigned long mmap_prot(struct file *file, unsigned long prot)
2646	{	2748	{
2647	/*	2749	/*
@@ -3794,10 +3896,158 @@ void security_d_instantiate(struct dentry dentry, struct inode inode) · 1146 unmodified lines
3794	}	3896	}
3795	EXPORT_SYMBOL(security_d_instantiate);	3897	EXPORT_SYMBOL(security_d_instantiate);
3796		3898
		3899	/*
		3900	* Please keep this in sync with it's counterpart in security/lsm_syscalls.c
		3901	*/
		3902
		3903	/**
		3904	* security_getselfattr - Read an LSM attribute of the current process.
		3905	* @attr: which attribute to return
		3906	* @uctx: the user-space destination for the information, or NULL
		3907	* @size: pointer to the size of space available to receive the data
		3908	* @flags: special handling options. LSM_FLAG_SINGLE indicates that only
		3909	* attributes associated with the LSM identified in the passed @ctx be
		3910	* reported.
		3911	*
		3912	* A NULL value for @uctx can be used to get both the number of attributes
		3913	* and the size of the data.
		3914	*
		3915	* Returns the number of attributes found on success, negative value
		3916	* on error. @size is reset to the total size of the data.
		3917	* If @size is insufficient to contain the data -E2BIG is returned.
		3918	*/
		3919	int security_getselfattr(unsigned int attr, struct lsm_ctx __user *uctx,
		3920	size_t __user *size, u32 flags)
		3921	{
		3922	struct security_hook_list *hp;
		3923	struct lsm_ctx lctx = { .id = LSM_ID_UNDEF, };
		3924	u8 __user base = (u8 __user )uctx;
		3925	size_t total = 0;
		3926	size_t entrysize;
		3927	size_t left;
		3928	bool toobig = false;
		3929	bool single = false;
		3930	int count = 0;
		3931	int rc;
		3932
		3933	if (attr == LSM_ATTR_UNDEF)
		3934	return -EINVAL;
		3935	if (size == NULL)
		3936	return -EINVAL;
		3937	if (get_user(left, size))
		3938	return -EFAULT;
		3939
		3940	if (flags) {
		3941	/*
		3942	* Only flag supported is LSM_FLAG_SINGLE
		3943	*/
		3944	if (flags != LSM_FLAG_SINGLE \|\| !uctx)
		3945	return -EINVAL;
		3946	if (copy_from_user(&lctx, uctx, sizeof(lctx)))
		3947	return -EFAULT;
		3948	/*
		3949	* If the LSM ID isn't specified it is an error.
		3950	*/
		3951	if (lctx.id == LSM_ID_UNDEF)
		3952	return -EINVAL;
		3953	single = true;
		3954	}
		3955
		3956	/*
		3957	* In the usual case gather all the data from the LSMs.
		3958	* In the single case only get the data from the LSM specified.
		3959	*/
		3960	hlist_for_each_entry(hp, &security_hook_heads.getselfattr, list) {
		3961	if (single && lctx.id != hp->lsmid->id)
		3962	continue;
		3963	entrysize = left;
		3964	if (base)
		3965	uctx = (struct lsm_ctx __user *)(base + total);
		3966	rc = hp->hook.getselfattr(attr, uctx, &entrysize, flags);
		3967	if (rc == -EOPNOTSUPP) {
		3968	rc = 0;
		3969	continue;
		3970	}
		3971	if (rc == -E2BIG) {
		3972	rc = 0;
		3973	left = 0;
		3974	toobig = true;
		3975	} else if (rc < 0)
		3976	return rc;
		3977	else
		3978	left -= entrysize;
		3979
		3980	total += entrysize;
		3981	count += rc;
		3982	if (single)
		3983	break;
		3984	}
		3985	if (put_user(total, size))
		3986	return -EFAULT;
		3987	if (toobig)
		3988	return -E2BIG;
		3989	if (count == 0)
		3990	return LSM_RET_DEFAULT(getselfattr);
		3991	return count;
		3992	}
		3993
		3994	/*
		3995	* Please keep this in sync with it's counterpart in security/lsm_syscalls.c
		3996	*/
		3997
		3998	/**
		3999	* security_setselfattr - Set an LSM attribute on the current process.
		4000	* @attr: which attribute to set
		4001	* @uctx: the user-space source for the information
		4002	* @size: the size of the data
		4003	* @flags: reserved for future use, must be 0
		4004	*
		4005	* Set an LSM attribute for the current process. The LSM, attribute
		4006	* and new value are included in @uctx.
		4007	*
		4008	* Returns 0 on success, -EINVAL if the input is inconsistent, -EFAULT
		4009	* if the user buffer is inaccessible, E2BIG if size is too big, or an
		4010	* LSM specific failure.
		4011	*/
		4012	int security_setselfattr(unsigned int attr, struct lsm_ctx __user *uctx,
		4013	size_t size, u32 flags)
		4014	{
		4015	struct security_hook_list *hp;
		4016	struct lsm_ctx *lctx;
		4017	int rc = LSM_RET_DEFAULT(setselfattr);
		4018
		4019	if (flags)
		4020	return -EINVAL;
		4021	if (size < sizeof(*lctx))
		4022	return -EINVAL;
		4023	if (size > PAGE_SIZE)
		4024	return -E2BIG;
		4025
		4026	lctx = memdup_user(uctx, size);
		4027	if (IS_ERR(lctx))
		4028	return PTR_ERR(lctx);
		4029
		4030	if (size < lctx->len \|\| size < lctx->ctx_len + sizeof(*lctx) \|\|
		4031	lctx->len < lctx->ctx_len + sizeof(*lctx)) {
		4032	rc = -EINVAL;
		4033	goto free_out;
		4034	}
		4035
		4036	hlist_for_each_entry(hp, &security_hook_heads.setselfattr, list)
		4037	if ((hp->lsmid->id) == lctx->id) {
		4038	rc = hp->hook.setselfattr(attr, lctx, size, flags);
		4039	break;
		4040	}
		4041
		4042	free_out:
		4043	kfree(lctx);
		4044	return rc;
		4045	}
		4046
3797	/**	4047	/**
3798	* security_getprocattr() - Read an attribute for a task	4048	* security_getprocattr() - Read an attribute for a task
3799	* @p: the task	4049	* @p: the task
3800	* @lsm: LSM name	4050	* @lsmid: LSM identification
3801	* @name: attribute name	4051	* @name: attribute name
3802	* @value: attribute value	4052	* @value: attribute value
3803	*	4053	*
@@ -3805,13 +4055,13 @@ EXPORT_SYMBOL(security_d_instantiate); · 1 unmodified line
3805	*	4055	*
3806	* Return: Returns the length of @value on success, a negative value otherwise.	4056	* Return: Returns the length of @value on success, a negative value otherwise.
3807	*/	4057	*/
3808	int security_getprocattr(struct task_struct p, const char lsm,	4058	int security_getprocattr(struct task_struct p, int lsmid, const char name,
3809	const char name, char *value)	4059	char **value)
3810	{	4060	{
3811	struct security_hook_list *hp;	4061	struct security_hook_list *hp;
3812		4062
3813	hlist_for_each_entry(hp, &security_hook_heads.getprocattr, list) {	4063	hlist_for_each_entry(hp, &security_hook_heads.getprocattr, list) {
3814	if (lsm != NULL && strcmp(lsm, hp->lsm))	4064	if (lsmid != 0 && lsmid != hp->lsmid->id)
3815	continue;	4065	continue;
3816	return hp->hook.getprocattr(p, name, value);	4066	return hp->hook.getprocattr(p, name, value);
3817	}	4067	}
@@ -3820,7 +4070,7 @@ int security_getprocattr(struct task_struct p, const char lsm, · 2 unmodified lines
3820		4070
3821	/**	4071	/**
3822	* security_setprocattr() - Set an attribute for a task	4072	* security_setprocattr() - Set an attribute for a task
3823	* @lsm: LSM name	4073	* @lsmid: LSM identification
3824	* @name: attribute name	4074	* @name: attribute name
3825	* @value: attribute value	4075	* @value: attribute value
3826	* @size: attribute value size	4076	* @size: attribute value size
@@ -3830,13 +4080,12 @@ int security_getprocattr(struct task_struct p, const char lsm, · 3 unmodified lines
3830	*	4080	*
3831	* Return: Returns bytes written on success, a negative value otherwise.	4081	* Return: Returns bytes written on success, a negative value otherwise.
3832	*/	4082	*/
3833	int security_setprocattr(const char lsm, const char name, void *value,	4083	int security_setprocattr(int lsmid, const char name, void value, size_t size)
3834	size_t size)
3835	{	4084	{
3836	struct security_hook_list *hp;	4085	struct security_hook_list *hp;
3837		4086
3838	hlist_for_each_entry(hp, &security_hook_heads.setprocattr, list) {	4087	hlist_for_each_entry(hp, &security_hook_heads.setprocattr, list) {
3839	if (lsm != NULL && strcmp(lsm, hp->lsm))	4088	if (lsmid != 0 && lsmid != hp->lsmid->id)
3840	continue;	4089	continue;
3841	return hp->hook.setprocattr(name, value, size);	4090	return hp->hook.setprocattr(name, value, size);
3842	}	4091	}

security/selinux/hooks.c+145−28

 #include <linux/fsnotify.h>
 #include <linux/fanotify.h>
 #include <linux/io_uring.h>
+#include <uapi/linux/lsm.h>
 #include "avc.h"
 #include "objsec.h"
 	return error;
 }
+static int selinux_file_ioctl_compat(struct file *file, unsigned int cmd,
+			      unsigned long arg)
+{
+	/*
+	 * If we are in a 64-bit kernel running 32-bit userspace, we need to
+	 * make sure we don't compare 32-bit flags to 64-bit flags.
+	 */
+	switch (cmd) {
+	case FS_IOC32_GETFLAGS:
+		cmd = FS_IOC_GETFLAGS;
+		break;
+	case FS_IOC32_SETFLAGS:
+		cmd = FS_IOC_SETFLAGS;
+		break;
+	case FS_IOC32_GETVERSION:
+		cmd = FS_IOC_GETVERSION;
+		break;
+	case FS_IOC32_SETVERSION:
+		cmd = FS_IOC_SETVERSION;
+		break;
+	default:
+		break;
+	}
+	return selinux_file_ioctl(file, cmd, arg);
+}
 static int default_noexec __ro_after_init;
 static int file_map_prot_check(struct file *file, unsigned long prot, int shared)
 		inode_doinit_with_dentry(inode, dentry);
 }
-static int selinux_getprocattr(struct task_struct *p,
+static int selinux_lsm_getattr(unsigned int attr, struct task_struct *p,
-			       const char *name, char **value)
+			       char **value)
 {
 	const struct task_security_struct *__tsec;
 	u32 sid;
 			goto bad;
 	}
-	if (!strcmp(name, "current"))
+	switch (attr) {
+	case LSM_ATTR_CURRENT:
 		sid = __tsec->sid;
-	else if (!strcmp(name, "prev"))
+		break;
+	case LSM_ATTR_PREV:
 		sid = __tsec->osid;
-	else if (!strcmp(name, "exec"))
+		break;
+	case LSM_ATTR_EXEC:
 		sid = __tsec->exec_sid;
-	else if (!strcmp(name, "fscreate"))
+		break;
+	case LSM_ATTR_FSCREATE:
 		sid = __tsec->create_sid;
-	else if (!strcmp(name, "keycreate"))
+		break;
+	case LSM_ATTR_KEYCREATE:
 		sid = __tsec->keycreate_sid;
-	else if (!strcmp(name, "sockcreate"))
+		break;
+	case LSM_ATTR_SOCKCREATE:
 		sid = __tsec->sockcreate_sid;
-	else {
+		break;
-		error = -EINVAL;
+	default:
+		error = -EOPNOTSUPP;
 		goto bad;
 	}
 	rcu_read_unlock();
 	return error;
 }
-static int selinux_setprocattr(const char *name, void *value, size_t size)
+static int selinux_lsm_setattr(u64 attr, void *value, size_t size)
 {
 	struct task_security_struct *tsec;
 	struct cred *new;
 	/*
 	 * Basic control over ability to set these attributes at all.
 	 */
-	if (!strcmp(name, "exec"))
+	switch (attr) {
+	case LSM_ATTR_EXEC:
 		error = avc_has_perm(mysid, mysid, SECCLASS_PROCESS,
 				     PROCESS__SETEXEC, NULL);
-	else if (!strcmp(name, "fscreate"))
+		break;
+	case LSM_ATTR_FSCREATE:
 		error = avc_has_perm(mysid, mysid, SECCLASS_PROCESS,
 				     PROCESS__SETFSCREATE, NULL);
-	else if (!strcmp(name, "keycreate"))
+		break;
+	case LSM_ATTR_KEYCREATE:
 		error = avc_has_perm(mysid, mysid, SECCLASS_PROCESS,
 				     PROCESS__SETKEYCREATE, NULL);
-	else if (!strcmp(name, "sockcreate"))
+		break;
+	case LSM_ATTR_SOCKCREATE:
 		error = avc_has_perm(mysid, mysid, SECCLASS_PROCESS,
 				     PROCESS__SETSOCKCREATE, NULL);
-	else if (!strcmp(name, "current"))
+		break;
+	case LSM_ATTR_CURRENT:
 		error = avc_has_perm(mysid, mysid, SECCLASS_PROCESS,
 				     PROCESS__SETCURRENT, NULL);
-	else
+		break;
-		error = -EINVAL;
+	default:
+		error = -EOPNOTSUPP;
+		break;
+	}
 	if (error)
 		return error;
 		}
 		error = security_context_to_sid(value, size,
 						&sid, GFP_KERNEL);
-		if (error == -EINVAL && !strcmp(name, "fscreate")) {
+		if (error == -EINVAL && attr == LSM_ATTR_FSCREATE) {
 			if (!has_cap_mac_admin(true)) {
 				struct audit_buffer *ab;
 				size_t audit_size;
-				/* We strip a nul only if it is at the end, otherwise the
+				/* We strip a nul only if it is at the end,
-				 * context contains a nul and we should audit that */
+				 * otherwise the context contains a nul and
+				 * we should audit that */
 				if (str[size - 1] == '\0')
 					audit_size = size - 1;
 				else
 				if (!ab)
 					return error;
 				audit_log_format(ab, "op=fscreate invalid_context=");
-				audit_log_n_untrustedstring(ab, value, audit_size);
+				audit_log_n_untrustedstring(ab, value,
+							    audit_size);
 				audit_log_end(ab);
 				return error;
 	   checks and may_create for the file creation checks. The
 	   operation will then fail if the context is not permitted. */
 	tsec = selinux_cred(new);
-	if (!strcmp(name, "exec")) {
+	if (attr == LSM_ATTR_EXEC) {
 		tsec->exec_sid = sid;
-	} else if (!strcmp(name, "fscreate")) {
+	} else if (attr == LSM_ATTR_FSCREATE) {
 		tsec->create_sid = sid;
-	} else if (!strcmp(name, "keycreate")) {
+	} else if (attr == LSM_ATTR_KEYCREATE) {
 		if (sid) {
 			error = avc_has_perm(mysid, sid,
 					     SECCLASS_KEY, KEY__CREATE, NULL);
 				goto abort_change;
 		}
 		tsec->keycreate_sid = sid;
-	} else if (!strcmp(name, "sockcreate")) {
+	} else if (attr == LSM_ATTR_SOCKCREATE) {
 		tsec->sockcreate_sid = sid;
-	} else if (!strcmp(name, "current")) {
+	} else if (attr == LSM_ATTR_CURRENT) {
 		error = -EINVAL;
 		if (sid == 0)
 			goto abort_change;
 	return error;
 }
+/**
+ * selinux_getselfattr - Get SELinux current task attributes
+ * @attr: the requested attribute
+ * @ctx: buffer to receive the result
+ * @size: buffer size (input), buffer size used (output)
+ * @flags: unused
+ *
+ * Fill the passed user space @ctx with the details of the requested
+ * attribute.
+ *
+ * Returns the number of attributes on success, an error code otherwise.
+ * There will only ever be one attribute.
+ */
+static int selinux_getselfattr(unsigned int attr, struct lsm_ctx __user *ctx,
+			       size_t *size, u32 flags)
+{
+	int rc;
+	char *val;
+	int val_len;
+	val_len = selinux_lsm_getattr(attr, current, &val);
+	if (val_len < 0)
+		return val_len;
+	rc = lsm_fill_user_ctx(ctx, size, val, val_len, LSM_ID_SELINUX, 0);
+	kfree(val);
+	return (!rc ? 1 : rc);
+}
+static int selinux_setselfattr(unsigned int attr, struct lsm_ctx *ctx,
+			       size_t size, u32 flags)
+{
+	int rc;
+	rc = selinux_lsm_setattr(attr, ctx->ctx, ctx->ctx_len);
+	if (rc > 0)
+		return 0;
+	return rc;
+}
+static int selinux_getprocattr(struct task_struct *p,
+			       const char *name, char **value)
+{
+	unsigned int attr = lsm_name_to_attr(name);
+	int rc;
+	if (attr) {
+		rc = selinux_lsm_getattr(attr, p, value);
+		if (rc != -EOPNOTSUPP)
+			return rc;
+	}
+	return -EINVAL;
+}
+static int selinux_setprocattr(const char *name, void *value, size_t size)
+{
+	int attr = lsm_name_to_attr(name);
+	if (attr)
+		return selinux_lsm_setattr(attr, value, size);
+	return -EINVAL;
+}
 static int selinux_ismaclabel(const char *name)
 {
 	return (strcmp(name, XATTR_SELINUX_SUFFIX) == 0);
 }
 #endif /* CONFIG_IO_URING */
+static const struct lsm_id selinux_lsmid = {
+	.name = "selinux",
+	.id = LSM_ID_SELINUX,
+};
 /*
  * IMPORTANT NOTE: When adding new hooks, please be careful to keep this order:
  * 1. any hooks that don't belong to (2.) or (3.) below,
 	LSM_HOOK_INIT(file_permission, selinux_file_permission),
 	LSM_HOOK_INIT(file_alloc_security, selinux_file_alloc_security),
 	LSM_HOOK_INIT(file_ioctl, selinux_file_ioctl),
+	LSM_HOOK_INIT(file_ioctl_compat, selinux_file_ioctl_compat),
 	LSM_HOOK_INIT(mmap_file, selinux_mmap_file),
 	LSM_HOOK_INIT(mmap_addr, selinux_mmap_addr),
 	LSM_HOOK_INIT(file_mprotect, selinux_file_mprotect),
 	LSM_HOOK_INIT(d_instantiate, selinux_d_instantiate),
+	LSM_HOOK_INIT(getselfattr, selinux_getselfattr),
+	LSM_HOOK_INIT(setselfattr, selinux_setselfattr),
 	LSM_HOOK_INIT(getprocattr, selinux_getprocattr),
 	LSM_HOOK_INIT(setprocattr, selinux_setprocattr),
 	hashtab_cache_init();
-	security_add_hooks(selinux_hooks, ARRAY_SIZE(selinux_hooks), "selinux");
+	security_add_hooks(selinux_hooks, ARRAY_SIZE(selinux_hooks),
+			   &selinux_lsmid);
 	if (avc_add_callback(selinux_netcache_avc_callback, AVC_CALLBACK_RESET))
 		panic("SELinux: Unable to register AVC netcache callback\n");

security/smack/smack_lsm.c+87−6

@@ -43,6 +43,7 @@ · 42 unmodified lines
43	#include <linux/fs_parser.h>	43	#include <linux/fs_parser.h>
44	#include <linux/watch_queue.h>	44	#include <linux/watch_queue.h>
45	#include <linux/io_uring.h>	45	#include <linux/io_uring.h>
		46	#include <uapi/linux/lsm.h>
46	#include "smack.h"	47	#include "smack.h"
47		48
48	#define TRANS_TRUE "TRUE"	49	#define TRANS_TRUE "TRUE"
@@ -3625,6 +3626,35 @@ static void smack_d_instantiate(struct dentry opt_dentry, struct inode inode) · 3576 unmodified lines
3625	return;	3626	return;
3626	}	3627	}
3627		3628
		3629	/**
		3630	* smack_getselfattr - Smack current process attribute
		3631	* @attr: which attribute to fetch
		3632	* @ctx: buffer to receive the result
		3633	* @size: available size in, actual size out
		3634	* @flags: unused
		3635	*
		3636	* Fill the passed user space @ctx with the details of the requested
		3637	* attribute.
		3638	*
		3639	* Returns the number of attributes on success, an error code otherwise.
		3640	* There will only ever be one attribute.
		3641	*/
		3642	static int smack_getselfattr(unsigned int attr, struct lsm_ctx __user *ctx,
		3643	size_t *size, u32 flags)
		3644	{
		3645	int rc;
		3646	struct smack_known *skp;
		3647
		3648	if (attr != LSM_ATTR_CURRENT)
		3649	return -EOPNOTSUPP;
		3650
		3651	skp = smk_of_current();
		3652	rc = lsm_fill_user_ctx(ctx, size,
		3653	skp->smk_known, strlen(skp->smk_known) + 1,
		3654	LSM_ID_SMACK, 0);
		3655	return (!rc ? 1 : rc);
		3656	}
		3657
3628	/**	3658	/**
3629	* smack_getprocattr - Smack process attribute access	3659	* smack_getprocattr - Smack process attribute access
3630	* @p: the object task	3660	* @p: the object task
@@ -3654,8 +3684,8 @@ static int smack_getprocattr(struct task_struct p, const char name, char **val · 23 unmodified lines
3654	}	3684	}
3655		3685
3656	/**	3686	/**
3657	* smack_setprocattr - Smack process attribute setting	3687	* do_setattr - Smack process attribute setting
3658	* @name: the name of the attribute in /proc/.../attr	3688	* @attr: the ID of the attribute
3659	* @value: the value to set	3689	* @value: the value to set
3660	* @size: the size of the value	3690	* @size: the size of the value
3661	*	3691	*
@@ -3664,7 +3694,7 @@ static int smack_getprocattr(struct task_struct p, const char name, char **val · 2 unmodified lines
3664	*	3694	*
3665	* Returns the length of the smack label or an error code	3695	* Returns the length of the smack label or an error code
3666	*/	3696	*/
3667	static int smack_setprocattr(const char name, void value, size_t size)	3697	static int do_setattr(u64 attr, void *value, size_t size)
3668	{	3698	{
3669	struct task_smack *tsp = smack_cred(current_cred());	3699	struct task_smack *tsp = smack_cred(current_cred());
3670	struct cred *new;	3700	struct cred *new;
@@ -3678,8 +3708,8 @@ static int smack_setprocattr(const char name, void value, size_t size) · 7 unmodified lines
3678	if (value == NULL \|\| size == 0 \|\| size >= SMK_LONGLABEL)	3708	if (value == NULL \|\| size == 0 \|\| size >= SMK_LONGLABEL)
3679	return -EINVAL;	3709	return -EINVAL;
3680		3710
3681	if (strcmp(name, "current") != 0)	3711	if (attr != LSM_ATTR_CURRENT)
3682	return -EINVAL;	3712	return -EOPNOTSUPP;
3683		3713
3684	skp = smk_import_entry(value, size);	3714	skp = smk_import_entry(value, size);
3685	if (IS_ERR(skp))	3715	if (IS_ERR(skp))
@@ -3718,6 +3748,49 @@ static int smack_setprocattr(const char name, void value, size_t size) · 32 unmodified lines
3718	return size;	3748	return size;
3719	}	3749	}
3720		3750
		3751	/**
		3752	* smack_setselfattr - Set a Smack process attribute
		3753	* @attr: which attribute to set
		3754	* @ctx: buffer containing the data
		3755	* @size: size of @ctx
		3756	* @flags: unused
		3757	*
		3758	* Fill the passed user space @ctx with the details of the requested
		3759	* attribute.
		3760	*
		3761	* Returns 0 on success, an error code otherwise.
		3762	*/
		3763	static int smack_setselfattr(unsigned int attr, struct lsm_ctx *ctx,
		3764	size_t size, u32 flags)
		3765	{
		3766	int rc;
		3767
		3768	rc = do_setattr(attr, ctx->ctx, ctx->ctx_len);
		3769	if (rc > 0)
		3770	return 0;
		3771	return rc;
		3772	}
		3773
		3774	/**
		3775	* smack_setprocattr - Smack process attribute setting
		3776	* @name: the name of the attribute in /proc/.../attr
		3777	* @value: the value to set
		3778	* @size: the size of the value
		3779	*
		3780	* Sets the Smack value of the task. Only setting self
		3781	* is permitted and only with privilege
		3782	*
		3783	* Returns the length of the smack label or an error code
		3784	*/
		3785	static int smack_setprocattr(const char name, void value, size_t size)
		3786	{
		3787	int attr = lsm_name_to_attr(name);
		3788
		3789	if (attr != LSM_ATTR_UNDEF)
		3790	return do_setattr(attr, value, size);
		3791	return -EINVAL;
		3792	}
		3793
3721	/**	3794	/**
3722	* smack_unix_stream_connect - Smack access on UDS	3795	* smack_unix_stream_connect - Smack access on UDS
3723	* @sock: one sock	3796	* @sock: one sock
@@ -4933,6 +5006,11 @@ struct lsm_blob_sizes smack_blob_sizes __ro_after_init = { · 1209 unmodified lines
4933	.lbs_xattr_count = SMACK_INODE_INIT_XATTRS,	5006	.lbs_xattr_count = SMACK_INODE_INIT_XATTRS,
4934	};	5007	};
4935		5008
		5009	static const struct lsm_id smack_lsmid = {
		5010	.name = "smack",
		5011	.id = LSM_ID_SMACK,
		5012	};
		5013
4936	static struct security_hook_list smack_hooks[] __ro_after_init = {	5014	static struct security_hook_list smack_hooks[] __ro_after_init = {
4937	LSM_HOOK_INIT(ptrace_access_check, smack_ptrace_access_check),	5015	LSM_HOOK_INIT(ptrace_access_check, smack_ptrace_access_check),
4938	LSM_HOOK_INIT(ptrace_traceme, smack_ptrace_traceme),	5016	LSM_HOOK_INIT(ptrace_traceme, smack_ptrace_traceme),
@@ -4973,6 +5051,7 @@ static struct security_hook_list smack_hooks[] __ro_after_init = { · 34 unmodified lines
4973		5051
4974	LSM_HOOK_INIT(file_alloc_security, smack_file_alloc_security),	5052	LSM_HOOK_INIT(file_alloc_security, smack_file_alloc_security),
4975	LSM_HOOK_INIT(file_ioctl, smack_file_ioctl),	5053	LSM_HOOK_INIT(file_ioctl, smack_file_ioctl),
		5054	LSM_HOOK_INIT(file_ioctl_compat, smack_file_ioctl),
4976	LSM_HOOK_INIT(file_lock, smack_file_lock),	5055	LSM_HOOK_INIT(file_lock, smack_file_lock),
4977	LSM_HOOK_INIT(file_fcntl, smack_file_fcntl),	5056	LSM_HOOK_INIT(file_fcntl, smack_file_fcntl),
4978	LSM_HOOK_INIT(mmap_file, smack_mmap_file),	5057	LSM_HOOK_INIT(mmap_file, smack_mmap_file),
@@ -5027,6 +5106,8 @@ static struct security_hook_list smack_hooks[] __ro_after_init = { · 48 unmodified lines
5027		5106
5028	LSM_HOOK_INIT(d_instantiate, smack_d_instantiate),	5107	LSM_HOOK_INIT(d_instantiate, smack_d_instantiate),
5029		5108
		5109	LSM_HOOK_INIT(getselfattr, smack_getselfattr),
		5110	LSM_HOOK_INIT(setselfattr, smack_setselfattr),
5030	LSM_HOOK_INIT(getprocattr, smack_getprocattr),	5111	LSM_HOOK_INIT(getprocattr, smack_getprocattr),
5031	LSM_HOOK_INIT(setprocattr, smack_setprocattr),	5112	LSM_HOOK_INIT(setprocattr, smack_setprocattr),
5032		5113
@@ -5140,7 +5221,7 @@ static __init int smack_init(void) · 107 unmodified lines
5140	/*	5221	/*
5141	* Register with LSM	5222	* Register with LSM
5142	*/	5223	*/
5143	security_add_hooks(smack_hooks, ARRAY_SIZE(smack_hooks), "smack");	5224	security_add_hooks(smack_hooks, ARRAY_SIZE(smack_hooks), &smack_lsmid);
5144	smack_enabled = 1;	5225	smack_enabled = 1;
5145		5226
5146	pr_info("Smack: Initializing.\n");	5227	pr_info("Smack: Initializing.\n");

security/tomoyo/tomoyo.c+9−1

  */
 #include <linux/lsm_hooks.h>
+#include <uapi/linux/lsm.h>
 #include "common.h"
 /**
 	}
 }
+static const struct lsm_id tomoyo_lsmid = {
+	.name = "tomoyo",
+	.id = LSM_ID_TOMOYO,
+};
 /*
  * tomoyo_security_ops is a "struct security_operations" which is used for
  * registering TOMOYO.
 	LSM_HOOK_INIT(path_rename, tomoyo_path_rename),
 	LSM_HOOK_INIT(inode_getattr, tomoyo_inode_getattr),
 	LSM_HOOK_INIT(file_ioctl, tomoyo_file_ioctl),
+	LSM_HOOK_INIT(file_ioctl_compat, tomoyo_file_ioctl),
 	LSM_HOOK_INIT(path_chmod, tomoyo_path_chmod),
 	LSM_HOOK_INIT(path_chown, tomoyo_path_chown),
 	LSM_HOOK_INIT(path_chroot, tomoyo_path_chroot),
 	struct tomoyo_task *s = tomoyo_task(current);
 	/* register ourselves with the security framework */
-	security_add_hooks(tomoyo_hooks, ARRAY_SIZE(tomoyo_hooks), "tomoyo");
+	security_add_hooks(tomoyo_hooks, ARRAY_SIZE(tomoyo_hooks),
+			   &tomoyo_lsmid);
 	pr_info("TOMOYO Linux initialized\n");
 	s->domain_info = &tomoyo_kernel_domain;
 	atomic_inc(&tomoyo_kernel_domain.users);

security/yama/yama_lsm.c+7−1

 #include <linux/task_work.h>
 #include <linux/sched.h>
 #include <linux/spinlock.h>
+#include <uapi/linux/lsm.h>
 #define YAMA_SCOPE_DISABLED	0
 #define YAMA_SCOPE_RELATIONAL	1
 	return rc;
 }
+static const struct lsm_id yama_lsmid = {
+	.name = "yama",
+	.id = LSM_ID_YAMA,
+};
 static struct security_hook_list yama_hooks[] __ro_after_init = {
 	LSM_HOOK_INIT(ptrace_access_check, yama_ptrace_access_check),
 	LSM_HOOK_INIT(ptrace_traceme, yama_ptrace_traceme),
 static int __init yama_init(void)
 {
 	pr_info("Yama: becoming mindful.\n");
-	security_add_hooks(yama_hooks, ARRAY_SIZE(yama_hooks), "yama");
+	security_add_hooks(yama_hooks, ARRAY_SIZE(yama_hooks), &yama_lsmid);
 	yama_init_sysctl();
 	return 0;
 }

tools/perf/arch/mips/entry/syscalls/syscall_n64.tbl+5−0

@@ -371,3 +371,8 @@ · 370 unmodified lines
371	454 n64 futex_wake sys_futex_wake	371	454 n64 futex_wake sys_futex_wake
372	455 n64 futex_wait sys_futex_wait	372	455 n64 futex_wait sys_futex_wait
373	456 n64 futex_requeue sys_futex_requeue	373	456 n64 futex_requeue sys_futex_requeue
		374	457 n64 statmount sys_statmount
		375	458 n64 listmount sys_listmount
		376	459 n64 lsm_get_self_attr sys_lsm_get_self_attr
		377	460 n64 lsm_set_self_attr sys_lsm_set_self_attr
		378	461 n64 lsm_list_modules sys_lsm_list_modules

tools/perf/arch/powerpc/entry/syscalls/syscall.tbl+5−0

@@ -543,3 +543,8 @@ · 542 unmodified lines
543	454 common futex_wake sys_futex_wake	543	454 common futex_wake sys_futex_wake
544	455 common futex_wait sys_futex_wait	544	455 common futex_wait sys_futex_wait
545	456 common futex_requeue sys_futex_requeue	545	456 common futex_requeue sys_futex_requeue
		546	457 common statmount sys_statmount
		547	458 common listmount sys_listmount
		548	459 common lsm_get_self_attr sys_lsm_get_self_attr
		549	460 common lsm_set_self_attr sys_lsm_set_self_attr
		550	461 common lsm_list_modules sys_lsm_list_modules

tools/perf/arch/s390/entry/syscalls/syscall.tbl+5−0

@@ -459,3 +459,8 @@ · 458 unmodified lines
459	454 common futex_wake sys_futex_wake sys_futex_wake	459	454 common futex_wake sys_futex_wake sys_futex_wake
460	455 common futex_wait sys_futex_wait sys_futex_wait	460	455 common futex_wait sys_futex_wait sys_futex_wait
461	456 common futex_requeue sys_futex_requeue sys_futex_requeue	461	456 common futex_requeue sys_futex_requeue sys_futex_requeue
		462	457 common statmount sys_statmount sys_statmount
		463	458 common listmount sys_listmount sys_listmount
		464	459 common lsm_get_self_attr sys_lsm_get_self_attr sys_lsm_get_self_attr
		465	460 common lsm_set_self_attr sys_lsm_set_self_attr sys_lsm_set_self_attr
		466	461 common lsm_list_modules sys_lsm_list_modules sys_lsm_list_modules

tools/perf/arch/x86/entry/syscalls/syscall_64.tbl+5−0

 454	common	futex_wake		sys_futex_wake
 455	common	futex_wait		sys_futex_wait
 456	common	futex_requeue		sys_futex_requeue
+457	common	statmount		sys_statmount
+458	common	listmount		sys_listmount
+459	common	lsm_get_self_attr	sys_lsm_get_self_attr
+460	common	lsm_set_self_attr	sys_lsm_set_self_attr
+461	common	lsm_list_modules	sys_lsm_list_modules
 #
 # Due to a historical design error, certain syscalls are numbered differently

tools/testing/selftests/Makefile+1−0

@@ -45,6 +45,7 @@ TARGETS += landlock · 44 unmodified lines
45	TARGETS += lib	45	TARGETS += lib
46	TARGETS += livepatch	46	TARGETS += livepatch
47	TARGETS += lkdtm	47	TARGETS += lkdtm
		48	TARGETS += lsm
48	TARGETS += membarrier	49	TARGETS += membarrier
49	TARGETS += memfd	50	TARGETS += memfd
50	TARGETS += memory-hotplug	51	TARGETS += memory-hotplug

tools/testing/selftests/lsm/.gitignore+1−0

@@ -0,0 +1 @@
		1	/*_test

tools/testing/selftests/lsm/Makefile+17−0

@@ -0,0 +1,17 @@
	1	# SPDX-License-Identifier: GPL-2.0
	2	#
	3	# First run: make -C ../../../.. headers_install
	4
	5	CFLAGS += -Wall -O2 $(KHDR_INCLUDES)
	6	LOCAL_HDRS += common.h
	7
	8	TEST_GEN_PROGS := lsm_get_self_attr_test lsm_list_modules_test \
	9	lsm_set_self_attr_test
	10
	11	include ../lib.mk
	12
	13	$(OUTPUT)/lsm_get_self_attr_test: lsm_get_self_attr_test.c common.c
	14	$(OUTPUT)/lsm_set_self_attr_test: lsm_set_self_attr_test.c common.c
	15	$(OUTPUT)/lsm_list_modules_test: lsm_list_modules_test.c common.c
	16
	17	EXTRA_CLEAN = $(OUTPUT)/common.o

tools/testing/selftests/lsm/common.c+89−0

@@ -0,0 +1,89 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Linux Security Module infrastructure tests
	4	*
	5	* Copyright © 2023 Casey Schaufler <casey@schaufler-ca.com>
	6	*/
	7
	8	#define _GNU_SOURCE
	9	#include <linux/lsm.h>
	10	#include <fcntl.h>
	11	#include <string.h>
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <unistd.h>
	15	#include <sys/types.h>
	16	#include "common.h"
	17
	18	#define PROCATTR "/proc/self/attr/"
	19
	20	int read_proc_attr(const char attr, char value, size_t size)
	21	{
	22	int fd;
	23	int len;
	24	char *path;
	25
	26	len = strlen(PROCATTR) + strlen(attr) + 1;
	27	path = calloc(len, 1);
	28	if (path == NULL)
	29	return -1;
	30	sprintf(path, "%s%s", PROCATTR, attr);
	31
	32	fd = open(path, O_RDONLY);
	33	free(path);
	34
	35	if (fd < 0)
	36	return -1;
	37	len = read(fd, value, size);
	38
	39	close(fd);
	40
	41	/* Ensure value is terminated */
	42	if (len <= 0 \|\| len == size)
	43	return -1;
	44	value[len] = '\0';
	45
	46	path = strchr(value, '\n');
	47	if (path)
	48	*path = '\0';
	49
	50	return 0;
	51	}
	52
	53	int read_sysfs_lsms(char *lsms, size_t size)
	54	{
	55	FILE *fp;
	56	size_t red;
	57
	58	fp = fopen("/sys/kernel/security/lsm", "r");
	59	if (fp == NULL)
	60	return -1;
	61	red = fread(lsms, 1, size, fp);
	62	fclose(fp);
	63
	64	if (red <= 0 \|\| red == size)
	65	return -1;
	66	lsms[red] = '\0';
	67	return 0;
	68	}
	69
	70	int attr_lsm_count(void)
	71	{
	72	char *names = calloc(sysconf(_SC_PAGESIZE), 1);
	73	int count = 0;
	74
	75	if (!names)
	76	return 0;
	77
	78	if (read_sysfs_lsms(names, sysconf(_SC_PAGESIZE)))
	79	return 0;
	80
	81	if (strstr(names, "selinux"))
	82	count++;
	83	if (strstr(names, "smack"))
	84	count++;
	85	if (strstr(names, "apparmor"))
	86	count++;
	87
	88	return count;
	89	}

tools/testing/selftests/lsm/common.h+33−0

@@ -0,0 +1,33 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Linux Security Module infrastructure tests
	4	*
	5	* Copyright © 2023 Casey Schaufler <casey@schaufler-ca.com>
	6	*/
	7
	8	#ifndef lsm_get_self_attr
	9	static inline int lsm_get_self_attr(unsigned int attr, struct lsm_ctx *ctx,
	10	size_t *size, __u32 flags)
	11	{
	12	return syscall(__NR_lsm_get_self_attr, attr, ctx, size, flags);
	13	}
	14	#endif
	15
	16	#ifndef lsm_set_self_attr
	17	static inline int lsm_set_self_attr(unsigned int attr, struct lsm_ctx *ctx,
	18	size_t size, __u32 flags)
	19	{
	20	return syscall(__NR_lsm_set_self_attr, attr, ctx, size, flags);
	21	}
	22	#endif
	23
	24	#ifndef lsm_list_modules
	25	static inline int lsm_list_modules(__u64 ids, size_t size, __u32 flags)
	26	{
	27	return syscall(__NR_lsm_list_modules, ids, size, flags);
	28	}
	29	#endif
	30
	31	extern int read_proc_attr(const char attr, char value, size_t size);
	32	extern int read_sysfs_lsms(char *lsms, size_t size);
	33	int attr_lsm_count(void);

tools/testing/selftests/lsm/config+3−0

@@ -0,0 +1,3 @@
	1	CONFIG_SYSFS=y
	2	CONFIG_SECURITY=y
	3	CONFIG_SECURITYFS=y

tools/testing/selftests/lsm/lsm_get_self_attr_test.c+275−0

@@ -0,0 +1,275 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Linux Security Module infrastructure tests
	4	* Tests for the lsm_get_self_attr system call
	5	*
	6	* Copyright © 2022 Casey Schaufler <casey@schaufler-ca.com>
	7	*/
	8
	9	#define _GNU_SOURCE
	10	#include <linux/lsm.h>
	11	#include <fcntl.h>
	12	#include <string.h>
	13	#include <stdio.h>
	14	#include <unistd.h>
	15	#include <sys/types.h>
	16	#include "../kselftest_harness.h"
	17	#include "common.h"
	18
	19	static struct lsm_ctx next_ctx(struct lsm_ctx ctxp)
	20	{
	21	void *vp;
	22
	23	vp = (void )ctxp + sizeof(ctxp) + ctxp->ctx_len;
	24	return (struct lsm_ctx *)vp;
	25	}
	26
	27	TEST(size_null_lsm_get_self_attr)
	28	{
	29	const long page_size = sysconf(_SC_PAGESIZE);
	30	struct lsm_ctx *ctx = calloc(page_size, 1);
	31
	32	ASSERT_NE(NULL, ctx);
	33	errno = 0;
	34	ASSERT_EQ(-1, lsm_get_self_attr(LSM_ATTR_CURRENT, ctx, NULL, 0));
	35	ASSERT_EQ(EINVAL, errno);
	36
	37	free(ctx);
	38	}
	39
	40	TEST(ctx_null_lsm_get_self_attr)
	41	{
	42	const long page_size = sysconf(_SC_PAGESIZE);
	43	size_t size = page_size;
	44	int rc;
	45
	46	rc = lsm_get_self_attr(LSM_ATTR_CURRENT, NULL, &size, 0);
	47
	48	if (attr_lsm_count()) {
	49	ASSERT_NE(-1, rc);
	50	ASSERT_NE(1, size);
	51	} else {
	52	ASSERT_EQ(-1, rc);
	53	}
	54	}
	55
	56	TEST(size_too_small_lsm_get_self_attr)
	57	{
	58	const long page_size = sysconf(_SC_PAGESIZE);
	59	struct lsm_ctx *ctx = calloc(page_size, 1);
	60	size_t size = 1;
	61
	62	ASSERT_NE(NULL, ctx);
	63	errno = 0;
	64	ASSERT_EQ(-1, lsm_get_self_attr(LSM_ATTR_CURRENT, ctx, &size, 0));
	65	if (attr_lsm_count()) {
	66	ASSERT_EQ(E2BIG, errno);
	67	} else {
	68	ASSERT_EQ(EOPNOTSUPP, errno);
	69	}
	70	ASSERT_NE(1, size);
	71
	72	free(ctx);
	73	}
	74
	75	TEST(flags_zero_lsm_get_self_attr)
	76	{
	77	const long page_size = sysconf(_SC_PAGESIZE);
	78	struct lsm_ctx *ctx = calloc(page_size, 1);
	79	__u64 *syscall_lsms = calloc(page_size, 1);
	80	size_t size;
	81	int lsmcount;
	82	int i;
	83
	84	ASSERT_NE(NULL, ctx);
	85	errno = 0;
	86	size = page_size;
	87	ASSERT_EQ(-1, lsm_get_self_attr(LSM_ATTR_CURRENT, ctx, &size,
	88	LSM_FLAG_SINGLE));
	89	ASSERT_EQ(EINVAL, errno);
	90	ASSERT_EQ(page_size, size);
	91
	92	lsmcount = syscall(__NR_lsm_list_modules, syscall_lsms, &size, 0);
	93	ASSERT_LE(1, lsmcount);
	94	ASSERT_NE(NULL, syscall_lsms);
	95
	96	for (i = 0; i < lsmcount; i++) {
	97	errno = 0;
	98	size = page_size;
	99	ctx->id = syscall_lsms[i];
	100
	101	if (syscall_lsms[i] == LSM_ID_SELINUX \|\|
	102	syscall_lsms[i] == LSM_ID_SMACK \|\|
	103	syscall_lsms[i] == LSM_ID_APPARMOR) {
	104	ASSERT_EQ(1, lsm_get_self_attr(LSM_ATTR_CURRENT, ctx,
	105	&size, LSM_FLAG_SINGLE));
	106	} else {
	107	ASSERT_EQ(-1, lsm_get_self_attr(LSM_ATTR_CURRENT, ctx,
	108	&size,
	109	LSM_FLAG_SINGLE));
	110	}
	111	}
	112
	113	free(ctx);
	114	}
	115
	116	TEST(flags_overset_lsm_get_self_attr)
	117	{
	118	const long page_size = sysconf(_SC_PAGESIZE);
	119	struct lsm_ctx *ctx = calloc(page_size, 1);
	120	size_t size;
	121
	122	ASSERT_NE(NULL, ctx);
	123
	124	errno = 0;
	125	size = page_size;
	126	ASSERT_EQ(-1, lsm_get_self_attr(LSM_ATTR_CURRENT \| LSM_ATTR_PREV, ctx,
	127	&size, 0));
	128	ASSERT_EQ(EOPNOTSUPP, errno);
	129
	130	errno = 0;
	131	size = page_size;
	132	ASSERT_EQ(-1, lsm_get_self_attr(LSM_ATTR_CURRENT, ctx, &size,
	133	LSM_FLAG_SINGLE \|
	134	(LSM_FLAG_SINGLE << 1)));
	135	ASSERT_EQ(EINVAL, errno);
	136
	137	free(ctx);
	138	}
	139
	140	TEST(basic_lsm_get_self_attr)
	141	{
	142	const long page_size = sysconf(_SC_PAGESIZE);
	143	size_t size = page_size;
	144	struct lsm_ctx *ctx = calloc(page_size, 1);
	145	struct lsm_ctx *tctx = NULL;
	146	__u64 *syscall_lsms = calloc(page_size, 1);
	147	char *attr = calloc(page_size, 1);
	148	int cnt_current = 0;
	149	int cnt_exec = 0;
	150	int cnt_fscreate = 0;
	151	int cnt_keycreate = 0;
	152	int cnt_prev = 0;
	153	int cnt_sockcreate = 0;
	154	int lsmcount;
	155	int count;
	156	int i;
	157
	158	ASSERT_NE(NULL, ctx);
	159	ASSERT_NE(NULL, syscall_lsms);
	160
	161	lsmcount = syscall(__NR_lsm_list_modules, syscall_lsms, &size, 0);
	162	ASSERT_LE(1, lsmcount);
	163
	164	for (i = 0; i < lsmcount; i++) {
	165	switch (syscall_lsms[i]) {
	166	case LSM_ID_SELINUX:
	167	cnt_current++;
	168	cnt_exec++;
	169	cnt_fscreate++;
	170	cnt_keycreate++;
	171	cnt_prev++;
	172	cnt_sockcreate++;
	173	break;
	174	case LSM_ID_SMACK:
	175	cnt_current++;
	176	break;
	177	case LSM_ID_APPARMOR:
	178	cnt_current++;
	179	cnt_exec++;
	180	cnt_prev++;
	181	break;
	182	default:
	183	break;
	184	}
	185	}
	186
	187	if (cnt_current) {
	188	size = page_size;
	189	count = lsm_get_self_attr(LSM_ATTR_CURRENT, ctx, &size, 0);
	190	ASSERT_EQ(cnt_current, count);
	191	tctx = ctx;
	192	ASSERT_EQ(0, read_proc_attr("current", attr, page_size));
	193	ASSERT_EQ(0, strcmp((char *)tctx->ctx, attr));
	194	for (i = 1; i < count; i++) {
	195	tctx = next_ctx(tctx);
	196	ASSERT_NE(0, strcmp((char *)tctx->ctx, attr));
	197	}
	198	}
	199	if (cnt_exec) {
	200	size = page_size;
	201	count = lsm_get_self_attr(LSM_ATTR_EXEC, ctx, &size, 0);
	202	ASSERT_GE(cnt_exec, count);
	203	if (count > 0) {
	204	tctx = ctx;
	205	if (read_proc_attr("exec", attr, page_size) == 0)
	206	ASSERT_EQ(0, strcmp((char *)tctx->ctx, attr));
	207	}
	208	for (i = 1; i < count; i++) {
	209	tctx = next_ctx(tctx);
	210	ASSERT_NE(0, strcmp((char *)tctx->ctx, attr));
	211	}
	212	}
	213	if (cnt_fscreate) {
	214	size = page_size;
	215	count = lsm_get_self_attr(LSM_ATTR_FSCREATE, ctx, &size, 0);
	216	ASSERT_GE(cnt_fscreate, count);
	217	if (count > 0) {
	218	tctx = ctx;
	219	if (read_proc_attr("fscreate", attr, page_size) == 0)
	220	ASSERT_EQ(0, strcmp((char *)tctx->ctx, attr));
	221	}
	222	for (i = 1; i < count; i++) {
	223	tctx = next_ctx(tctx);
	224	ASSERT_NE(0, strcmp((char *)tctx->ctx, attr));
	225	}
	226	}
	227	if (cnt_keycreate) {
	228	size = page_size;
	229	count = lsm_get_self_attr(LSM_ATTR_KEYCREATE, ctx, &size, 0);
	230	ASSERT_GE(cnt_keycreate, count);
	231	if (count > 0) {
	232	tctx = ctx;
	233	if (read_proc_attr("keycreate", attr, page_size) == 0)
	234	ASSERT_EQ(0, strcmp((char *)tctx->ctx, attr));
	235	}
	236	for (i = 1; i < count; i++) {
	237	tctx = next_ctx(tctx);
	238	ASSERT_NE(0, strcmp((char *)tctx->ctx, attr));
	239	}
	240	}
	241	if (cnt_prev) {
	242	size = page_size;
	243	count = lsm_get_self_attr(LSM_ATTR_PREV, ctx, &size, 0);
	244	ASSERT_GE(cnt_prev, count);
	245	if (count > 0) {
	246	tctx = ctx;
	247	ASSERT_EQ(0, read_proc_attr("prev", attr, page_size));
	248	ASSERT_EQ(0, strcmp((char *)tctx->ctx, attr));
	249	for (i = 1; i < count; i++) {
	250	tctx = next_ctx(tctx);
	251	ASSERT_NE(0, strcmp((char *)tctx->ctx, attr));
	252	}
	253	}
	254	}
	255	if (cnt_sockcreate) {
	256	size = page_size;
	257	count = lsm_get_self_attr(LSM_ATTR_SOCKCREATE, ctx, &size, 0);
	258	ASSERT_GE(cnt_sockcreate, count);
	259	if (count > 0) {
	260	tctx = ctx;
	261	if (read_proc_attr("sockcreate", attr, page_size) == 0)
	262	ASSERT_EQ(0, strcmp((char *)tctx->ctx, attr));
	263	}
	264	for (i = 1; i < count; i++) {
	265	tctx = next_ctx(tctx);
	266	ASSERT_NE(0, strcmp((char *)tctx->ctx, attr));
	267	}
	268	}
	269
	270	free(ctx);
	271	free(attr);
	272	free(syscall_lsms);
	273	}
	274
	275	TEST_HARNESS_MAIN

tools/testing/selftests/lsm/lsm_list_modules_test.c+137−0

@@ -0,0 +1,137 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Linux Security Module infrastructure tests
	4	* Tests for the lsm_list_modules system call
	5	*
	6	* Copyright © 2022 Casey Schaufler <casey@schaufler-ca.com>
	7	*/
	8
	9	#define _GNU_SOURCE
	10	#include <linux/lsm.h>
	11	#include <string.h>
	12	#include <stdio.h>
	13	#include <unistd.h>
	14	#include <sys/types.h>
	15	#include "../kselftest_harness.h"
	16	#include "common.h"
	17
	18	TEST(size_null_lsm_list_modules)
	19	{
	20	const long page_size = sysconf(_SC_PAGESIZE);
	21	__u64 *syscall_lsms = calloc(page_size, 1);
	22
	23	ASSERT_NE(NULL, syscall_lsms);
	24	errno = 0;
	25	ASSERT_EQ(-1, lsm_list_modules(syscall_lsms, NULL, 0));
	26	ASSERT_EQ(EFAULT, errno);
	27
	28	free(syscall_lsms);
	29	}
	30
	31	TEST(ids_null_lsm_list_modules)
	32	{
	33	const long page_size = sysconf(_SC_PAGESIZE);
	34	size_t size = page_size;
	35
	36	errno = 0;
	37	ASSERT_EQ(-1, lsm_list_modules(NULL, &size, 0));
	38	ASSERT_EQ(EFAULT, errno);
	39	ASSERT_NE(1, size);
	40	}
	41
	42	TEST(size_too_small_lsm_list_modules)
	43	{
	44	const long page_size = sysconf(_SC_PAGESIZE);
	45	__u64 *syscall_lsms = calloc(page_size, 1);
	46	size_t size = 1;
	47
	48	ASSERT_NE(NULL, syscall_lsms);
	49	errno = 0;
	50	ASSERT_EQ(-1, lsm_list_modules(syscall_lsms, &size, 0));
	51	ASSERT_EQ(E2BIG, errno);
	52	ASSERT_NE(1, size);
	53
	54	free(syscall_lsms);
	55	}
	56
	57	TEST(flags_set_lsm_list_modules)
	58	{
	59	const long page_size = sysconf(_SC_PAGESIZE);
	60	__u64 *syscall_lsms = calloc(page_size, 1);
	61	size_t size = page_size;
	62
	63	ASSERT_NE(NULL, syscall_lsms);
	64	errno = 0;
	65	ASSERT_EQ(-1, lsm_list_modules(syscall_lsms, &size, 7));
	66	ASSERT_EQ(EINVAL, errno);
	67	ASSERT_EQ(page_size, size);
	68
	69	free(syscall_lsms);
	70	}
	71
	72	TEST(correct_lsm_list_modules)
	73	{
	74	const long page_size = sysconf(_SC_PAGESIZE);
	75	size_t size = page_size;
	76	__u64 *syscall_lsms = calloc(page_size, 1);
	77	char *sysfs_lsms = calloc(page_size, 1);
	78	char *name;
	79	char *cp;
	80	int count;
	81	int i;
	82
	83	ASSERT_NE(NULL, sysfs_lsms);
	84	ASSERT_NE(NULL, syscall_lsms);
	85	ASSERT_EQ(0, read_sysfs_lsms(sysfs_lsms, page_size));
	86
	87	count = lsm_list_modules(syscall_lsms, &size, 0);
	88	ASSERT_LE(1, count);
	89	cp = sysfs_lsms;
	90	for (i = 0; i < count; i++) {
	91	switch (syscall_lsms[i]) {
	92	case LSM_ID_CAPABILITY:
	93	name = "capability";
	94	break;
	95	case LSM_ID_SELINUX:
	96	name = "selinux";
	97	break;
	98	case LSM_ID_SMACK:
	99	name = "smack";
	100	break;
	101	case LSM_ID_TOMOYO:
	102	name = "tomoyo";
	103	break;
	104	case LSM_ID_APPARMOR:
	105	name = "apparmor";
	106	break;
	107	case LSM_ID_YAMA:
	108	name = "yama";
	109	break;
	110	case LSM_ID_LOADPIN:
	111	name = "loadpin";
	112	break;
	113	case LSM_ID_SAFESETID:
	114	name = "safesetid";
	115	break;
	116	case LSM_ID_LOCKDOWN:
	117	name = "lockdown";
	118	break;
	119	case LSM_ID_BPF:
	120	name = "bpf";
	121	break;
	122	case LSM_ID_LANDLOCK:
	123	name = "landlock";
	124	break;
	125	default:
	126	name = "INVALID";
	127	break;
	128	}
	129	ASSERT_EQ(0, strncmp(cp, name, strlen(name)));
	130	cp += strlen(name) + 1;
	131	}
	132
	133	free(sysfs_lsms);
	134	free(syscall_lsms);
	135	}
	136
	137	TEST_HARNESS_MAIN

tools/testing/selftests/lsm/lsm_set_self_attr_test.c+74−0

@@ -0,0 +1,74 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Linux Security Module infrastructure tests
	4	* Tests for the lsm_set_self_attr system call
	5	*
	6	* Copyright © 2022 Casey Schaufler <casey@schaufler-ca.com>
	7	*/
	8
	9	#define _GNU_SOURCE
	10	#include <linux/lsm.h>
	11	#include <string.h>
	12	#include <stdio.h>
	13	#include <unistd.h>
	14	#include <sys/types.h>
	15	#include "../kselftest_harness.h"
	16	#include "common.h"
	17
	18	TEST(ctx_null_lsm_set_self_attr)
	19	{
	20	ASSERT_EQ(-1, lsm_set_self_attr(LSM_ATTR_CURRENT, NULL,
	21	sizeof(struct lsm_ctx), 0));
	22	}
	23
	24	TEST(size_too_small_lsm_set_self_attr)
	25	{
	26	const long page_size = sysconf(_SC_PAGESIZE);
	27	struct lsm_ctx *ctx = calloc(page_size, 1);
	28	size_t size = page_size;
	29
	30	ASSERT_NE(NULL, ctx);
	31	if (attr_lsm_count()) {
	32	ASSERT_LE(1, lsm_get_self_attr(LSM_ATTR_CURRENT, ctx, &size,
	33	0));
	34	}
	35	ASSERT_EQ(-1, lsm_set_self_attr(LSM_ATTR_CURRENT, ctx, 1, 0));
	36
	37	free(ctx);
	38	}
	39
	40	TEST(flags_zero_lsm_set_self_attr)
	41	{
	42	const long page_size = sysconf(_SC_PAGESIZE);
	43	struct lsm_ctx *ctx = calloc(page_size, 1);
	44	size_t size = page_size;
	45
	46	ASSERT_NE(NULL, ctx);
	47	if (attr_lsm_count()) {
	48	ASSERT_LE(1, lsm_get_self_attr(LSM_ATTR_CURRENT, ctx, &size,
	49	0));
	50	}
	51	ASSERT_EQ(-1, lsm_set_self_attr(LSM_ATTR_CURRENT, ctx, size, 1));
	52
	53	free(ctx);
	54	}
	55
	56	TEST(flags_overset_lsm_set_self_attr)
	57	{
	58	const long page_size = sysconf(_SC_PAGESIZE);
	59	char *ctx = calloc(page_size, 1);
	60	size_t size = page_size;
	61	struct lsm_ctx tctx = (struct lsm_ctx )ctx;
	62
	63	ASSERT_NE(NULL, ctx);
	64	if (attr_lsm_count()) {
	65	ASSERT_LE(1, lsm_get_self_attr(LSM_ATTR_CURRENT, tctx, &size,
	66	0));
	67	}
	68	ASSERT_EQ(-1, lsm_set_self_attr(LSM_ATTR_CURRENT \| LSM_ATTR_PREV, tctx,
	69	size, 0));
	70
	71	free(ctx);
	72	}
	73
	74	TEST_HARNESS_MAIN