前言

这篇文章介绍了LSM相关知识：Linux 安全 - LSM机制，接下来源码分析LSM模块。

一、简介

1.1 DAC 和 MAC

（1）
DAC（Discretionary Access Control）基于访问控制是一种根据主体或组的身份限制对对象访问的手段。DAC使用用户和组权限，实现访问控制。DAC的一个问题是其基本操作是可传递的。一个特权用户可以创建其他特权用户，并且这些用户可能具有对受限对象的访问权限。

传统的Linux UID/GID机制，Linux通过用户、进程、文件的UID/GID来进行权限管理的。Linux将文件的权限划分为读、写和执行三种，分别用字母r、w和x表示。每一个文件有三组读、写和执行权限，分别是针对文件的所有者(u)、文件所有者所属的组(g)以及除前两种之外的其它用户(o)。这样，如果一个用户想要将一个自己创建的文件交给另外一个用户访问，那么只需要相应地设置一下这个文件的其它用户权限位就可以了。文件的权限控制在所有者手中。

（2）
MAC（Mandatory Access Control）中，主体（例如用户、进程、线程）和对象（例如文件、套接字、内存段）都具有一组安全属性。这些安全属性通过MAC策略进行集中管理。在MAC的情况下，用户/组不做任何访问决策，而是由安全属性进行管理。

每当主体尝试访问对象时，都会由操作系统内核强 制执行授权规则–检查安全属性并决定是否可进行访问。同样，任何主体对任何对象的任何操作都将根据一组授权规则（策略）进行测试，决定操作是否被允许。

MAC提供了更严格的访问控制，它不依赖于用户或组的身份，而是根据预定义的安全策略和属性来进行访问决策。这种策略可能基于许多因素，如用户角色、标签、上下文等。通过使用MAC，可以实现更细粒度的访问控制，并提供更高的安全性，以防止特权用户滥用权限或绕过访问控制规则。

在Linux中，MAC功能由安全模块（Linux Security Module）提供，如SELinux（Security-Enhanced Linux）和AppArmor。这些安全模块通过管理对象的安全上下文和定义访问策略来实现MAC。与DAC相比，MAC提供了更强大的安全能力，特别适用于需要更严格访问控制的环境，如多用户系统、服务器和敏感数据系统。

1.2 LSM 调用流程图

LSM通过在内核代码中恰好在访问内核对象（比如inode）之前放置挂钩来调解对内核对象的访问。

当用户空间中的进程调用open()系统调用打开文件时，涉及以下步骤：

（1）用户空间中的进程调用open()系统调用，并提供文件路径作为参数。

（2）系统调度该系统调用，并使用提供的文件路径获取与文件关联的内核文件对象和inode对象。

（3）如果open()系统调用的参数不正确或无效，则返回错误。

（4）内核执行常规的"自主访问控制"（DAC）文件权限检查。它验证当前用户是否具有打开文件所需的权限。如果用户没有所需的权限，则终止系统调用，并将错误返回给用户空间。

（5）如果DAC检查通过，并且用户具有所需的权限，则Linux安全模块（LSM）框架开始工作。对于每个已启用的LSM，框架调用file_open钩子函数。每个LSM都有机会执行额外的安全检查或修改文件打开操作的行为。如果任何LSM钩子函数返回错误，则终止系统调用，并将错误返回给用户空间。

（6）最后，如果所有的安全检查，包括DAC和LSM钩子函数，都通过了，文件将被打开给进程。创建一个新的文件描述符，并返回给用户空间的进程，允许对已打开文件进行进一步操作。

当进程调用open()打开文件时，内核首先执行DAC文件权限检查，如果通过，然后调用LSM框架执行额外的安全检查。只有当所有的安全检查都通过后，文件才会被打开，并将文件描述符返回给进程。

从上图可以看出，LSM挂钩是在执行DAC和其他健全性检查之后应用的。

通过系统调用进入内核之后，系统首先进行传统的DAC权限检查（传统权限检查主要是基于用户的，用户通过验证之后就可以访问资源），通过之后才会进行MAC强制访问控制 ，从图上看来，LSM实现MAC强制访问控制主要通过LSM安全模块的钩子函数实现。

LSM是一种基于MAC的控制形式，常见的有SELinux/AppArmor。

以下是selinux LSM 简易图：

二、LSM相关数据结构

2.1 struct security_hook_list

struct hlist_node {struct hlist_node *next, **pprev;
};struct hlist_head {struct hlist_node *first;
};union security_list_options {.....int (*ptrace_access_check)(struct task_struct *child,unsigned int mode);......
}/** Security module hook list structure.* For use with generic list macros for common operations.*/
struct security_hook_list {struct hlist_node		list;struct hlist_head		*head;union security_list_options	hook;char				*lsm;
} __randomize_layout;

security_hook_list结构体用于表示安全模块钩子列表的结构。这个结构体被用于在通用的列表操作中进行常见操作。

结构体的成员含义：
（1）list：struct hlist_node类型的成员，用于将security_hook_list结构体链接到一个哈希链表中。哈希链表提供了高效的查找和插入操作。

（2）head：指向struct hlist_head类型的指针，指向哈希链表的头部。哈希链表的头部包含指向链表中第一个元素的指针。

（3）hook：union security_list_options类型的联合体，表示安全模块钩子的选项。这是一个通用的选项字段，具体的含义可能取决于具体的安全模块和使用场景。

（4）lsm：一个指向字符（char）类型的指针，用于存储与此安全模块钩子相关的LSM（Linux Security Module）的名称。LSM是Linux内核的安全模块架构，用于实现各种安全策略和功能。

（5）__randomize_layout：一个特殊的属性，用于在内存中随机化这个结构体的布局。这有助于增加系统的安全性，使攻击者更难利用结构体的布局来进行攻击。

这个结构体的设计使得可以使用通用的列表宏（generic list macros）对安全模块钩子进行常见操作，例如插入、删除和遍历。它提供了一种灵活的方式来管理安全模块钩子，并与其他系统组件进行交互。

2.2 union security_list_options

/*** union security_list_options - Linux Security Module hook function list** Security hooks for program execution operations.***/union security_list_options {int (*binder_set_context_mgr)(struct task_struct *mgr);int (*binder_transaction)(struct task_struct *from,struct task_struct *to);int (*binder_transfer_binder)(struct task_struct *from,struct task_struct *to);int (*binder_transfer_file)(struct task_struct *from,struct task_struct *to,struct file *file);int (*ptrace_access_check)(struct task_struct *child,unsigned int mode);int (*ptrace_traceme)(struct task_struct *parent);......
}

为LSM定义的安全挂钩的函数指针的联合，在内核代码中的各种关键路径上调用。

2.3 structure security_hook_heads

struct security_hook_heads {struct hlist_head binder_set_context_mgr;struct hlist_head binder_transaction;struct hlist_head binder_transfer_binder;struct hlist_head binder_transfer_file;struct hlist_head ptrace_access_check;struct hlist_head ptrace_traceme;......

该数据结构包含与每个钩子相对应的链表的头部，考虑到LSM的堆叠属性，从而允许它们以正确的顺序执行。

三、security_bprm_check

SYSCALL_DEFINE5(execveat-->do_execveat()-->do_execveat_common()-->__do_execve_file()--exec_binprm()-->search_binary_handler()-->security_bprm_check()

int security_bprm_check(struct linux_binprm *bprm)
{int ret;ret = call_int_hook(bprm_check_security, 0, bprm);if (ret)return ret;return ima_bprm_check(bprm);
}

函数 security_bprm_check 就是一个LSM HOOK 点，用于在执行二进制文件之前进行安全性检查。

struct security_hook_heads security_hook_heads __lsm_ro_after_init;

#define call_int_hook(FUNC, IRC, ...) ({			\int RC = IRC;						\do {							\struct security_hook_list *P;			\\hlist_for_each_entry(P, &security_hook_heads.FUNC, list) { \RC = P->hook.FUNC(__VA_ARGS__);		\if (RC != 0)				\break;				\}						\} while (0);						\RC;							\
})

宏 call_int_hook，用于调用安全模块的钩子函数。

这个宏的作用是依次调用安全模块的钩子函数，并将它们的返回值进行处理。

宏接受三个参数：
FUNC：安全模块钩子函数的名称。这个宏将通过 FUNC 参数拼接出对应的钩子函数列表的成员。
IRC：初始返回值（Initial Return Code）。这个值将被用作初始的返回值，如果所有的钩子函数都返回0，则最终的返回值将是初始返回值。
…：可变参数，用于传递给钩子函数的参数。

宏的工作流程如下：
使用 hlist_for_each_entry 宏遍历存储在 security_hook_heads.FUNC 中的钩子函数列表。
对于每个钩子函数，调用 P->hook.FUNC 并传递可变参数 __VA_ARGS__。
如果钩子函数的返回值 RC 不等于0，则跳出循环。

四、LSM 源码分析

start_kernel()-->early_security_init()-->security_init()/* Load LSMs in specified order. */-->ordered_lsm_init()-->initialize_lsm()-->lsm->init()-->selinux_init()-->apparmor_init()-->tomoyo_init()-->smack_init()

由于selinux、apparmor、tomoyo和smack都是LSM_FLAG_EXCLUSIVE 独占模式标志，因此只能选择其中的一个启动。

3.1 early_security_init

struct security_hook_heads security_hook_heads __lsm_ro_after_init;int __init early_security_init(void)
{int i;struct hlist_head *list = (struct hlist_head *) &security_hook_heads;struct lsm_info *lsm;for (i = 0; i < sizeof(security_hook_heads) / sizeof(struct hlist_head);i++)INIT_HLIST_HEAD(&list[i]);for (lsm = __start_early_lsm_info; lsm < __end_early_lsm_info; lsm++) {if (!lsm->enabled)lsm->enabled = &lsm_enabled_true;prepare_lsm(lsm);initialize_lsm(lsm);}return 0;
}

early_security_init函数是在系统初始化过程中早期调用的安全初始化函数。

（1）将security_hook_heads的地址强制转换为struct hlist_head指针，并将其赋值给名为list的变量。security_hook_heads是一个全局变量，它存储了一组hlist_head结构体，用于存储不同安全钩子的链表头部。

（2）循环遍历security_hook_heads数组，计算需要迭代的次数。通过sizeof(security_hook_heads)除以sizeof(struct hlist_head)，可以确定数组中有多少个hlist_head元素。

（3）INIT_HLIST_HEAD(&list[i]);：对list[i]所指向的hlist_head进行初始化，将其设置为空链表。

（4）循环遍历__start_early_lsm_info到__end_early_lsm_info之间的lsm_info结构体数组，这些结构体包含了早期加载的安全模块信息。

（5）调用prepare_lsm函数，对当前安全模块进行准备工作。

（6）调用initialize_lsm函数，对当前安全模块进行初始化。

总的来说，这段代码的作用是在系统初始化早期对安全模块进行初始化。它遍历安全钩子的链表头部，将每个链表头部初始化为空链表。然后，对早期加载的安全模块进行准备和初始化操作，确保它们的状态正确并可用于后续的安全处理。

3.2 security_init

3.2.1 security_init

LSM内核调用security_init进行LSM框架初始化，该初始化按以下顺序加载已启用的受支持的Linux安全模块：

– Capability module
– Minor LSMs
– Major LSM

// linux-5.4.18/include/asm-generic/vmlinux.lds.h#ifdef CONFIG_SECURITY
#define LSM_TABLE()	. = ALIGN(8);					\__start_lsm_info = .;				\KEEP(*(.lsm_info.init))				\__end_lsm_info = .;
#define EARLY_LSM_TABLE()	. = ALIGN(8);				\__start_early_lsm_info = .;			\KEEP(*(.early_lsm_info.init))			\__end_early_lsm_info = .;

// linux-5.4.18/include/linux/lsm_hooks.h/** Security blob size or offset data.*/
struct lsm_blob_sizes {int	lbs_cred;int	lbs_file;int	lbs_inode;int	lbs_ipc;int	lbs_msg_msg;int	lbs_task;
};enum lsm_order {LSM_ORDER_FIRST = -1,	/* This is only for capabilities. */LSM_ORDER_MUTABLE = 0,
};struct lsm_info {const char *name;	/* Required. */enum lsm_order order;	/* Optional: default is LSM_ORDER_MUTABLE */unsigned long flags;	/* Optional: flags describing LSM */int *enabled;		/* Optional: controlled by CONFIG_LSM */int (*init)(void);	/* Required. */struct lsm_blob_sizes *blobs; /* Optional: for blob sharing. */
};/*** security_init - initializes the security framework** This should be called early in the kernel initialization sequence.*/
int __init security_init(void)
{struct lsm_info *lsm;pr_info("Security Framework initializing\n");/** Append the names of the early LSM modules now that kmalloc() is* available*/for (lsm = __start_early_lsm_info; lsm < __end_early_lsm_info; lsm++) {if (lsm->enabled)lsm_append(lsm->name, &lsm_names);}/* Load LSMs in specified order. */ordered_lsm_init();return 0;
}

security_init函数用于初始化安全框架。它应该在内核初始化序列的早期调用。

（1）定义一个指向lsm_info结构体的指针变量lsm，用于遍历LSM模块的数组。循环遍历__start_early_lsm_info到__end_early_lsm_info之间的lsm_info结构体数组，这些结构体包含了早期加载的安全模块的信息。

（2）调用ordered_lsm_init函数，按照指定的顺序加载LSM模块。

这段代码的作用是初始化安全框架。它遍历早期加载的安全模块数组，将启用的模块名称追加到链表中。然后，按照指定的顺序加载LSM模块。这个函数在内核初始化的早期阶段被调用，用于确保安全框架在系统启动时得到正确的初始化。

3.2.2 ordered_lsm_init

/* Boot-time LSM user choice */
static __initdata const char *chosen_lsm_order;
static __initdata const char *chosen_major_lsm;static __initconst const char * const builtin_lsm_order = CONFIG_LSM;/* Ordered list of LSMs to initialize. */
static __initdata struct lsm_info **ordered_lsms;static void __init ordered_lsm_init(void)
{struct lsm_info **lsm;ordered_lsms = kcalloc(LSM_COUNT + 1, sizeof(*ordered_lsms),GFP_KERNEL);if (chosen_lsm_order) {if (chosen_major_lsm) {pr_info("security= is ignored because it is superseded by lsm=\n");chosen_major_lsm = NULL;}ordered_lsm_parse(chosen_lsm_order, "cmdline");} elseordered_lsm_parse(builtin_lsm_order, "builtin");for (lsm = ordered_lsms; *lsm; lsm++)prepare_lsm(*lsm);init_debug("cred blob size     = %d\n", blob_sizes.lbs_cred);init_debug("file blob size     = %d\n", blob_sizes.lbs_file);init_debug("inode blob size    = %d\n", blob_sizes.lbs_inode);init_debug("ipc blob size      = %d\n", blob_sizes.lbs_ipc);init_debug("msg_msg blob size  = %d\n", blob_sizes.lbs_msg_msg);init_debug("task blob size     = %d\n", blob_sizes.lbs_task);/** Create any kmem_caches needed for blobs*/if (blob_sizes.lbs_file)lsm_file_cache = kmem_cache_create("lsm_file_cache",blob_sizes.lbs_file, 0,SLAB_PANIC, NULL);if (blob_sizes.lbs_inode)lsm_inode_cache = kmem_cache_create("lsm_inode_cache",blob_sizes.lbs_inode, 0,SLAB_PANIC, NULL);lsm_early_cred((struct cred *) current->cred);lsm_early_task(current);for (lsm = ordered_lsms; *lsm; lsm++)initialize_lsm(*lsm);kfree(ordered_lsms);
}

ordered_lsm_init函数用于按照指定的顺序初始化LSM模块。

代码含义如下：
（1）定义一个指向lsm_info结构体指针的指针变量lsm，用于遍历LSM模块的指针数组。
（2）使用kcalloc函数为ordered_lsms分配内存，大小为LSM_COUNT + 1个指针的大小。这个数组用于存储按顺序加载的LSM模块的指针。
（3）如果存在chosen_lsm_order，表示在内核命令行中指定了LSM的加载顺序。调用ordered_lsm_parse函数解析chosen_lsm_order，解析类型为"cmdline"，将解析结果存储在ordered_lsms数组中。
（4）如果没有指定chosen_lsm_order，则使用内核编译时的默认LSM加载顺序。调用ordered_lsm_parse函数解析builtin_lsm_order，解析类型为"builtin"，将解析结果存储在ordered_lsms数组中。
（5）遍历ordered_lsms数组，对于每个非空指针，调用prepare_lsm函数进行LSM的准备工作。
（6）打印LSM需要的blob大小的调试信息，包括cred、file、inode、ipc、msg_msg和task blob的大小。
（7）如果blob_sizes.lbs_file不为0，使用kmem_cache_create函数创建一个名为lsm_file_cache的内存缓存，用于存储file blob。
（8）如果blob_sizes.lbs_inode不为0，使用kmem_cache_create函数创建一个名为lsm_inode_cache的内存缓存，用于存储inode blob。
（9）调用lsm_early_cred函数，传递当前进程的cred结构作为参数，进行早期的cred blob初始化。
（10）调用lsm_early_task函数，传递当前进程作为参数，进行早期的task blob初始化。
（11）再次遍历ordered_lsms数组，对于每个非空指针，调用initialize_lsm函数进行LSM的初始化。

这段代码的作用是按照指定的顺序初始化LSM模块。它根据指定的LSM加载顺序解析LSM模块，并进行准备工作和初始化。同时，它还创建了用于存储file blob和inode blob的内存缓存。在LSM初始化之前，它对cred blob和task blob进行了早期的初始化。完成初始化后，释放了用于存储LSM模块指针的内存。

3.2.3 initialize_lsm

/* Initialize a given LSM, if it is enabled. */
static void __init initialize_lsm(struct lsm_info *lsm)
{if (is_enabled(lsm)) {int ret;init_debug("initializing %s\n", lsm->name);ret = lsm->init();WARN(ret, "%s failed to initialize: %d\n", lsm->name, ret);}
}

lsm->init()表示调用给定LSM的初始化函数。

这个函数用于初始化给定的LSM，前提是该LSM是启用的。它首先检查LSM是否启用，然后调用LSM的初始化函数：

selinux_init()
apparmor_init()
tomoyo_init()
smack_init()

五、LSM初始化例程

5.1 selinux

/* SELinux requires early initialization in order to labelall processes and objects when they are created. */
DEFINE_LSM(selinux) = {.name = "selinux",.flags = LSM_FLAG_LEGACY_MAJOR | LSM_FLAG_EXCLUSIVE,.enabled = &selinux_enabled,.blobs = &selinux_blob_sizes,.init = selinux_init,
};

这段代码的作用是定义了一个名为selinux的LSM模块的信息结构体，并初始化了结构体的成员。

（1）.name = “selinux”：设置了name成员，表示LSM模块的名称是"selinux"。

（2）.flags = LSM_FLAG_LEGACY_MAJOR | LSM_FLAG_EXCLUSIVE：设置了flags成员，表示LSM模块的标志。LSM_FLAG_LEGACY_MAJOR标志表示该模块是遗留的主要模块，LSM_FLAG_EXCLUSIVE标志表示该模块是独占的，不与其他模块共存。比如 selinux 不能和 apparmor 同时存在。

（3）.enabled = &selinux_enabled：设置了enabled成员，指向一个名为selinux_enabled的变量。这个变量用于指示selinux模块是否启用。

（4）.blobs = &selinux_blob_sizes：设置了blobs成员，指向一个名为selinux_blob_sizes的变量。这个变量用于指定selinux模块需要的各个blob的大小。

（5）.init = selinux_init：设置了init成员，指向一个名为selinux_init的函数。这个函数用于初始化selinux模块。

通过DEFINE_LSM宏创建的结构体被赋值给selinux，从而定义了一个名为selinux的LSM模块的信息结构体。这个结构体包含了模块的名称、标志、启用状态、blob大小和初始化函数等信息。

DEFINE_LSM宏：

#define DEFINE_LSM(lsm)							\static struct lsm_info __lsm_##lsm				\__used __section(.lsm_info.init)			\__aligned(sizeof(unsigned long))

宏定义用于定义LSM模块的信息结构体，这个宏定义包含了以下几个部分：
（1）DEFINE_LSM(lsm)：定义了一个名为DEFINE_LSM的宏，宏的参数是lsm，用于指定LSM模块的名称。

（2）static struct lsm_info _lsm##lsm：定义了一个名为__lsm_加上lsm参数的结构体，该结构体用于存储LSM模块的信息。使用static关键字使结构体具有文件作用域。

（3）__used：这是一个编译器特定的属性，用于告诉编译器即使没有使用到这个结构体，也不要优化掉它。

（4）__section(.lsm_info.init)：这是一个编译器特定的属性，用于指定将这个结构体放置在名为.lsm_info.init的特定节(section)中。这个节可能是用于存放LSM模块信息的特定节。

（5）__aligned(sizeof(unsigned long))：这是一个编译器特定的属性，用于指定结构体的对齐方式。在这里，结构体的对齐方式被设置为unsigned long的大小。

这个宏定义用于创建一个静态的LSM信息结构体，该结构体存储了LSM模块的相关信息，并通过编译器的属性设置将它放置在特定的节中。这个宏定义通常用于在LSM模块的源文件中定义LSM信息结构体。

static __init int selinux_init(void)
{security_add_hooks(selinux_hooks, ARRAY_SIZE(selinux_hooks), "selinux");
}

/*** security_add_hooks - Add a modules hooks to the hook lists.* @hooks: the hooks to add* @count: the number of hooks to add* @lsm: the name of the security module** Each LSM has to register its hooks with the infrastructure.*/
void __init security_add_hooks(struct security_hook_list *hooks, int count,char *lsm)
{int i;for (i = 0; i < count; i++) {hooks[i].lsm = lsm;hlist_add_tail_rcu(&hooks[i].list, hooks[i].head);}......
}

/** Security module hook list structure.* For use with generic list macros for common operations.*/
struct security_hook_list {struct hlist_node		list;struct hlist_head		*head;union security_list_options	hook;char				*lsm;
} __randomize_layout;

static struct security_hook_list selinux_hooks[] __lsm_ro_after_init = {LSM_HOOK_INIT(binder_set_context_mgr, selinux_binder_set_context_mgr),LSM_HOOK_INIT(binder_transaction, selinux_binder_transaction),LSM_HOOK_INIT(binder_transfer_binder, selinux_binder_transfer_binder),LSM_HOOK_INIT(binder_transfer_file, selinux_binder_transfer_file),LSM_HOOK_INIT(ptrace_access_check, selinux_ptrace_access_check),LSM_HOOK_INIT(ptrace_traceme, selinux_ptrace_traceme),......
}

/** Initializing a security_hook_list structure takes* up a lot of space in a source file. This macro takes* care of the common case and reduces the amount of* text involved.*/
#define LSM_HOOK_INIT(HEAD, HOOK) \{ .head = &security_hook_heads.HEAD, .hook = { .HEAD = HOOK } }

（1）LSM_HOOK_INIT(HEAD, HOOK)：定义了一个名为LSM_HOOK_INIT的宏，宏的参数是HEAD和HOOK，用于指定security_hook_list结构体的成员。

（2）{ .head = &security_hook_heads.HEAD, .hook = { .HEAD = HOOK } }：这是一个结构体初始化的语法，用于初始化security_hook_list结构体的成员。具体来说：

.head = &security_hook_heads.HEAD：初始化head成员，将其指向security_hook_heads结构体中的HEAD成员的地址。security_hook_heads是一个全局变量，用于存储各个hook链表的头部。

struct security_hook_heads {.....struct hlist_head ptrace_access_check;......
}

.hook = { .HEAD = HOOK }：初始化hook成员，其中的.HEAD = HOOK将HOOK的值赋给hook中对应的HEAD成员。这里的HEAD是一个宏参数，用于指定具体的hook函数

union security_list_options {......int (*ptrace_access_check)(struct task_struct *child,unsigned int mode);......
}

struct security_hook_heads这个全局变量用于存储各个hook链表的头部。

比如：

LSM_HOOK_INIT(ptrace_access_check, selinux_ptrace_access_check)

等价于：

{ .head = &security_hook_heads.ptrace_access_check, .hook = { .ptrace_access_check= selinux_ptrace_access_check} }

这个宏定义用于简化初始化security_hook_list结构体的操作。通过宏调用，可以用较少的代码初始化security_hook_list结构体中的head和hook成员。

如果Linux使用的是 selinux，那么执行 exec系统调用时，执行 security_bprm_check hook点就是执行 selinux_ptrace_access_check 函数。

5.2 apparmor

apparmor 和 selinux 初始化过程相同：

DEFINE_LSM(apparmor) = {.name = "apparmor",.flags = LSM_FLAG_LEGACY_MAJOR | LSM_FLAG_EXCLUSIVE,.enabled = &apparmor_enabled,.blobs = &apparmor_blob_sizes,.init = apparmor_init,
};

static int __init apparmor_init(void)
{......security_add_hooks(apparmor_hooks, ARRAY_SIZE(apparmor_hooks),"apparmor");......
}

static struct security_hook_list apparmor_hooks[] __lsm_ro_after_init = {LSM_HOOK_INIT(ptrace_access_check, apparmor_ptrace_access_check),LSM_HOOK_INIT(ptrace_traceme, apparmor_ptrace_traceme),LSM_HOOK_INIT(capget, apparmor_capget),LSM_HOOK_INIT(capable, apparmor_capable),......
}

如果Linux使用的是 apparmor，那么执行 exec系统调用时，执行 security_bprm_check hook点就是执行 apparmor_ptrace_access_check函数。

参考资料

Linux 5.4.18

https://pwl999.blog.csdn.net/article/details/107066666
https://blog.csdn.net/feelabclihu/article/details/121059328
https://github.com/kubearmor/KubeArmor/wiki/Introduction-to-Linux-Security-Modules-(LSMs)