2015-05-02 22:10:46 +00:00
|
|
|
/*
|
|
|
|
* Linux Security Module interfaces
|
|
|
|
*
|
|
|
|
* Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
|
|
|
|
* Copyright (C) 2001 Greg Kroah-Hartman <greg@kroah.com>
|
|
|
|
* Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
|
|
|
|
* Copyright (C) 2001 James Morris <jmorris@intercode.com.au>
|
|
|
|
* Copyright (C) 2001 Silicon Graphics, Inc. (Trust Technology Group)
|
|
|
|
* Copyright (C) 2015 Intel Corporation.
|
|
|
|
* Copyright (C) 2015 Casey Schaufler <casey@schaufler-ca.com>
|
IB/core: Enforce PKey security on QPs
Add new LSM hooks to allocate and free security contexts and check for
permission to access a PKey.
Allocate and free a security context when creating and destroying a QP.
This context is used for controlling access to PKeys.
When a request is made to modify a QP that changes the port, PKey index,
or alternate path, check that the QP has permission for the PKey in the
PKey table index on the subnet prefix of the port. If the QP is shared
make sure all handles to the QP also have access.
Store which port and PKey index a QP is using. After the reset to init
transition the user can modify the port, PKey index and alternate path
independently. So port and PKey settings changes can be a merge of the
previous settings and the new ones.
In order to maintain access control if there are PKey table or subnet
prefix change keep a list of all QPs are using each PKey index on
each port. If a change occurs all QPs using that device and port must
have access enforced for the new cache settings.
These changes add a transaction to the QP modify process. Association
with the old port and PKey index must be maintained if the modify fails,
and must be removed if it succeeds. Association with the new port and
PKey index must be established prior to the modify and removed if the
modify fails.
1. When a QP is modified to a particular Port, PKey index or alternate
path insert that QP into the appropriate lists.
2. Check permission to access the new settings.
3. If step 2 grants access attempt to modify the QP.
4a. If steps 2 and 3 succeed remove any prior associations.
4b. If ether fails remove the new setting associations.
If a PKey table or subnet prefix changes walk the list of QPs and
check that they have permission. If not send the QP to the error state
and raise a fatal error event. If it's a shared QP make sure all the
QPs that share the real_qp have permission as well. If the QP that
owns a security structure is denied access the security structure is
marked as such and the QP is added to an error_list. Once the moving
the QP to error is complete the security structure mark is cleared.
Maintaining the lists correctly turns QP destroy into a transaction.
The hardware driver for the device frees the ib_qp structure, so while
the destroy is in progress the ib_qp pointer in the ib_qp_security
struct is undefined. When the destroy process begins the ib_qp_security
structure is marked as destroying. This prevents any action from being
taken on the QP pointer. After the QP is destroyed successfully it
could still listed on an error_list wait for it to be processed by that
flow before cleaning up the structure.
If the destroy fails the QPs port and PKey settings are reinserted into
the appropriate lists, the destroying flag is cleared, and access control
is enforced, in case there were any cache changes during the destroy
flow.
To keep the security changes isolated a new file is used to hold security
related functionality.
Signed-off-by: Daniel Jurgens <danielj@mellanox.com>
Acked-by: Doug Ledford <dledford@redhat.com>
[PM: merge fixup in ib_verbs.h and uverbs_cmd.c]
Signed-off-by: Paul Moore <paul@paul-moore.com>
2017-05-19 12:48:52 +00:00
|
|
|
* Copyright (C) 2016 Mellanox Techonologies
|
2015-05-02 22:10:46 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Due to this file being licensed under the GPL there is controversy over
|
|
|
|
* whether this permits you to write a module that #includes this file
|
|
|
|
* without placing your module under the GPL. Please consult a lawyer for
|
|
|
|
* advice before doing this.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __LINUX_LSM_HOOKS_H
|
|
|
|
#define __LINUX_LSM_HOOKS_H
|
|
|
|
|
|
|
|
#include <linux/security.h>
|
2015-05-02 22:11:42 +00:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/rculist.h>
|
2015-05-02 22:10:46 +00:00
|
|
|
|
2015-05-02 22:10:53 +00:00
|
|
|
/**
|
2017-05-13 11:51:42 +00:00
|
|
|
* union security_list_options - Linux Security Module hook function list
|
|
|
|
*
|
2015-05-02 22:10:53 +00:00
|
|
|
* Security hooks for program execution operations.
|
|
|
|
*
|
2020-03-22 20:46:24 +00:00
|
|
|
* @bprm_creds_for_exec:
|
|
|
|
* If the setup in prepare_exec_creds did not setup @bprm->cred->security
|
|
|
|
* properly for executing @bprm->file, update the LSM's portion of
|
|
|
|
* @bprm->cred->security to be what commit_creds needs to install for the
|
|
|
|
* new program. This hook may also optionally check permissions
|
|
|
|
* (e.g. for transitions between security domains).
|
|
|
|
* The hook must set @bprm->secureexec to 1 if AT_SECURE should be set to
|
|
|
|
* request libc enable secure mode.
|
|
|
|
* @bprm contains the linux_binprm structure.
|
|
|
|
* Return 0 if the hook is successful and permission is granted.
|
2020-05-30 03:00:54 +00:00
|
|
|
* @bprm_creds_from_file:
|
|
|
|
* If @file is setpcap, suid, sgid or otherwise marked to change
|
|
|
|
* privilege upon exec, update @bprm->cred to reflect that change.
|
|
|
|
* This is called after finding the binary that will be executed.
|
|
|
|
* without an interpreter. This ensures that the credentials will not
|
|
|
|
* be derived from a script that the binary will need to reopen, which
|
|
|
|
* when reopend may end up being a completely different file. This
|
|
|
|
* hook may also optionally check permissions (e.g. for transitions
|
|
|
|
* between security domains).
|
|
|
|
* The hook must set @bprm->secureexec to 1 if AT_SECURE should be set to
|
2020-03-22 20:46:24 +00:00
|
|
|
* request libc enable secure mode.
|
2020-05-30 03:00:54 +00:00
|
|
|
* The hook must add to @bprm->per_clear any personality flags that
|
2020-05-29 13:24:10 +00:00
|
|
|
* should be cleared from current->personality.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @bprm contains the linux_binprm structure.
|
|
|
|
* Return 0 if the hook is successful and permission is granted.
|
|
|
|
* @bprm_check_security:
|
|
|
|
* This hook mediates the point when a search for a binary handler will
|
2020-03-22 20:46:24 +00:00
|
|
|
* begin. It allows a check against the @bprm->cred->security value
|
|
|
|
* which was set in the preceding creds_for_exec call. The argv list and
|
|
|
|
* envp list are reliably available in @bprm. This hook may be called
|
|
|
|
* multiple times during a single execve.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @bprm contains the linux_binprm structure.
|
|
|
|
* Return 0 if the hook is successful and permission is granted.
|
|
|
|
* @bprm_committing_creds:
|
|
|
|
* Prepare to install the new security attributes of a process being
|
|
|
|
* transformed by an execve operation, based on the old credentials
|
|
|
|
* pointed to by @current->cred and the information set in @bprm->cred by
|
2020-03-22 20:46:24 +00:00
|
|
|
* the bprm_creds_for_exec hook. @bprm points to the linux_binprm
|
|
|
|
* structure. This hook is a good place to perform state changes on the
|
|
|
|
* process such as closing open file descriptors to which access will no
|
|
|
|
* longer be granted when the attributes are changed. This is called
|
|
|
|
* immediately before commit_creds().
|
2015-05-02 22:10:53 +00:00
|
|
|
* @bprm_committed_creds:
|
|
|
|
* Tidy up after the installation of the new security attributes of a
|
|
|
|
* process being transformed by an execve operation. The new credentials
|
|
|
|
* have, by this point, been set to @current->cred. @bprm points to the
|
|
|
|
* linux_binprm structure. This hook is a good place to perform state
|
|
|
|
* changes on the process such as clearing out non-inheritable signal
|
|
|
|
* state. This is called immediately after commit_creds().
|
|
|
|
*
|
2018-11-01 23:07:24 +00:00
|
|
|
* Security hooks for mount using fs_context.
|
2020-04-27 21:17:09 +00:00
|
|
|
* [See also Documentation/filesystems/mount_api.rst]
|
2018-11-01 23:07:24 +00:00
|
|
|
*
|
2018-12-23 21:02:47 +00:00
|
|
|
* @fs_context_dup:
|
|
|
|
* Allocate and attach a security structure to sc->security. This pointer
|
|
|
|
* is initialised to NULL by the caller.
|
|
|
|
* @fc indicates the new filesystem context.
|
|
|
|
* @src_fc indicates the original filesystem context.
|
2018-11-01 23:07:24 +00:00
|
|
|
* @fs_context_parse_param:
|
|
|
|
* Userspace provided a parameter to configure a superblock. The LSM may
|
|
|
|
* reject it with an error and may use it for itself, in which case it
|
|
|
|
* should return 0; otherwise it should return -ENOPARAM to pass it on to
|
|
|
|
* the filesystem.
|
|
|
|
* @fc indicates the filesystem context.
|
|
|
|
* @param The parameter
|
|
|
|
*
|
2015-05-02 22:10:53 +00:00
|
|
|
* Security hooks for filesystem operations.
|
|
|
|
*
|
|
|
|
* @sb_alloc_security:
|
|
|
|
* Allocate and attach a security structure to the sb->s_security field.
|
|
|
|
* The s_security field is initialized to NULL when the structure is
|
|
|
|
* allocated.
|
|
|
|
* @sb contains the super_block structure to be modified.
|
|
|
|
* Return 0 if operation was successful.
|
2021-04-22 15:41:16 +00:00
|
|
|
* @sb_delete:
|
|
|
|
* Release objects tied to a superblock (e.g. inodes).
|
|
|
|
* @sb contains the super_block structure being released.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @sb_free_security:
|
|
|
|
* Deallocate and clear the sb->s_security field.
|
|
|
|
* @sb contains the super_block structure to be modified.
|
2020-02-16 07:08:38 +00:00
|
|
|
* @sb_free_mnt_opts:
|
|
|
|
* Free memory associated with @mnt_ops.
|
|
|
|
* @sb_eat_lsm_opts:
|
|
|
|
* Eat (scan @orig options) and save them in @mnt_opts.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @sb_statfs:
|
|
|
|
* Check permission before obtaining filesystem statistics for the @mnt
|
|
|
|
* mountpoint.
|
|
|
|
* @dentry is a handle on the superblock for the filesystem.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @sb_mount:
|
|
|
|
* Check permission before an object specified by @dev_name is mounted on
|
|
|
|
* the mount point named by @nd. For an ordinary mount, @dev_name
|
|
|
|
* identifies a device if the file system type requires a device. For a
|
|
|
|
* remount (@flags & MS_REMOUNT), @dev_name is irrelevant. For a
|
|
|
|
* loopback/bind mount (@flags & MS_BIND), @dev_name identifies the
|
|
|
|
* pathname of the object being mounted.
|
|
|
|
* @dev_name contains the name for object being mounted.
|
|
|
|
* @path contains the path for mount point object.
|
|
|
|
* @type contains the filesystem type.
|
|
|
|
* @flags contains the mount flags.
|
|
|
|
* @data contains the filesystem-specific data.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @sb_copy_data:
|
|
|
|
* Allow mount option data to be copied prior to parsing by the filesystem,
|
|
|
|
* so that the security module can extract security-specific mount
|
|
|
|
* options cleanly (a filesystem may modify the data e.g. with strsep()).
|
|
|
|
* This also allows the original mount data to be stripped of security-
|
|
|
|
* specific options to avoid having to make filesystems aware of them.
|
|
|
|
* @orig the original mount data copied from userspace.
|
|
|
|
* @copy copied data which will be passed to the security module.
|
|
|
|
* Returns 0 if the copy was successful.
|
2021-02-27 03:37:55 +00:00
|
|
|
* @sb_mnt_opts_compat:
|
|
|
|
* Determine if the new mount options in @mnt_opts are allowed given
|
|
|
|
* the existing mounted filesystem at @sb.
|
|
|
|
* @sb superblock being compared
|
|
|
|
* @mnt_opts new mount options
|
|
|
|
* Return 0 if options are compatible.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @sb_remount:
|
|
|
|
* Extracts security system specific mount options and verifies no changes
|
|
|
|
* are being made to those options.
|
|
|
|
* @sb superblock being remounted
|
|
|
|
* @data contains the filesystem-specific data.
|
|
|
|
* Return 0 if permission is granted.
|
2020-02-16 07:08:38 +00:00
|
|
|
* @sb_kern_mount:
|
|
|
|
* Mount this @sb if allowed by permissions.
|
|
|
|
* @sb_show_options:
|
|
|
|
* Show (print on @m) mount options for this @sb.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @sb_umount:
|
|
|
|
* Check permission before the @mnt file system is unmounted.
|
|
|
|
* @mnt contains the mounted file system.
|
|
|
|
* @flags contains the unmount flags, e.g. MNT_FORCE.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @sb_pivotroot:
|
|
|
|
* Check permission before pivoting the root filesystem.
|
|
|
|
* @old_path contains the path for the new location of the
|
|
|
|
* current root (put_old).
|
|
|
|
* @new_path contains the path for the new root (new_root).
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @sb_set_mnt_opts:
|
|
|
|
* Set the security relevant mount options used for a superblock
|
|
|
|
* @sb the superblock to set security mount options for
|
|
|
|
* @opts binary data structure containing all lsm mount data
|
|
|
|
* @sb_clone_mnt_opts:
|
|
|
|
* Copy all security options from a given superblock to another
|
|
|
|
* @oldsb old superblock which contain information to clone
|
|
|
|
* @newsb new superblock which needs filled in
|
|
|
|
* @sb_parse_opts_str:
|
|
|
|
* Parse a string of security data filling in the opts structure
|
|
|
|
* @options string containing all mount options known by the LSM
|
|
|
|
* @opts binary data structure usable by the LSM
|
2018-11-05 17:40:30 +00:00
|
|
|
* @move_mount:
|
|
|
|
* Check permission before a mount is moved.
|
|
|
|
* @from_path indicates the mount that is going to be moved.
|
|
|
|
* @to_path indicates the mountpoint that will be mounted upon.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @dentry_init_security:
|
|
|
|
* Compute a context for a dentry as the inode is not yet available
|
|
|
|
* since NFSv4 has no label backed by an EA anyway.
|
|
|
|
* @dentry dentry to use in calculating the context.
|
|
|
|
* @mode mode used to determine resource type.
|
|
|
|
* @name name of the last path component used to create file
|
2021-10-12 13:23:07 +00:00
|
|
|
* @xattr_name pointer to place the pointer to security xattr name.
|
|
|
|
* Caller does not have to free the resulting pointer. Its
|
|
|
|
* a pointer to static string.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @ctx pointer to place the pointer to the resulting context in.
|
|
|
|
* @ctxlen point to place the length of the resulting context.
|
2016-07-13 14:44:52 +00:00
|
|
|
* @dentry_create_files_as:
|
|
|
|
* Compute a context for a dentry as the inode is not yet available
|
|
|
|
* and set that context in passed in creds so that new files are
|
|
|
|
* created using that context. Context is calculated using the
|
|
|
|
* passed in creds and not the creds of the caller.
|
|
|
|
* @dentry dentry to use in calculating the context.
|
|
|
|
* @mode mode used to determine resource type.
|
|
|
|
* @name name of the last path component used to create file
|
|
|
|
* @old creds which should be used for context calculation
|
|
|
|
* @new creds to modify
|
2015-05-02 22:10:53 +00:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* Security hooks for inode operations.
|
|
|
|
*
|
|
|
|
* @inode_alloc_security:
|
|
|
|
* Allocate and attach a security structure to @inode->i_security. The
|
|
|
|
* i_security field is initialized to NULL when the inode structure is
|
|
|
|
* allocated.
|
|
|
|
* @inode contains the inode structure.
|
|
|
|
* Return 0 if operation was successful.
|
|
|
|
* @inode_free_security:
|
|
|
|
* @inode contains the inode structure.
|
|
|
|
* Deallocate the inode security structure and set @inode->i_security to
|
|
|
|
* NULL.
|
|
|
|
* @inode_init_security:
|
|
|
|
* Obtain the security attribute name suffix and value to set on a newly
|
|
|
|
* created inode and set up the incore security field for the new inode.
|
|
|
|
* This hook is called by the fs code as part of the inode creation
|
|
|
|
* transaction and provides for atomic labeling of the inode, unlike
|
|
|
|
* the post_create/mkdir/... hooks called by the VFS. The hook function
|
|
|
|
* is expected to allocate the name and value via kmalloc, with the caller
|
|
|
|
* being responsible for calling kfree after using them.
|
|
|
|
* If the security module does not use security attributes or does
|
|
|
|
* not wish to put a security attribute on this particular inode,
|
|
|
|
* then it should return -EOPNOTSUPP to skip this processing.
|
|
|
|
* @inode contains the inode structure of the newly created inode.
|
|
|
|
* @dir contains the inode structure of the parent directory.
|
|
|
|
* @qstr contains the last path component of the new object
|
|
|
|
* @name will be set to the allocated name suffix (e.g. selinux).
|
|
|
|
* @value will be set to the allocated attribute value.
|
|
|
|
* @len will be set to the length of the value.
|
|
|
|
* Returns 0 if @name and @value have been successfully set,
|
2017-05-13 11:51:42 +00:00
|
|
|
* -EOPNOTSUPP if no security attribute is needed, or
|
|
|
|
* -ENOMEM on memory allocation failure.
|
2021-01-08 22:22:20 +00:00
|
|
|
* @inode_init_security_anon:
|
|
|
|
* Set up the incore security field for the new anonymous inode
|
|
|
|
* and return whether the inode creation is permitted by the security
|
|
|
|
* module or not.
|
|
|
|
* @inode contains the inode structure
|
|
|
|
* @name name of the anonymous inode class
|
|
|
|
* @context_inode optional related inode
|
|
|
|
* Returns 0 on success, -EACCES if the security module denies the
|
|
|
|
* creation of this inode, or another -errno upon other errors.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @inode_create:
|
|
|
|
* Check permission to create a regular file.
|
|
|
|
* @dir contains inode structure of the parent of the new file.
|
|
|
|
* @dentry contains the dentry structure for the file to be created.
|
|
|
|
* @mode contains the file mode of the file to be created.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_link:
|
|
|
|
* Check permission before creating a new hard link to a file.
|
|
|
|
* @old_dentry contains the dentry structure for an existing
|
|
|
|
* link to the file.
|
|
|
|
* @dir contains the inode structure of the parent directory
|
|
|
|
* of the new link.
|
|
|
|
* @new_dentry contains the dentry structure for the new link.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_link:
|
|
|
|
* Check permission before creating a new hard link to a file.
|
|
|
|
* @old_dentry contains the dentry structure for an existing link
|
|
|
|
* to the file.
|
|
|
|
* @new_dir contains the path structure of the parent directory of
|
|
|
|
* the new link.
|
|
|
|
* @new_dentry contains the dentry structure for the new link.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_unlink:
|
|
|
|
* Check the permission to remove a hard link to a file.
|
|
|
|
* @dir contains the inode structure of parent directory of the file.
|
|
|
|
* @dentry contains the dentry structure for file to be unlinked.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_unlink:
|
|
|
|
* Check the permission to remove a hard link to a file.
|
|
|
|
* @dir contains the path structure of parent directory of the file.
|
|
|
|
* @dentry contains the dentry structure for file to be unlinked.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_symlink:
|
|
|
|
* Check the permission to create a symbolic link to a file.
|
|
|
|
* @dir contains the inode structure of parent directory of
|
|
|
|
* the symbolic link.
|
|
|
|
* @dentry contains the dentry structure of the symbolic link.
|
|
|
|
* @old_name contains the pathname of file.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_symlink:
|
|
|
|
* Check the permission to create a symbolic link to a file.
|
|
|
|
* @dir contains the path structure of parent directory of
|
|
|
|
* the symbolic link.
|
|
|
|
* @dentry contains the dentry structure of the symbolic link.
|
|
|
|
* @old_name contains the pathname of file.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_mkdir:
|
|
|
|
* Check permissions to create a new directory in the existing directory
|
|
|
|
* associated with inode structure @dir.
|
|
|
|
* @dir contains the inode structure of parent of the directory
|
|
|
|
* to be created.
|
|
|
|
* @dentry contains the dentry structure of new directory.
|
|
|
|
* @mode contains the mode of new directory.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_mkdir:
|
|
|
|
* Check permissions to create a new directory in the existing directory
|
|
|
|
* associated with path structure @path.
|
|
|
|
* @dir contains the path structure of parent of the directory
|
|
|
|
* to be created.
|
|
|
|
* @dentry contains the dentry structure of new directory.
|
|
|
|
* @mode contains the mode of new directory.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_rmdir:
|
|
|
|
* Check the permission to remove a directory.
|
|
|
|
* @dir contains the inode structure of parent of the directory
|
|
|
|
* to be removed.
|
|
|
|
* @dentry contains the dentry structure of directory to be removed.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_rmdir:
|
|
|
|
* Check the permission to remove a directory.
|
|
|
|
* @dir contains the path structure of parent of the directory to be
|
|
|
|
* removed.
|
|
|
|
* @dentry contains the dentry structure of directory to be removed.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_mknod:
|
|
|
|
* Check permissions when creating a special file (or a socket or a fifo
|
|
|
|
* file created via the mknod system call). Note that if mknod operation
|
|
|
|
* is being done for a regular file, then the create hook will be called
|
|
|
|
* and not this hook.
|
|
|
|
* @dir contains the inode structure of parent of the new file.
|
|
|
|
* @dentry contains the dentry structure of the new file.
|
|
|
|
* @mode contains the mode of the new file.
|
|
|
|
* @dev contains the device number.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_mknod:
|
|
|
|
* Check permissions when creating a file. Note that this hook is called
|
|
|
|
* even if mknod operation is being done for a regular file.
|
|
|
|
* @dir contains the path structure of parent of the new file.
|
|
|
|
* @dentry contains the dentry structure of the new file.
|
|
|
|
* @mode contains the mode of the new file.
|
|
|
|
* @dev contains the undecoded device number. Use new_decode_dev() to get
|
|
|
|
* the decoded device number.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_rename:
|
|
|
|
* Check for permission to rename a file or directory.
|
|
|
|
* @old_dir contains the inode structure for parent of the old link.
|
|
|
|
* @old_dentry contains the dentry structure of the old link.
|
|
|
|
* @new_dir contains the inode structure for parent of the new link.
|
|
|
|
* @new_dentry contains the dentry structure of the new link.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_rename:
|
|
|
|
* Check for permission to rename a file or directory.
|
|
|
|
* @old_dir contains the path structure for parent of the old link.
|
|
|
|
* @old_dentry contains the dentry structure of the old link.
|
|
|
|
* @new_dir contains the path structure for parent of the new link.
|
|
|
|
* @new_dentry contains the dentry structure of the new link.
|
2022-05-06 16:10:56 +00:00
|
|
|
* @flags may contain rename options such as RENAME_EXCHANGE.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_chmod:
|
2019-02-26 20:49:07 +00:00
|
|
|
* Check for permission to change a mode of the file @path. The new
|
|
|
|
* mode is specified in @mode.
|
|
|
|
* @path contains the path structure of the file to change the mode.
|
|
|
|
* @mode contains the new DAC's permission, which is a bitmask of
|
|
|
|
* constants from <include/uapi/linux/stat.h>
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_chown:
|
|
|
|
* Check for permission to change owner/group of a file or directory.
|
|
|
|
* @path contains the path structure.
|
|
|
|
* @uid contains new owner's ID.
|
|
|
|
* @gid contains new group's ID.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_chroot:
|
|
|
|
* Check for permission to change root directory.
|
|
|
|
* @path contains the path structure.
|
|
|
|
* Return 0 if permission is granted.
|
fanotify, inotify, dnotify, security: add security hook for fs notifications
As of now, setting watches on filesystem objects has, at most, applied a
check for read access to the inode, and in the case of fanotify, requires
CAP_SYS_ADMIN. No specific security hook or permission check has been
provided to control the setting of watches. Using any of inotify, dnotify,
or fanotify, it is possible to observe, not only write-like operations, but
even read access to a file. Modeling the watch as being merely a read from
the file is insufficient for the needs of SELinux. This is due to the fact
that read access should not necessarily imply access to information about
when another process reads from a file. Furthermore, fanotify watches grant
more power to an application in the form of permission events. While
notification events are solely, unidirectional (i.e. they only pass
information to the receiving application), permission events are blocking.
Permission events make a request to the receiving application which will
then reply with a decision as to whether or not that action may be
completed. This causes the issue of the watching application having the
ability to exercise control over the triggering process. Without drawing a
distinction within the permission check, the ability to read would imply
the greater ability to control an application. Additionally, mount and
superblock watches apply to all files within the same mount or superblock.
Read access to one file should not necessarily imply the ability to watch
all files accessed within a given mount or superblock.
In order to solve these issues, a new LSM hook is implemented and has been
placed within the system calls for marking filesystem objects with inotify,
fanotify, and dnotify watches. These calls to the hook are placed at the
point at which the target path has been resolved and are provided with the
path struct, the mask of requested notification events, and the type of
object on which the mark is being set (inode, superblock, or mount). The
mask and obj_type have already been translated into common FS_* values
shared by the entirety of the fs notification infrastructure. The path
struct is passed rather than just the inode so that the mount is available,
particularly for mount watches. This also allows for use of the hook by
pathname-based security modules. However, since the hook is intended for
use even by inode based security modules, it is not placed under the
CONFIG_SECURITY_PATH conditional. Otherwise, the inode-based security
modules would need to enable all of the path hooks, even though they do not
use any of them.
This only provides a hook at the point of setting a watch, and presumes
that permission to set a particular watch implies the ability to receive
all notification about that object which match the mask. This is all that
is required for SELinux. If other security modules require additional hooks
or infrastructure to control delivery of notification, these can be added
by them. It does not make sense for us to propose hooks for which we have
no implementation. The understanding that all notifications received by the
requesting application are all strictly of a type for which the application
has been granted permission shows that this implementation is sufficient in
its coverage.
Security modules wishing to provide complete control over fanotify must
also implement a security_file_open hook that validates that the access
requested by the watching application is authorized. Fanotify has the issue
that it returns a file descriptor with the file mode specified during
fanotify_init() to the watching process on event. This is already covered
by the LSM security_file_open hook if the security module implements
checking of the requested file mode there. Otherwise, a watching process
can obtain escalated access to a file for which it has not been authorized.
The selinux_path_notify hook implementation works by adding five new file
permissions: watch, watch_mount, watch_sb, watch_reads, and watch_with_perm
(descriptions about which will follow), and one new filesystem permission:
watch (which is applied to superblock checks). The hook then decides which
subset of these permissions must be held by the requesting application
based on the contents of the provided mask and the obj_type. The
selinux_file_open hook already checks the requested file mode and therefore
ensures that a watching process cannot escalate its access through
fanotify.
The watch, watch_mount, and watch_sb permissions are the baseline
permissions for setting a watch on an object and each are a requirement for
any watch to be set on a file, mount, or superblock respectively. It should
be noted that having either of the other two permissions (watch_reads and
watch_with_perm) does not imply the watch, watch_mount, or watch_sb
permission. Superblock watches further require the filesystem watch
permission to the superblock. As there is no labeled object in view for
mounts, there is no specific check for mount watches beyond watch_mount to
the inode. Such a check could be added in the future, if a suitable labeled
object existed representing the mount.
The watch_reads permission is required to receive notifications from
read-exclusive events on filesystem objects. These events include accessing
a file for the purpose of reading and closing a file which has been opened
read-only. This distinction has been drawn in order to provide a direct
indication in the policy for this otherwise not obvious capability. Read
access to a file should not necessarily imply the ability to observe read
events on a file.
Finally, watch_with_perm only applies to fanotify masks since it is the
only way to set a mask which allows for the blocking, permission event.
This permission is needed for any watch which is of this type. Though
fanotify requires CAP_SYS_ADMIN, this is insufficient as it gives implicit
trust to root, which we do not do, and does not support least privilege.
Signed-off-by: Aaron Goidel <acgoide@tycho.nsa.gov>
Acked-by: Casey Schaufler <casey@schaufler-ca.com>
Acked-by: Jan Kara <jack@suse.cz>
Signed-off-by: Paul Moore <paul@paul-moore.com>
2019-08-12 15:20:00 +00:00
|
|
|
* @path_notify:
|
|
|
|
* Check permissions before setting a watch on events as defined by @mask,
|
|
|
|
* on an object at @path, whose type is defined by @obj_type.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @inode_readlink:
|
|
|
|
* Check the permission to read the symbolic link.
|
|
|
|
* @dentry contains the dentry structure for the file link.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_follow_link:
|
|
|
|
* Check permission to follow a symbolic link when looking up a pathname.
|
|
|
|
* @dentry contains the dentry structure for the link.
|
2015-06-27 20:26:03 +00:00
|
|
|
* @inode contains the inode, which itself is not stable in RCU-walk
|
|
|
|
* @rcu indicates whether we are in RCU-walk mode.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_permission:
|
|
|
|
* Check permission before accessing an inode. This hook is called by the
|
|
|
|
* existing Linux permission function, so a security module can use it to
|
|
|
|
* provide additional checking for existing Linux permission checks.
|
|
|
|
* Notice that this hook is called when a file is opened (as well as many
|
|
|
|
* other operations), whereas the file_security_ops permission hook is
|
|
|
|
* called when the actual read/write operations are performed.
|
|
|
|
* @inode contains the inode structure to check.
|
|
|
|
* @mask contains the permission mask.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_setattr:
|
|
|
|
* Check permission before setting file attributes. Note that the kernel
|
|
|
|
* call to notify_change is performed from several locations, whenever
|
|
|
|
* file attributes change (such as when a file is truncated, chown/chmod
|
|
|
|
* operations, transferring disk quotas, etc).
|
|
|
|
* @dentry contains the dentry structure for the file.
|
|
|
|
* @attr is the iattr structure containing the new file attributes.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @path_truncate:
|
|
|
|
* Check permission before truncating a file.
|
|
|
|
* @path contains the path structure for the file.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_getattr:
|
|
|
|
* Check permission before obtaining file attributes.
|
2016-12-21 23:32:25 +00:00
|
|
|
* @path contains the path structure for the file.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_setxattr:
|
|
|
|
* Check permission before setting the extended attributes
|
|
|
|
* @value identified by @name for @dentry.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_post_setxattr:
|
|
|
|
* Update inode security field after successful setxattr operation.
|
|
|
|
* @value identified by @name for @dentry.
|
|
|
|
* @inode_getxattr:
|
|
|
|
* Check permission before obtaining the extended attributes
|
|
|
|
* identified by @name for @dentry.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_listxattr:
|
|
|
|
* Check permission before obtaining the list of extended attribute
|
|
|
|
* names for @dentry.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_removexattr:
|
|
|
|
* Check permission before removing the extended attribute
|
|
|
|
* identified by @name for @dentry.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @inode_getsecurity:
|
|
|
|
* Retrieve a copy of the extended attribute representation of the
|
|
|
|
* security label associated with @name for @inode via @buffer. Note that
|
|
|
|
* @name is the remainder of the attribute name after the security prefix
|
|
|
|
* has been removed. @alloc is used to specify of the call should return a
|
|
|
|
* value via the buffer or just the value length Return size of buffer on
|
|
|
|
* success.
|
|
|
|
* @inode_setsecurity:
|
|
|
|
* Set the security label associated with @name for @inode from the
|
|
|
|
* extended attribute value @value. @size indicates the size of the
|
|
|
|
* @value in bytes. @flags may be XATTR_CREATE, XATTR_REPLACE, or 0.
|
|
|
|
* Note that @name is the remainder of the attribute name after the
|
|
|
|
* security. prefix has been removed.
|
|
|
|
* Return 0 on success.
|
|
|
|
* @inode_listsecurity:
|
|
|
|
* Copy the extended attribute names for the security labels
|
|
|
|
* associated with @inode into @buffer. The maximum size of @buffer
|
|
|
|
* is specified by @buffer_size. @buffer may be NULL to request
|
|
|
|
* the size of the buffer required.
|
|
|
|
* Returns number of bytes used/required on success.
|
|
|
|
* @inode_need_killpriv:
|
|
|
|
* Called when an inode has been changed.
|
|
|
|
* @dentry is the dentry being changed.
|
|
|
|
* Return <0 on error to abort the inode change operation.
|
|
|
|
* Return 0 if inode_killpriv does not need to be called.
|
|
|
|
* Return >0 if inode_killpriv does need to be called.
|
|
|
|
* @inode_killpriv:
|
|
|
|
* The setuid bit is being removed. Remove similar security labels.
|
|
|
|
* Called with the dentry->d_inode->i_mutex held.
|
2021-01-21 13:19:29 +00:00
|
|
|
* @mnt_userns: user namespace of the mount
|
2015-05-02 22:10:53 +00:00
|
|
|
* @dentry is the dentry being changed.
|
|
|
|
* Return 0 on success. If error is returned, then the operation
|
|
|
|
* causing setuid bit removal is failed.
|
|
|
|
* @inode_getsecid:
|
|
|
|
* Get the secid associated with the node.
|
|
|
|
* @inode contains a pointer to the inode.
|
|
|
|
* @secid contains a pointer to the location where result will be saved.
|
|
|
|
* In case of failure, @secid will be set to zero.
|
2016-07-13 15:13:56 +00:00
|
|
|
* @inode_copy_up:
|
|
|
|
* A file is about to be copied up from lower layer to upper layer of
|
|
|
|
* overlay filesystem. Security module can prepare a set of new creds
|
|
|
|
* and modify as need be and return new creds. Caller will switch to
|
|
|
|
* new creds temporarily to create new file and release newly allocated
|
|
|
|
* creds.
|
|
|
|
* @src indicates the union dentry of file that is being copied up.
|
|
|
|
* @new pointer to pointer to return newly allocated creds.
|
|
|
|
* Returns 0 on success or a negative error code on error.
|
2016-07-13 14:44:49 +00:00
|
|
|
* @inode_copy_up_xattr:
|
|
|
|
* Filter the xattrs being copied up when a unioned file is copied
|
|
|
|
* up from a lower layer to the union/overlay layer.
|
|
|
|
* @name indicates the name of the xattr.
|
|
|
|
* Returns 0 to accept the xattr, 1 to discard the xattr, -EOPNOTSUPP if
|
|
|
|
* security module does not know about attribute or a negative error code
|
|
|
|
* to abort the copy up. Note that the caller is responsible for reading
|
|
|
|
* and writing the xattrs as this hook is merely a filter.
|
2020-02-16 07:08:38 +00:00
|
|
|
* @d_instantiate:
|
|
|
|
* Fill in @inode security information for a @dentry if allowed.
|
|
|
|
* @getprocattr:
|
|
|
|
* Read attribute @name for process @p and store it into @value if allowed.
|
|
|
|
* @setprocattr:
|
|
|
|
* Write (set) attribute @name to @value, size @size if allowed.
|
2015-05-02 22:10:53 +00:00
|
|
|
*
|
2019-02-22 14:57:16 +00:00
|
|
|
* Security hooks for kernfs node operations
|
|
|
|
*
|
2019-03-25 08:05:35 +00:00
|
|
|
* @kernfs_init_security:
|
2019-02-22 14:57:16 +00:00
|
|
|
* Initialize the security context of a newly created kernfs node based
|
|
|
|
* on its own and its parent's attributes.
|
|
|
|
*
|
|
|
|
* @kn_dir the parent kernfs node
|
|
|
|
* @kn the new child kernfs node
|
|
|
|
*
|
2015-05-02 22:10:53 +00:00
|
|
|
* Security hooks for file operations
|
|
|
|
*
|
|
|
|
* @file_permission:
|
|
|
|
* Check file permissions before accessing an open file. This hook is
|
|
|
|
* called by various operations that read or write files. A security
|
|
|
|
* module can use this hook to perform additional checking on these
|
|
|
|
* operations, e.g. to revalidate permissions on use to support privilege
|
|
|
|
* bracketing or policy changes. Notice that this hook is used when the
|
|
|
|
* actual read/write operations are performed, whereas the
|
|
|
|
* inode_security_ops hook is called when a file is opened (as well as
|
|
|
|
* many other operations).
|
|
|
|
* Caveat: Although this hook can be used to revalidate permissions for
|
|
|
|
* various system call operations that read or write files, it does not
|
|
|
|
* address the revalidation of permissions for memory-mapped files.
|
|
|
|
* Security modules must handle this separately if they need such
|
|
|
|
* revalidation.
|
|
|
|
* @file contains the file structure being accessed.
|
|
|
|
* @mask contains the requested permissions.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @file_alloc_security:
|
|
|
|
* Allocate and attach a security structure to the file->f_security field.
|
|
|
|
* The security field is initialized to NULL when the structure is first
|
|
|
|
* created.
|
|
|
|
* @file contains the file structure to secure.
|
|
|
|
* Return 0 if the hook is successful and permission is granted.
|
|
|
|
* @file_free_security:
|
|
|
|
* Deallocate and free any security structures stored in file->f_security.
|
|
|
|
* @file contains the file structure being modified.
|
|
|
|
* @file_ioctl:
|
|
|
|
* @file contains the file structure.
|
|
|
|
* @cmd contains the operation to perform.
|
|
|
|
* @arg contains the operational arguments.
|
|
|
|
* Check permission for an ioctl operation on @file. Note that @arg
|
|
|
|
* sometimes represents a user space pointer; in other cases, it may be a
|
|
|
|
* simple integer value. When @arg represents a user space pointer, it
|
|
|
|
* should never be used by the security module.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @mmap_addr :
|
|
|
|
* Check permissions for a mmap operation at @addr.
|
|
|
|
* @addr contains virtual address that will be used for the operation.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @mmap_file :
|
|
|
|
* Check permissions for a mmap operation. The @file may be NULL, e.g.
|
|
|
|
* if mapping anonymous memory.
|
|
|
|
* @file contains the file structure for file to map (may be NULL).
|
|
|
|
* @reqprot contains the protection requested by the application.
|
|
|
|
* @prot contains the protection that will be applied by the kernel.
|
|
|
|
* @flags contains the operational flags.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @file_mprotect:
|
|
|
|
* Check permissions before changing memory access permissions.
|
|
|
|
* @vma contains the memory region to modify.
|
|
|
|
* @reqprot contains the protection requested by the application.
|
|
|
|
* @prot contains the protection that will be applied by the kernel.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @file_lock:
|
|
|
|
* Check permission before performing file locking operations.
|
2019-02-26 20:49:12 +00:00
|
|
|
* Note the hook mediates both flock and fcntl style locks.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @file contains the file structure.
|
|
|
|
* @cmd contains the posix-translated lock operation to perform
|
|
|
|
* (e.g. F_RDLCK, F_WRLCK).
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @file_fcntl:
|
|
|
|
* Check permission before allowing the file operation specified by @cmd
|
|
|
|
* from being performed on the file @file. Note that @arg sometimes
|
|
|
|
* represents a user space pointer; in other cases, it may be a simple
|
|
|
|
* integer value. When @arg represents a user space pointer, it should
|
|
|
|
* never be used by the security module.
|
|
|
|
* @file contains the file structure.
|
|
|
|
* @cmd contains the operation to be performed.
|
|
|
|
* @arg contains the operational arguments.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @file_set_fowner:
|
|
|
|
* Save owner security information (typically from current->security) in
|
|
|
|
* file->f_security for later use by the send_sigiotask hook.
|
|
|
|
* @file contains the file structure to update.
|
|
|
|
* Return 0 on success.
|
|
|
|
* @file_send_sigiotask:
|
|
|
|
* Check permission for the file owner @fown to send SIGIO or SIGURG to the
|
|
|
|
* process @tsk. Note that this hook is sometimes called from interrupt.
|
|
|
|
* Note that the fown_struct, @fown, is never outside the context of a
|
|
|
|
* struct file, so the file structure (and associated security information)
|
2017-05-13 11:51:42 +00:00
|
|
|
* can always be obtained: container_of(fown, struct file, f_owner)
|
2015-05-02 22:10:53 +00:00
|
|
|
* @tsk contains the structure of task receiving signal.
|
|
|
|
* @fown contains the file owner information.
|
|
|
|
* @sig is the signal that will be sent. When 0, kernel sends SIGIO.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @file_receive:
|
|
|
|
* This hook allows security modules to control the ability of a process
|
|
|
|
* to receive an open file descriptor via socket IPC.
|
|
|
|
* @file contains the file structure being received.
|
|
|
|
* Return 0 if permission is granted.
|
2017-05-13 11:51:42 +00:00
|
|
|
* @file_open:
|
2015-05-02 22:10:53 +00:00
|
|
|
* Save open-time permission checking state for later use upon
|
|
|
|
* file_permission, and recheck access if anything has changed
|
|
|
|
* since inode_permission.
|
|
|
|
*
|
|
|
|
* Security hooks for task operations.
|
|
|
|
*
|
2017-03-24 11:46:33 +00:00
|
|
|
* @task_alloc:
|
|
|
|
* @task task being allocated.
|
|
|
|
* @clone_flags contains the flags indicating what should be shared.
|
|
|
|
* Handle allocation of task-related resources.
|
|
|
|
* Returns a zero on success, negative values on failure.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @task_free:
|
2017-03-24 11:46:33 +00:00
|
|
|
* @task task about to be freed.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Handle release of task-related resources. (Note that this can be called
|
|
|
|
* from interrupt context.)
|
|
|
|
* @cred_alloc_blank:
|
|
|
|
* @cred points to the credentials.
|
|
|
|
* @gfp indicates the atomicity of any memory allocations.
|
|
|
|
* Only allocate sufficient memory and attach to @cred such that
|
|
|
|
* cred_transfer() will not get ENOMEM.
|
|
|
|
* @cred_free:
|
|
|
|
* @cred points to the credentials.
|
|
|
|
* Deallocate and clear the cred->security field in a set of credentials.
|
|
|
|
* @cred_prepare:
|
|
|
|
* @new points to the new credentials.
|
|
|
|
* @old points to the original credentials.
|
|
|
|
* @gfp indicates the atomicity of any memory allocations.
|
|
|
|
* Prepare a new set of credentials by copying the data from the old set.
|
|
|
|
* @cred_transfer:
|
|
|
|
* @new points to the new credentials.
|
|
|
|
* @old points to the original credentials.
|
|
|
|
* Transfer data from original creds to new creds
|
2018-01-08 21:36:19 +00:00
|
|
|
* @cred_getsecid:
|
|
|
|
* Retrieve the security identifier of the cred structure @c
|
|
|
|
* @c contains the credentials, secid will be placed into @secid.
|
|
|
|
* In case of failure, @secid will be set to zero.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @kernel_act_as:
|
|
|
|
* Set the credentials for a kernel service to act as (subjective context).
|
|
|
|
* @new points to the credentials to be modified.
|
|
|
|
* @secid specifies the security ID to be set
|
|
|
|
* The current task must be the one that nominated @secid.
|
|
|
|
* Return 0 if successful.
|
|
|
|
* @kernel_create_files_as:
|
|
|
|
* Set the file creation context in a set of credentials to be the same as
|
|
|
|
* the objective context of the specified inode.
|
|
|
|
* @new points to the credentials to be modified.
|
|
|
|
* @inode points to the inode to use as a reference.
|
|
|
|
* The current task must be the one that nominated @inode.
|
|
|
|
* Return 0 if successful.
|
|
|
|
* @kernel_module_request:
|
|
|
|
* Ability to trigger the kernel to automatically upcall to userspace for
|
|
|
|
* userspace to load a kernel module with the given name.
|
|
|
|
* @kmod_name name of the module requested by the kernel
|
|
|
|
* Return 0 if successful.
|
2018-07-13 18:05:56 +00:00
|
|
|
* @kernel_load_data:
|
|
|
|
* Load data provided by userspace.
|
|
|
|
* @id kernel load data identifier
|
2020-10-02 17:38:20 +00:00
|
|
|
* @contents if a subsequent @kernel_post_load_data will be called.
|
2018-07-13 18:05:56 +00:00
|
|
|
* Return 0 if permission is granted.
|
2020-10-02 17:38:20 +00:00
|
|
|
* @kernel_post_load_data:
|
|
|
|
* Load data provided by a non-file source (usually userspace buffer).
|
|
|
|
* @buf pointer to buffer containing the data contents.
|
|
|
|
* @size length of the data contents.
|
|
|
|
* @id kernel load data identifier
|
|
|
|
* @description a text description of what was loaded, @id-specific
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* This must be paired with a prior @kernel_load_data call that had
|
|
|
|
* @contents set to true.
|
2016-01-31 03:23:26 +00:00
|
|
|
* @kernel_read_file:
|
|
|
|
* Read a file specified by userspace.
|
|
|
|
* @file contains the file structure pointing to the file being read
|
|
|
|
* by the kernel.
|
|
|
|
* @id kernel read file identifier
|
2020-10-02 17:38:23 +00:00
|
|
|
* @contents if a subsequent @kernel_post_read_file will be called.
|
2016-01-31 03:23:26 +00:00
|
|
|
* Return 0 if permission is granted.
|
2015-12-28 21:02:29 +00:00
|
|
|
* @kernel_post_read_file:
|
|
|
|
* Read a file specified by userspace.
|
|
|
|
* @file contains the file structure pointing to the file being read
|
|
|
|
* by the kernel.
|
|
|
|
* @buf pointer to buffer containing the file contents.
|
|
|
|
* @size length of the file contents.
|
2016-01-24 15:07:32 +00:00
|
|
|
* @id kernel read file identifier
|
2020-10-02 17:38:23 +00:00
|
|
|
* This must be paired with a prior @kernel_read_file call that had
|
|
|
|
* @contents set to true.
|
2015-12-28 21:02:29 +00:00
|
|
|
* Return 0 if permission is granted.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @task_fix_setuid:
|
|
|
|
* Update the module's state after setting one or more of the user
|
|
|
|
* identity attributes of the current process. The @flags parameter
|
|
|
|
* indicates which of the set*uid system calls invoked this hook. If
|
|
|
|
* @new is the set of credentials that will be installed. Modifications
|
|
|
|
* should be made to this rather than to @current->cred.
|
|
|
|
* @old is the set of credentials that are being replaces
|
|
|
|
* @flags contains one of the LSM_SETID_* values.
|
|
|
|
* Return 0 on success.
|
2020-06-09 17:22:13 +00:00
|
|
|
* @task_fix_setgid:
|
|
|
|
* Update the module's state after setting one or more of the group
|
|
|
|
* identity attributes of the current process. The @flags parameter
|
|
|
|
* indicates which of the set*gid system calls invoked this hook.
|
|
|
|
* @new is the set of credentials that will be installed. Modifications
|
|
|
|
* should be made to this rather than to @current->cred.
|
|
|
|
* @old is the set of credentials that are being replaced.
|
|
|
|
* @flags contains one of the LSM_SETID_* values.
|
|
|
|
* Return 0 on success.
|
2022-06-08 20:57:11 +00:00
|
|
|
* @task_fix_setgroups:
|
|
|
|
* Update the module's state after setting the supplementary group
|
|
|
|
* identity attributes of the current process.
|
|
|
|
* @new is the set of credentials that will be installed. Modifications
|
|
|
|
* should be made to this rather than to @current->cred.
|
|
|
|
* @old is the set of credentials that are being replaced.
|
|
|
|
* Return 0 on success.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @task_setpgid:
|
|
|
|
* Check permission before setting the process group identifier of the
|
|
|
|
* process @p to @pgid.
|
|
|
|
* @p contains the task_struct for process being modified.
|
|
|
|
* @pgid contains the new pgid.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @task_getpgid:
|
|
|
|
* Check permission before getting the process group identifier of the
|
|
|
|
* process @p.
|
|
|
|
* @p contains the task_struct for the process.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @task_getsid:
|
|
|
|
* Check permission before getting the session identifier of the process
|
|
|
|
* @p.
|
|
|
|
* @p contains the task_struct for the process.
|
|
|
|
* Return 0 if permission is granted.
|
2021-09-29 15:01:21 +00:00
|
|
|
* @current_getsecid_subj:
|
|
|
|
* Retrieve the subjective security identifier of the current task and
|
|
|
|
* return it in @secid.
|
2021-02-19 19:26:21 +00:00
|
|
|
* In case of failure, @secid will be set to zero.
|
|
|
|
* @task_getsecid_obj:
|
|
|
|
* Retrieve the objective security identifier of the task_struct in @p
|
|
|
|
* and return it in @secid.
|
2015-05-02 22:10:53 +00:00
|
|
|
* In case of failure, @secid will be set to zero.
|
|
|
|
*
|
|
|
|
* @task_setnice:
|
|
|
|
* Check permission before setting the nice value of @p to @nice.
|
|
|
|
* @p contains the task_struct of process.
|
|
|
|
* @nice contains the new nice value.
|
|
|
|
* Return 0 if permission is granted.
|
2019-02-26 20:49:12 +00:00
|
|
|
* @task_setioprio:
|
2015-05-02 22:10:53 +00:00
|
|
|
* Check permission before setting the ioprio value of @p to @ioprio.
|
|
|
|
* @p contains the task_struct of process.
|
|
|
|
* @ioprio contains the new ioprio value
|
|
|
|
* Return 0 if permission is granted.
|
2019-02-26 20:49:12 +00:00
|
|
|
* @task_getioprio:
|
2015-05-02 22:10:53 +00:00
|
|
|
* Check permission before getting the ioprio value of @p.
|
|
|
|
* @p contains the task_struct of process.
|
|
|
|
* Return 0 if permission is granted.
|
prlimit,security,selinux: add a security hook for prlimit
When SELinux was first added to the kernel, a process could only get
and set its own resource limits via getrlimit(2) and setrlimit(2), so no
MAC checks were required for those operations, and thus no security hooks
were defined for them. Later, SELinux introduced a hook for setlimit(2)
with a check if the hard limit was being changed in order to be able to
rely on the hard limit value as a safe reset point upon context
transitions.
Later on, when prlimit(2) was added to the kernel with the ability to get
or set resource limits (hard or soft) of another process, LSM/SELinux was
not updated other than to pass the target process to the setrlimit hook.
This resulted in incomplete control over both getting and setting the
resource limits of another process.
Add a new security_task_prlimit() hook to the check_prlimit_permission()
function to provide complete mediation. The hook is only called when
acting on another task, and only if the existing DAC/capability checks
would allow access. Pass flags down to the hook to indicate whether the
prlimit(2) call will read, write, or both read and write the resource
limits of the target process.
The existing security_task_setrlimit() hook is left alone; it continues
to serve a purpose in supporting the ability to make decisions based on
the old and/or new resource limit values when setting limits. This
is consistent with the DAC/capability logic, where
check_prlimit_permission() performs generic DAC/capability checks for
acting on another task, while do_prlimit() performs a capability check
based on a comparison of the old and new resource limits. Fix the
inline documentation for the hook to match the code.
Implement the new hook for SELinux. For setting resource limits, we
reuse the existing setrlimit permission. Note that this does overload
the setrlimit permission to mean the ability to set the resource limit
(soft or hard) of another process or the ability to change one's own
hard limit. For getting resource limits, a new getrlimit permission
is defined. This was not originally defined since getrlimit(2) could
only be used to obtain a process' own limits.
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <james.l.morris@oracle.com>
2017-02-17 12:57:00 +00:00
|
|
|
* @task_prlimit:
|
|
|
|
* Check permission before getting and/or setting the resource limits of
|
|
|
|
* another task.
|
|
|
|
* @cred points to the cred structure for the current task.
|
|
|
|
* @tcred points to the cred structure for the target task.
|
|
|
|
* @flags contains the LSM_PRLIMIT_* flag bits indicating whether the
|
|
|
|
* resource limits are being read, modified, or both.
|
|
|
|
* Return 0 if permission is granted.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @task_setrlimit:
|
prlimit,security,selinux: add a security hook for prlimit
When SELinux was first added to the kernel, a process could only get
and set its own resource limits via getrlimit(2) and setrlimit(2), so no
MAC checks were required for those operations, and thus no security hooks
were defined for them. Later, SELinux introduced a hook for setlimit(2)
with a check if the hard limit was being changed in order to be able to
rely on the hard limit value as a safe reset point upon context
transitions.
Later on, when prlimit(2) was added to the kernel with the ability to get
or set resource limits (hard or soft) of another process, LSM/SELinux was
not updated other than to pass the target process to the setrlimit hook.
This resulted in incomplete control over both getting and setting the
resource limits of another process.
Add a new security_task_prlimit() hook to the check_prlimit_permission()
function to provide complete mediation. The hook is only called when
acting on another task, and only if the existing DAC/capability checks
would allow access. Pass flags down to the hook to indicate whether the
prlimit(2) call will read, write, or both read and write the resource
limits of the target process.
The existing security_task_setrlimit() hook is left alone; it continues
to serve a purpose in supporting the ability to make decisions based on
the old and/or new resource limit values when setting limits. This
is consistent with the DAC/capability logic, where
check_prlimit_permission() performs generic DAC/capability checks for
acting on another task, while do_prlimit() performs a capability check
based on a comparison of the old and new resource limits. Fix the
inline documentation for the hook to match the code.
Implement the new hook for SELinux. For setting resource limits, we
reuse the existing setrlimit permission. Note that this does overload
the setrlimit permission to mean the ability to set the resource limit
(soft or hard) of another process or the ability to change one's own
hard limit. For getting resource limits, a new getrlimit permission
is defined. This was not originally defined since getrlimit(2) could
only be used to obtain a process' own limits.
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <james.l.morris@oracle.com>
2017-02-17 12:57:00 +00:00
|
|
|
* Check permission before setting the resource limits of process @p
|
|
|
|
* for @resource to @new_rlim. The old resource limit values can
|
|
|
|
* be examined by dereferencing (p->signal->rlim + resource).
|
|
|
|
* @p points to the task_struct for the target task's group leader.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @resource contains the resource whose limit is being set.
|
|
|
|
* @new_rlim contains the new limits for @resource.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @task_setscheduler:
|
|
|
|
* Check permission before setting scheduling policy and/or parameters of
|
2019-02-26 20:49:05 +00:00
|
|
|
* process @p.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @p contains the task_struct for process.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @task_getscheduler:
|
|
|
|
* Check permission before obtaining scheduling information for process
|
|
|
|
* @p.
|
|
|
|
* @p contains the task_struct for process.
|
|
|
|
* Return 0 if permission is granted.
|
2019-02-26 20:49:12 +00:00
|
|
|
* @task_movememory:
|
2015-05-02 22:10:53 +00:00
|
|
|
* Check permission before moving memory owned by process @p.
|
|
|
|
* @p contains the task_struct for process.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @task_kill:
|
|
|
|
* Check permission before sending signal @sig to @p. @info can be NULL,
|
2018-09-25 09:27:20 +00:00
|
|
|
* the constant 1, or a pointer to a kernel_siginfo structure. If @info is 1 or
|
2015-05-02 22:10:53 +00:00
|
|
|
* SI_FROMKERNEL(info) is true, then the signal should be viewed as coming
|
|
|
|
* from the kernel and should typically be permitted.
|
|
|
|
* SIGIO signals are handled separately by the send_sigiotask hook in
|
|
|
|
* file_security_ops.
|
|
|
|
* @p contains the task_struct for process.
|
|
|
|
* @info contains the signal information.
|
|
|
|
* @sig contains the signal value.
|
usb, signal, security: only pass the cred, not the secid, to kill_pid_info_as_cred and security_task_kill
commit d178bc3a708f39cbfefc3fab37032d3f2511b4ec ("user namespace: usb:
make usb urbs user namespace aware (v2)") changed kill_pid_info_as_uid
to kill_pid_info_as_cred, saving and passing a cred structure instead of
uids. Since the secid can be obtained from the cred, drop the secid fields
from the usb_dev_state and async structures, and drop the secid argument to
kill_pid_info_as_cred. Replace the secid argument to security_task_kill
with the cred. Update SELinux, Smack, and AppArmor to use the cred, which
avoids the need for Smack and AppArmor to use a secid at all in this hook.
Further changes to Smack might still be required to take full advantage of
this change, since it should now be possible to perform capability
checking based on the supplied cred. The changes to Smack and AppArmor
have only been compile-tested.
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Acked-by: Paul Moore <paul@paul-moore.com>
Acked-by: Casey Schaufler <casey@schaufler-ca.com>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Acked-by: John Johansen <john.johansen@canonical.com>
Signed-off-by: James Morris <james.morris@microsoft.com>
2017-09-08 16:40:01 +00:00
|
|
|
* @cred contains the cred of the process where the signal originated, or
|
|
|
|
* NULL if the current task is the originator.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @task_prctl:
|
|
|
|
* Check permission before performing a process control operation on the
|
|
|
|
* current process.
|
|
|
|
* @option contains the operation.
|
|
|
|
* @arg2 contains a argument.
|
|
|
|
* @arg3 contains a argument.
|
|
|
|
* @arg4 contains a argument.
|
|
|
|
* @arg5 contains a argument.
|
|
|
|
* Return -ENOSYS if no-one wanted to handle this op, any other value to
|
|
|
|
* cause prctl() to return immediately with that value.
|
|
|
|
* @task_to_inode:
|
|
|
|
* Set the security attributes for an inode based on an associated task's
|
|
|
|
* security attributes, e.g. for /proc/pid inodes.
|
|
|
|
* @p contains the task_struct for the task.
|
|
|
|
* @inode contains the inode structure for the inode.
|
|
|
|
*
|
|
|
|
* Security hooks for Netlink messaging.
|
|
|
|
*
|
|
|
|
* @netlink_send:
|
|
|
|
* Save security information for a netlink message so that permission
|
|
|
|
* checking can be performed when the message is processed. The security
|
|
|
|
* information can be saved using the eff_cap field of the
|
|
|
|
* netlink_skb_parms structure. Also may be used to provide fine
|
|
|
|
* grained control over message transmission.
|
|
|
|
* @sk associated sock of task sending the message.
|
|
|
|
* @skb contains the sk_buff structure for the netlink message.
|
|
|
|
* Return 0 if the information was successfully saved and message
|
|
|
|
* is allowed to be transmitted.
|
|
|
|
*
|
|
|
|
* Security hooks for Unix domain networking.
|
|
|
|
*
|
|
|
|
* @unix_stream_connect:
|
|
|
|
* Check permissions before establishing a Unix domain stream connection
|
|
|
|
* between @sock and @other.
|
|
|
|
* @sock contains the sock structure.
|
|
|
|
* @other contains the peer sock structure.
|
|
|
|
* @newsk contains the new sock structure.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @unix_may_send:
|
|
|
|
* Check permissions before connecting or sending datagrams from @sock to
|
|
|
|
* @other.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* @other contains the peer socket structure.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
*
|
|
|
|
* The @unix_stream_connect and @unix_may_send hooks were necessary because
|
|
|
|
* Linux provides an alternative to the conventional file name space for Unix
|
|
|
|
* domain sockets. Whereas binding and connecting to sockets in the file name
|
|
|
|
* space is mediated by the typical file permissions (and caught by the mknod
|
|
|
|
* and permission hooks in inode_security_ops), binding and connecting to
|
|
|
|
* sockets in the abstract name space is completely unmediated. Sufficient
|
|
|
|
* control of Unix domain sockets in the abstract name space isn't possible
|
|
|
|
* using only the socket layer hooks, since we need to know the actual target
|
|
|
|
* socket, which is not looked up until we are inside the af_unix code.
|
|
|
|
*
|
|
|
|
* Security hooks for socket operations.
|
|
|
|
*
|
|
|
|
* @socket_create:
|
|
|
|
* Check permissions prior to creating a new socket.
|
|
|
|
* @family contains the requested protocol family.
|
|
|
|
* @type contains the requested communications type.
|
|
|
|
* @protocol contains the requested protocol.
|
|
|
|
* @kern set to 1 if a kernel socket.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_post_create:
|
|
|
|
* This hook allows a module to update or allocate a per-socket security
|
|
|
|
* structure. Note that the security field was not added directly to the
|
|
|
|
* socket structure, but rather, the socket security information is stored
|
|
|
|
* in the associated inode. Typically, the inode alloc_security hook will
|
2020-07-17 23:36:40 +00:00
|
|
|
* allocate and attach security information to
|
2019-02-26 20:49:04 +00:00
|
|
|
* SOCK_INODE(sock)->i_security. This hook may be used to update the
|
|
|
|
* SOCK_INODE(sock)->i_security field with additional information that
|
|
|
|
* wasn't available when the inode was allocated.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @sock contains the newly created socket structure.
|
|
|
|
* @family contains the requested protocol family.
|
|
|
|
* @type contains the requested communications type.
|
|
|
|
* @protocol contains the requested protocol.
|
|
|
|
* @kern set to 1 if a kernel socket.
|
2018-05-04 14:28:19 +00:00
|
|
|
* @socket_socketpair:
|
|
|
|
* Check permissions before creating a fresh pair of sockets.
|
|
|
|
* @socka contains the first socket structure.
|
|
|
|
* @sockb contains the second socket structure.
|
|
|
|
* Return 0 if permission is granted and the connection was established.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @socket_bind:
|
|
|
|
* Check permission before socket protocol layer bind operation is
|
|
|
|
* performed and the socket @sock is bound to the address specified in the
|
|
|
|
* @address parameter.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* @address contains the address to bind to.
|
|
|
|
* @addrlen contains the length of address.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_connect:
|
|
|
|
* Check permission before socket protocol layer connect operation
|
|
|
|
* attempts to connect socket @sock to a remote address, @address.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* @address contains the address of remote endpoint.
|
|
|
|
* @addrlen contains the length of address.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_listen:
|
|
|
|
* Check permission before socket protocol layer listen operation.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* @backlog contains the maximum length for the pending connection queue.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_accept:
|
|
|
|
* Check permission before accepting a new connection. Note that the new
|
|
|
|
* socket, @newsock, has been created and some information copied to it,
|
|
|
|
* but the accept operation has not actually been performed.
|
|
|
|
* @sock contains the listening socket structure.
|
|
|
|
* @newsock contains the newly created server socket for connection.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_sendmsg:
|
|
|
|
* Check permission before transmitting a message to another socket.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* @msg contains the message to be transmitted.
|
|
|
|
* @size contains the size of message.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_recvmsg:
|
|
|
|
* Check permission before receiving a message from a socket.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* @msg contains the message structure.
|
|
|
|
* @size contains the size of message structure.
|
|
|
|
* @flags contains the operational flags.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_getsockname:
|
|
|
|
* Check permission before the local address (name) of the socket object
|
|
|
|
* @sock is retrieved.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_getpeername:
|
|
|
|
* Check permission before the remote address (name) of a socket object
|
|
|
|
* @sock is retrieved.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_getsockopt:
|
|
|
|
* Check permissions before retrieving the options associated with socket
|
|
|
|
* @sock.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* @level contains the protocol level to retrieve option from.
|
|
|
|
* @optname contains the name of option to retrieve.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_setsockopt:
|
|
|
|
* Check permissions before setting the options associated with socket
|
|
|
|
* @sock.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* @level contains the protocol level to set options for.
|
|
|
|
* @optname contains the name of the option to set.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_shutdown:
|
|
|
|
* Checks permission before all or part of a connection on the socket
|
|
|
|
* @sock is shut down.
|
|
|
|
* @sock contains the socket structure.
|
|
|
|
* @how contains the flag indicating how future sends and receives
|
|
|
|
* are handled.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @socket_sock_rcv_skb:
|
|
|
|
* Check permissions on incoming network packets. This hook is distinct
|
|
|
|
* from Netfilter's IP input hooks since it is the first time that the
|
|
|
|
* incoming sk_buff @skb has been associated with a particular socket, @sk.
|
|
|
|
* Must not sleep inside this hook because some callers hold spinlocks.
|
|
|
|
* @sk contains the sock (not socket) associated with the incoming sk_buff.
|
|
|
|
* @skb contains the incoming network data.
|
|
|
|
* @socket_getpeersec_stream:
|
|
|
|
* This hook allows the security module to provide peer socket security
|
|
|
|
* state for unix or connected tcp sockets to userspace via getsockopt
|
|
|
|
* SO_GETPEERSEC. For tcp sockets this can be meaningful if the
|
|
|
|
* socket is associated with an ipsec SA.
|
|
|
|
* @sock is the local socket.
|
|
|
|
* @optval userspace memory where the security state is to be copied.
|
|
|
|
* @optlen userspace int where the module should copy the actual length
|
|
|
|
* of the security state.
|
|
|
|
* @len as input is the maximum length to copy to userspace provided
|
|
|
|
* by the caller.
|
|
|
|
* Return 0 if all is well, otherwise, typical getsockopt return
|
|
|
|
* values.
|
|
|
|
* @socket_getpeersec_dgram:
|
|
|
|
* This hook allows the security module to provide peer socket security
|
|
|
|
* state for udp sockets on a per-packet basis to userspace via
|
2019-02-26 20:49:06 +00:00
|
|
|
* getsockopt SO_GETPEERSEC. The application must first have indicated
|
|
|
|
* the IP_PASSSEC option via getsockopt. It can then retrieve the
|
2015-05-02 22:10:53 +00:00
|
|
|
* security state returned by this hook for a packet via the SCM_SECURITY
|
|
|
|
* ancillary message type.
|
2019-02-26 20:49:06 +00:00
|
|
|
* @sock contains the peer socket. May be NULL.
|
|
|
|
* @skb is the sk_buff for the packet being queried. May be NULL.
|
|
|
|
* @secid pointer to store the secid of the packet.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 on success, error on failure.
|
|
|
|
* @sk_alloc_security:
|
|
|
|
* Allocate and attach a security structure to the sk->sk_security field,
|
|
|
|
* which is used to copy security attributes between local stream sockets.
|
|
|
|
* @sk_free_security:
|
|
|
|
* Deallocate security structure.
|
|
|
|
* @sk_clone_security:
|
|
|
|
* Clone/copy security structure.
|
|
|
|
* @sk_getsecid:
|
|
|
|
* Retrieve the LSM-specific secid for the sock to enable caching
|
|
|
|
* of network authorizations.
|
|
|
|
* @sock_graft:
|
|
|
|
* Sets the socket's isec sid to the sock's sid.
|
|
|
|
* @inet_conn_request:
|
|
|
|
* Sets the openreq's sid to socket's sid with MLS portion taken
|
|
|
|
* from peer sid.
|
|
|
|
* @inet_csk_clone:
|
|
|
|
* Sets the new child socket's sid to the openreq sid.
|
|
|
|
* @inet_conn_established:
|
|
|
|
* Sets the connection's peersid to the secmark on skb.
|
|
|
|
* @secmark_relabel_packet:
|
|
|
|
* check if the process should be allowed to relabel packets to
|
|
|
|
* the given secid
|
2019-02-26 20:49:12 +00:00
|
|
|
* @secmark_refcount_inc:
|
2015-05-02 22:10:53 +00:00
|
|
|
* tells the LSM to increment the number of secmark labeling rules loaded
|
2019-02-26 20:49:12 +00:00
|
|
|
* @secmark_refcount_dec:
|
2015-05-02 22:10:53 +00:00
|
|
|
* tells the LSM to decrement the number of secmark labeling rules loaded
|
|
|
|
* @req_classify_flow:
|
|
|
|
* Sets the flow's sid to the openreq sid.
|
|
|
|
* @tun_dev_alloc_security:
|
|
|
|
* This hook allows a module to allocate a security structure for a TUN
|
|
|
|
* device.
|
|
|
|
* @security pointer to a security structure pointer.
|
|
|
|
* Returns a zero on success, negative values on failure.
|
|
|
|
* @tun_dev_free_security:
|
|
|
|
* This hook allows a module to free the security structure for a TUN
|
|
|
|
* device.
|
|
|
|
* @security pointer to the TUN device's security structure
|
|
|
|
* @tun_dev_create:
|
|
|
|
* Check permissions prior to creating a new TUN device.
|
|
|
|
* @tun_dev_attach_queue:
|
|
|
|
* Check permissions prior to attaching to a TUN device queue.
|
|
|
|
* @security pointer to the TUN device's security structure.
|
|
|
|
* @tun_dev_attach:
|
|
|
|
* This hook can be used by the module to update any security state
|
|
|
|
* associated with the TUN device's sock structure.
|
|
|
|
* @sk contains the existing sock structure.
|
|
|
|
* @security pointer to the TUN device's security structure.
|
|
|
|
* @tun_dev_open:
|
|
|
|
* This hook can be used by the module to update any security state
|
|
|
|
* associated with the TUN device's security structure.
|
|
|
|
* @security pointer to the TUN devices's security structure.
|
|
|
|
*
|
2018-02-13 20:53:21 +00:00
|
|
|
* Security hooks for SCTP
|
|
|
|
*
|
|
|
|
* @sctp_assoc_request:
|
2021-11-02 12:02:47 +00:00
|
|
|
* Passes the @asoc and @chunk->skb of the association INIT packet to
|
2018-02-13 20:53:21 +00:00
|
|
|
* the security module.
|
2021-11-02 12:02:47 +00:00
|
|
|
* @asoc pointer to sctp association structure.
|
2018-02-13 20:53:21 +00:00
|
|
|
* @skb pointer to skbuff of association packet.
|
|
|
|
* Return 0 on success, error on failure.
|
|
|
|
* @sctp_bind_connect:
|
|
|
|
* Validiate permissions required for each address associated with sock
|
|
|
|
* @sk. Depending on @optname, the addresses will be treated as either
|
|
|
|
* for a connect or bind service. The @addrlen is calculated on each
|
|
|
|
* ipv4 and ipv6 address using sizeof(struct sockaddr_in) or
|
|
|
|
* sizeof(struct sockaddr_in6).
|
|
|
|
* @sk pointer to sock structure.
|
|
|
|
* @optname name of the option to validate.
|
|
|
|
* @address list containing one or more ipv4/ipv6 addresses.
|
|
|
|
* @addrlen total length of address(s).
|
|
|
|
* Return 0 on success, error on failure.
|
|
|
|
* @sctp_sk_clone:
|
|
|
|
* Called whenever a new socket is created by accept(2) (i.e. a TCP
|
|
|
|
* style socket) or when a socket is 'peeled off' e.g userspace
|
|
|
|
* calls sctp_peeloff(3).
|
2021-11-02 12:02:47 +00:00
|
|
|
* @asoc pointer to current sctp association structure.
|
2018-02-13 20:53:21 +00:00
|
|
|
* @sk pointer to current sock structure.
|
2021-11-02 12:02:47 +00:00
|
|
|
* @newsk pointer to new sock structure.
|
2022-02-12 17:59:21 +00:00
|
|
|
* @sctp_assoc_established:
|
|
|
|
* Passes the @asoc and @chunk->skb of the association COOKIE_ACK packet
|
|
|
|
* to the security module.
|
|
|
|
* @asoc pointer to sctp association structure.
|
|
|
|
* @skb pointer to skbuff of association packet.
|
2018-02-13 20:53:21 +00:00
|
|
|
*
|
IB/core: Enforce PKey security on QPs
Add new LSM hooks to allocate and free security contexts and check for
permission to access a PKey.
Allocate and free a security context when creating and destroying a QP.
This context is used for controlling access to PKeys.
When a request is made to modify a QP that changes the port, PKey index,
or alternate path, check that the QP has permission for the PKey in the
PKey table index on the subnet prefix of the port. If the QP is shared
make sure all handles to the QP also have access.
Store which port and PKey index a QP is using. After the reset to init
transition the user can modify the port, PKey index and alternate path
independently. So port and PKey settings changes can be a merge of the
previous settings and the new ones.
In order to maintain access control if there are PKey table or subnet
prefix change keep a list of all QPs are using each PKey index on
each port. If a change occurs all QPs using that device and port must
have access enforced for the new cache settings.
These changes add a transaction to the QP modify process. Association
with the old port and PKey index must be maintained if the modify fails,
and must be removed if it succeeds. Association with the new port and
PKey index must be established prior to the modify and removed if the
modify fails.
1. When a QP is modified to a particular Port, PKey index or alternate
path insert that QP into the appropriate lists.
2. Check permission to access the new settings.
3. If step 2 grants access attempt to modify the QP.
4a. If steps 2 and 3 succeed remove any prior associations.
4b. If ether fails remove the new setting associations.
If a PKey table or subnet prefix changes walk the list of QPs and
check that they have permission. If not send the QP to the error state
and raise a fatal error event. If it's a shared QP make sure all the
QPs that share the real_qp have permission as well. If the QP that
owns a security structure is denied access the security structure is
marked as such and the QP is added to an error_list. Once the moving
the QP to error is complete the security structure mark is cleared.
Maintaining the lists correctly turns QP destroy into a transaction.
The hardware driver for the device frees the ib_qp structure, so while
the destroy is in progress the ib_qp pointer in the ib_qp_security
struct is undefined. When the destroy process begins the ib_qp_security
structure is marked as destroying. This prevents any action from being
taken on the QP pointer. After the QP is destroyed successfully it
could still listed on an error_list wait for it to be processed by that
flow before cleaning up the structure.
If the destroy fails the QPs port and PKey settings are reinserted into
the appropriate lists, the destroying flag is cleared, and access control
is enforced, in case there were any cache changes during the destroy
flow.
To keep the security changes isolated a new file is used to hold security
related functionality.
Signed-off-by: Daniel Jurgens <danielj@mellanox.com>
Acked-by: Doug Ledford <dledford@redhat.com>
[PM: merge fixup in ib_verbs.h and uverbs_cmd.c]
Signed-off-by: Paul Moore <paul@paul-moore.com>
2017-05-19 12:48:52 +00:00
|
|
|
* Security hooks for Infiniband
|
|
|
|
*
|
|
|
|
* @ib_pkey_access:
|
|
|
|
* Check permission to access a pkey when modifing a QP.
|
|
|
|
* @subnet_prefix the subnet prefix of the port being used.
|
|
|
|
* @pkey the pkey to be accessed.
|
|
|
|
* @sec pointer to a security structure.
|
2017-05-19 12:48:54 +00:00
|
|
|
* @ib_endport_manage_subnet:
|
|
|
|
* Check permissions to send and receive SMPs on a end port.
|
|
|
|
* @dev_name the IB device name (i.e. mlx4_0).
|
|
|
|
* @port_num the port number.
|
|
|
|
* @sec pointer to a security structure.
|
IB/core: Enforce PKey security on QPs
Add new LSM hooks to allocate and free security contexts and check for
permission to access a PKey.
Allocate and free a security context when creating and destroying a QP.
This context is used for controlling access to PKeys.
When a request is made to modify a QP that changes the port, PKey index,
or alternate path, check that the QP has permission for the PKey in the
PKey table index on the subnet prefix of the port. If the QP is shared
make sure all handles to the QP also have access.
Store which port and PKey index a QP is using. After the reset to init
transition the user can modify the port, PKey index and alternate path
independently. So port and PKey settings changes can be a merge of the
previous settings and the new ones.
In order to maintain access control if there are PKey table or subnet
prefix change keep a list of all QPs are using each PKey index on
each port. If a change occurs all QPs using that device and port must
have access enforced for the new cache settings.
These changes add a transaction to the QP modify process. Association
with the old port and PKey index must be maintained if the modify fails,
and must be removed if it succeeds. Association with the new port and
PKey index must be established prior to the modify and removed if the
modify fails.
1. When a QP is modified to a particular Port, PKey index or alternate
path insert that QP into the appropriate lists.
2. Check permission to access the new settings.
3. If step 2 grants access attempt to modify the QP.
4a. If steps 2 and 3 succeed remove any prior associations.
4b. If ether fails remove the new setting associations.
If a PKey table or subnet prefix changes walk the list of QPs and
check that they have permission. If not send the QP to the error state
and raise a fatal error event. If it's a shared QP make sure all the
QPs that share the real_qp have permission as well. If the QP that
owns a security structure is denied access the security structure is
marked as such and the QP is added to an error_list. Once the moving
the QP to error is complete the security structure mark is cleared.
Maintaining the lists correctly turns QP destroy into a transaction.
The hardware driver for the device frees the ib_qp structure, so while
the destroy is in progress the ib_qp pointer in the ib_qp_security
struct is undefined. When the destroy process begins the ib_qp_security
structure is marked as destroying. This prevents any action from being
taken on the QP pointer. After the QP is destroyed successfully it
could still listed on an error_list wait for it to be processed by that
flow before cleaning up the structure.
If the destroy fails the QPs port and PKey settings are reinserted into
the appropriate lists, the destroying flag is cleared, and access control
is enforced, in case there were any cache changes during the destroy
flow.
To keep the security changes isolated a new file is used to hold security
related functionality.
Signed-off-by: Daniel Jurgens <danielj@mellanox.com>
Acked-by: Doug Ledford <dledford@redhat.com>
[PM: merge fixup in ib_verbs.h and uverbs_cmd.c]
Signed-off-by: Paul Moore <paul@paul-moore.com>
2017-05-19 12:48:52 +00:00
|
|
|
* @ib_alloc_security:
|
|
|
|
* Allocate a security structure for Infiniband objects.
|
|
|
|
* @sec pointer to a security structure pointer.
|
|
|
|
* Returns 0 on success, non-zero on failure
|
|
|
|
* @ib_free_security:
|
|
|
|
* Deallocate an Infiniband security structure.
|
|
|
|
* @sec contains the security structure to be freed.
|
|
|
|
*
|
2015-05-02 22:10:53 +00:00
|
|
|
* Security hooks for XFRM operations.
|
|
|
|
*
|
|
|
|
* @xfrm_policy_alloc_security:
|
|
|
|
* @ctxp is a pointer to the xfrm_sec_ctx being added to Security Policy
|
|
|
|
* Database used by the XFRM system.
|
|
|
|
* @sec_ctx contains the security context information being provided by
|
|
|
|
* the user-level policy update program (e.g., setkey).
|
|
|
|
* Allocate a security structure to the xp->security field; the security
|
|
|
|
* field is initialized to NULL when the xfrm_policy is allocated.
|
|
|
|
* Return 0 if operation was successful (memory to allocate, legal context)
|
|
|
|
* @gfp is to specify the context for the allocation
|
|
|
|
* @xfrm_policy_clone_security:
|
|
|
|
* @old_ctx contains an existing xfrm_sec_ctx.
|
|
|
|
* @new_ctxp contains a new xfrm_sec_ctx being cloned from old.
|
|
|
|
* Allocate a security structure in new_ctxp that contains the
|
|
|
|
* information from the old_ctx structure.
|
|
|
|
* Return 0 if operation was successful (memory to allocate).
|
|
|
|
* @xfrm_policy_free_security:
|
|
|
|
* @ctx contains the xfrm_sec_ctx
|
|
|
|
* Deallocate xp->security.
|
|
|
|
* @xfrm_policy_delete_security:
|
|
|
|
* @ctx contains the xfrm_sec_ctx.
|
|
|
|
* Authorize deletion of xp->security.
|
|
|
|
* @xfrm_state_alloc:
|
|
|
|
* @x contains the xfrm_state being added to the Security Association
|
|
|
|
* Database by the XFRM system.
|
|
|
|
* @sec_ctx contains the security context information being provided by
|
|
|
|
* the user-level SA generation program (e.g., setkey or racoon).
|
|
|
|
* Allocate a security structure to the x->security field; the security
|
|
|
|
* field is initialized to NULL when the xfrm_state is allocated. Set the
|
|
|
|
* context to correspond to sec_ctx. Return 0 if operation was successful
|
|
|
|
* (memory to allocate, legal context).
|
|
|
|
* @xfrm_state_alloc_acquire:
|
|
|
|
* @x contains the xfrm_state being added to the Security Association
|
|
|
|
* Database by the XFRM system.
|
|
|
|
* @polsec contains the policy's security context.
|
|
|
|
* @secid contains the secid from which to take the mls portion of the
|
|
|
|
* context.
|
|
|
|
* Allocate a security structure to the x->security field; the security
|
|
|
|
* field is initialized to NULL when the xfrm_state is allocated. Set the
|
|
|
|
* context to correspond to secid. Return 0 if operation was successful
|
|
|
|
* (memory to allocate, legal context).
|
|
|
|
* @xfrm_state_free_security:
|
|
|
|
* @x contains the xfrm_state.
|
|
|
|
* Deallocate x->security.
|
|
|
|
* @xfrm_state_delete_security:
|
|
|
|
* @x contains the xfrm_state.
|
|
|
|
* Authorize deletion of x->security.
|
|
|
|
* @xfrm_policy_lookup:
|
|
|
|
* @ctx contains the xfrm_sec_ctx for which the access control is being
|
|
|
|
* checked.
|
|
|
|
* @fl_secid contains the flow security label that is used to authorize
|
|
|
|
* access to the policy xp.
|
|
|
|
* @dir contains the direction of the flow (input or output).
|
|
|
|
* Check permission when a flow selects a xfrm_policy for processing
|
|
|
|
* XFRMs on a packet. The hook is called when selecting either a
|
|
|
|
* per-socket policy or a generic xfrm policy.
|
|
|
|
* Return 0 if permission is granted, -ESRCH otherwise, or -errno
|
|
|
|
* on other errors.
|
|
|
|
* @xfrm_state_pol_flow_match:
|
|
|
|
* @x contains the state to match.
|
|
|
|
* @xp contains the policy to check for a match.
|
2020-09-28 02:38:26 +00:00
|
|
|
* @flic contains the flowi_common struct to check for a match.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 1 if there is a match.
|
|
|
|
* @xfrm_decode_session:
|
|
|
|
* @skb points to skb to decode.
|
|
|
|
* @secid points to the flow key secid to set.
|
|
|
|
* @ckall says if all xfrms used should be checked for same secid.
|
|
|
|
* Return 0 if ckall is zero or all xfrms used have the same secid.
|
|
|
|
*
|
|
|
|
* Security hooks affecting all Key Management operations
|
|
|
|
*
|
|
|
|
* @key_alloc:
|
|
|
|
* Permit allocation of a key and assign security data. Note that key does
|
|
|
|
* not have a serial number assigned at this point.
|
|
|
|
* @key points to the key.
|
|
|
|
* @flags is the allocation flags
|
|
|
|
* Return 0 if permission is granted, -ve error otherwise.
|
|
|
|
* @key_free:
|
|
|
|
* Notification of destruction; free security data.
|
|
|
|
* @key points to the key.
|
|
|
|
* No return value.
|
|
|
|
* @key_permission:
|
|
|
|
* See whether a specific operational right is granted to a process on a
|
|
|
|
* key.
|
|
|
|
* @key_ref refers to the key (key pointer + possession attribute bit).
|
|
|
|
* @cred points to the credentials to provide the context against which to
|
|
|
|
* evaluate the security data on the key.
|
|
|
|
* @perm describes the combination of permissions required of this key.
|
|
|
|
* Return 0 if permission is granted, -ve error otherwise.
|
|
|
|
* @key_getsecurity:
|
|
|
|
* Get a textual representation of the security context attached to a key
|
|
|
|
* for the purposes of honouring KEYCTL_GETSECURITY. This function
|
|
|
|
* allocates the storage for the NUL-terminated string and the caller
|
|
|
|
* should free it.
|
|
|
|
* @key points to the key to be queried.
|
|
|
|
* @_buffer points to a pointer that should be set to point to the
|
|
|
|
* resulting string (if no label or an error occurs).
|
|
|
|
* Return the length of the string (including terminating NUL) or -ve if
|
|
|
|
* an error.
|
|
|
|
* May also return 0 (and a NULL buffer pointer) if there is no label.
|
|
|
|
*
|
|
|
|
* Security hooks affecting all System V IPC operations.
|
|
|
|
*
|
|
|
|
* @ipc_permission:
|
|
|
|
* Check permissions for access to IPC
|
|
|
|
* @ipcp contains the kernel IPC permission structure
|
|
|
|
* @flag contains the desired (requested) permission set
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @ipc_getsecid:
|
|
|
|
* Get the secid associated with the ipc object.
|
|
|
|
* @ipcp contains the kernel IPC permission structure.
|
|
|
|
* @secid contains a pointer to the location where result will be saved.
|
|
|
|
* In case of failure, @secid will be set to zero.
|
|
|
|
*
|
|
|
|
* Security hooks for individual messages held in System V IPC message queues
|
2020-02-16 07:08:38 +00:00
|
|
|
*
|
2015-05-02 22:10:53 +00:00
|
|
|
* @msg_msg_alloc_security:
|
|
|
|
* Allocate and attach a security structure to the msg->security field.
|
|
|
|
* The security field is initialized to NULL when the structure is first
|
|
|
|
* created.
|
|
|
|
* @msg contains the message structure to be modified.
|
|
|
|
* Return 0 if operation was successful and permission is granted.
|
|
|
|
* @msg_msg_free_security:
|
|
|
|
* Deallocate the security structure for this message.
|
|
|
|
* @msg contains the message structure to be modified.
|
|
|
|
*
|
|
|
|
* Security hooks for System V IPC Message Queues
|
|
|
|
*
|
|
|
|
* @msg_queue_alloc_security:
|
|
|
|
* Allocate and attach a security structure to the
|
2019-02-26 20:49:09 +00:00
|
|
|
* @perm->security field. The security field is initialized to
|
2015-05-02 22:10:53 +00:00
|
|
|
* NULL when the structure is first created.
|
2019-02-26 20:49:09 +00:00
|
|
|
* @perm contains the IPC permissions of the message queue.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if operation was successful and permission is granted.
|
|
|
|
* @msg_queue_free_security:
|
2019-02-26 20:49:09 +00:00
|
|
|
* Deallocate security field @perm->security for the message queue.
|
|
|
|
* @perm contains the IPC permissions of the message queue.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @msg_queue_associate:
|
|
|
|
* Check permission when a message queue is requested through the
|
2019-02-26 20:49:09 +00:00
|
|
|
* msgget system call. This hook is only called when returning the
|
2015-05-02 22:10:53 +00:00
|
|
|
* message queue identifier for an existing message queue, not when a
|
|
|
|
* new message queue is created.
|
2019-02-26 20:49:09 +00:00
|
|
|
* @perm contains the IPC permissions of the message queue.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @msqflg contains the operation control flags.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @msg_queue_msgctl:
|
|
|
|
* Check permission when a message control operation specified by @cmd
|
2019-02-26 20:49:09 +00:00
|
|
|
* is to be performed on the message queue with permissions @perm.
|
|
|
|
* The @perm may be NULL, e.g. for IPC_INFO or MSG_INFO.
|
|
|
|
* @perm contains the IPC permissions of the msg queue. May be NULL.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @cmd contains the operation to be performed.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @msg_queue_msgsnd:
|
|
|
|
* Check permission before a message, @msg, is enqueued on the message
|
2019-02-26 20:49:09 +00:00
|
|
|
* queue with permissions @perm.
|
|
|
|
* @perm contains the IPC permissions of the message queue.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @msg contains the message to be enqueued.
|
|
|
|
* @msqflg contains operational flags.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @msg_queue_msgrcv:
|
|
|
|
* Check permission before a message, @msg, is removed from the message
|
2019-02-26 20:49:09 +00:00
|
|
|
* queue. The @target task structure contains a pointer to the
|
2015-05-02 22:10:53 +00:00
|
|
|
* process that will be receiving the message (not equal to the current
|
|
|
|
* process when inline receives are being performed).
|
2019-02-26 20:49:09 +00:00
|
|
|
* @perm contains the IPC permissions of the message queue.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @msg contains the message destination.
|
|
|
|
* @target contains the task structure for recipient process.
|
|
|
|
* @type contains the type of message requested.
|
|
|
|
* @mode contains the operational flags.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
*
|
|
|
|
* Security hooks for System V Shared Memory Segments
|
|
|
|
*
|
|
|
|
* @shm_alloc_security:
|
2019-02-26 20:49:11 +00:00
|
|
|
* Allocate and attach a security structure to the @perm->security
|
|
|
|
* field. The security field is initialized to NULL when the structure is
|
2015-05-02 22:10:53 +00:00
|
|
|
* first created.
|
2019-02-26 20:49:11 +00:00
|
|
|
* @perm contains the IPC permissions of the shared memory structure.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if operation was successful and permission is granted.
|
|
|
|
* @shm_free_security:
|
2019-02-26 20:49:11 +00:00
|
|
|
* Deallocate the security structure @perm->security for the memory segment.
|
|
|
|
* @perm contains the IPC permissions of the shared memory structure.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @shm_associate:
|
|
|
|
* Check permission when a shared memory region is requested through the
|
2019-02-26 20:49:11 +00:00
|
|
|
* shmget system call. This hook is only called when returning the shared
|
2015-05-02 22:10:53 +00:00
|
|
|
* memory region identifier for an existing region, not when a new shared
|
|
|
|
* memory region is created.
|
2019-02-26 20:49:11 +00:00
|
|
|
* @perm contains the IPC permissions of the shared memory structure.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @shmflg contains the operation control flags.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @shm_shmctl:
|
|
|
|
* Check permission when a shared memory control operation specified by
|
2019-02-26 20:49:11 +00:00
|
|
|
* @cmd is to be performed on the shared memory region with permissions @perm.
|
|
|
|
* The @perm may be NULL, e.g. for IPC_INFO or SHM_INFO.
|
|
|
|
* @perm contains the IPC permissions of the shared memory structure.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @cmd contains the operation to be performed.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @shm_shmat:
|
|
|
|
* Check permissions prior to allowing the shmat system call to attach the
|
2019-02-26 20:49:11 +00:00
|
|
|
* shared memory segment with permissions @perm to the data segment of the
|
|
|
|
* calling process. The attaching address is specified by @shmaddr.
|
|
|
|
* @perm contains the IPC permissions of the shared memory structure.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @shmaddr contains the address to attach memory region to.
|
|
|
|
* @shmflg contains the operational flags.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
*
|
|
|
|
* Security hooks for System V Semaphores
|
|
|
|
*
|
|
|
|
* @sem_alloc_security:
|
2019-02-26 20:49:10 +00:00
|
|
|
* Allocate and attach a security structure to the @perm->security
|
|
|
|
* field. The security field is initialized to NULL when the structure is
|
2015-05-02 22:10:53 +00:00
|
|
|
* first created.
|
2019-02-26 20:49:10 +00:00
|
|
|
* @perm contains the IPC permissions of the semaphore.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if operation was successful and permission is granted.
|
|
|
|
* @sem_free_security:
|
2019-02-26 20:49:10 +00:00
|
|
|
* Deallocate security structure @perm->security for the semaphore.
|
|
|
|
* @perm contains the IPC permissions of the semaphore.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @sem_associate:
|
|
|
|
* Check permission when a semaphore is requested through the semget
|
2019-02-26 20:49:10 +00:00
|
|
|
* system call. This hook is only called when returning the semaphore
|
2015-05-02 22:10:53 +00:00
|
|
|
* identifier for an existing semaphore, not when a new one must be
|
|
|
|
* created.
|
2019-02-26 20:49:10 +00:00
|
|
|
* @perm contains the IPC permissions of the semaphore.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @semflg contains the operation control flags.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @sem_semctl:
|
|
|
|
* Check permission when a semaphore operation specified by @cmd is to be
|
2019-02-26 20:49:10 +00:00
|
|
|
* performed on the semaphore. The @perm may be NULL, e.g. for
|
2015-05-02 22:10:53 +00:00
|
|
|
* IPC_INFO or SEM_INFO.
|
2019-02-26 20:49:10 +00:00
|
|
|
* @perm contains the IPC permissions of the semaphore. May be NULL.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @cmd contains the operation to be performed.
|
|
|
|
* Return 0 if permission is granted.
|
2017-05-13 11:51:42 +00:00
|
|
|
* @sem_semop:
|
2015-05-02 22:10:53 +00:00
|
|
|
* Check permissions before performing operations on members of the
|
2019-02-26 20:49:10 +00:00
|
|
|
* semaphore set. If the @alter flag is nonzero, the semaphore set
|
2015-05-02 22:10:53 +00:00
|
|
|
* may be modified.
|
2019-02-26 20:49:10 +00:00
|
|
|
* @perm contains the IPC permissions of the semaphore.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @sops contains the operations to perform.
|
|
|
|
* @nsops contains the number of operations to perform.
|
|
|
|
* @alter contains the flag indicating whether changes are to be made.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
*
|
2017-05-13 11:51:42 +00:00
|
|
|
* @binder_set_context_mgr:
|
2015-05-02 22:10:53 +00:00
|
|
|
* Check whether @mgr is allowed to be the binder context manager.
|
2021-10-12 16:56:13 +00:00
|
|
|
* @mgr contains the struct cred for the current binder process.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if permission is granted.
|
2017-05-13 11:51:42 +00:00
|
|
|
* @binder_transaction:
|
2015-05-02 22:10:53 +00:00
|
|
|
* Check whether @from is allowed to invoke a binder transaction call
|
|
|
|
* to @to.
|
2021-10-12 16:56:13 +00:00
|
|
|
* @from contains the struct cred for the sending process.
|
|
|
|
* @to contains the struct cred for the receiving process.
|
2017-05-13 11:51:42 +00:00
|
|
|
* @binder_transfer_binder:
|
2015-05-02 22:10:53 +00:00
|
|
|
* Check whether @from is allowed to transfer a binder reference to @to.
|
2021-10-12 16:56:13 +00:00
|
|
|
* @from contains the struct cred for the sending process.
|
|
|
|
* @to contains the struct cred for the receiving process.
|
2017-05-13 11:51:42 +00:00
|
|
|
* @binder_transfer_file:
|
2015-05-02 22:10:53 +00:00
|
|
|
* Check whether @from is allowed to transfer @file to @to.
|
2021-10-12 16:56:13 +00:00
|
|
|
* @from contains the struct cred for the sending process.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @file contains the struct file being transferred.
|
2021-10-12 16:56:13 +00:00
|
|
|
* @to contains the struct cred for the receiving process.
|
2015-05-02 22:10:53 +00:00
|
|
|
*
|
|
|
|
* @ptrace_access_check:
|
|
|
|
* Check permission before allowing the current process to trace the
|
|
|
|
* @child process.
|
|
|
|
* Security modules may also want to perform a process tracing check
|
|
|
|
* during an execve in the set_security or apply_creds hooks of
|
|
|
|
* tracing check during an execve in the bprm_set_creds hook of
|
|
|
|
* binprm_security_ops if the process is being traced and its security
|
|
|
|
* attributes would be changed by the execve.
|
|
|
|
* @child contains the task_struct structure for the target process.
|
|
|
|
* @mode contains the PTRACE_MODE flags indicating the form of access.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @ptrace_traceme:
|
|
|
|
* Check that the @parent process has sufficient permission to trace the
|
|
|
|
* current process before allowing the current process to present itself
|
|
|
|
* to the @parent process for tracing.
|
|
|
|
* @parent contains the task_struct structure for debugger process.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @capget:
|
|
|
|
* Get the @effective, @inheritable, and @permitted capability sets for
|
|
|
|
* the @target process. The hook may also perform permission checking to
|
|
|
|
* determine if the current process is allowed to see the capability sets
|
|
|
|
* of the @target process.
|
|
|
|
* @target contains the task_struct structure for target process.
|
|
|
|
* @effective contains the effective capability set.
|
|
|
|
* @inheritable contains the inheritable capability set.
|
|
|
|
* @permitted contains the permitted capability set.
|
|
|
|
* Return 0 if the capability sets were successfully obtained.
|
|
|
|
* @capset:
|
|
|
|
* Set the @effective, @inheritable, and @permitted capability sets for
|
|
|
|
* the current process.
|
|
|
|
* @new contains the new credentials structure for target process.
|
|
|
|
* @old contains the current credentials structure for target process.
|
|
|
|
* @effective contains the effective capability set.
|
|
|
|
* @inheritable contains the inheritable capability set.
|
|
|
|
* @permitted contains the permitted capability set.
|
|
|
|
* Return 0 and update @new if permission is granted.
|
|
|
|
* @capable:
|
|
|
|
* Check whether the @tsk process has the @cap capability in the indicated
|
|
|
|
* credentials.
|
|
|
|
* @cred contains the credentials to use.
|
|
|
|
* @ns contains the user namespace we want the capability in
|
|
|
|
* @cap contains the capability <include/linux/capability.h>.
|
2019-01-08 00:10:53 +00:00
|
|
|
* @opts contains options for the capable check <include/linux/security.h>
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if the capability is granted for @tsk.
|
2020-02-16 07:08:38 +00:00
|
|
|
* @quotactl:
|
|
|
|
* Check whether the quotactl syscall is allowed for this @sb.
|
|
|
|
* @quota_on:
|
|
|
|
* Check whether QUOTAON is allowed for this @dentry.
|
2015-05-02 22:10:53 +00:00
|
|
|
* @syslog:
|
|
|
|
* Check permission before accessing the kernel message ring or changing
|
|
|
|
* logging to the console.
|
|
|
|
* See the syslog(2) manual page for an explanation of the @type values.
|
2019-02-26 20:49:03 +00:00
|
|
|
* @type contains the SYSLOG_ACTION_* constant from <include/linux/syslog.h>
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @settime:
|
|
|
|
* Check permission to change the system time.
|
2019-02-26 20:49:12 +00:00
|
|
|
* struct timespec64 is defined in <include/linux/time64.h> and timezone
|
|
|
|
* is defined in <include/linux/time.h>
|
2015-05-02 22:10:53 +00:00
|
|
|
* @ts contains new time
|
|
|
|
* @tz contains new timezone
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
* @vm_enough_memory:
|
|
|
|
* Check permissions for allocating a new virtual mapping.
|
|
|
|
* @mm contains the mm struct it is being added to.
|
|
|
|
* @pages contains the number of pages.
|
|
|
|
* Return 0 if permission is granted.
|
|
|
|
*
|
|
|
|
* @ismaclabel:
|
|
|
|
* Check if the extended attribute specified by @name
|
|
|
|
* represents a MAC label. Returns 1 if name is a MAC
|
|
|
|
* attribute otherwise returns 0.
|
|
|
|
* @name full extended attribute name to check against
|
|
|
|
* LSM as a MAC label.
|
|
|
|
*
|
|
|
|
* @secid_to_secctx:
|
|
|
|
* Convert secid to security context. If secdata is NULL the length of
|
|
|
|
* the result will be returned in seclen, but no secdata will be returned.
|
|
|
|
* This does mean that the length could change between calls to check the
|
|
|
|
* length and the next call which actually allocates and returns the
|
|
|
|
* secdata.
|
|
|
|
* @secid contains the security ID.
|
|
|
|
* @secdata contains the pointer that stores the converted security
|
|
|
|
* context.
|
|
|
|
* @seclen pointer which contains the length of the data
|
|
|
|
* @secctx_to_secid:
|
|
|
|
* Convert security context to secid.
|
|
|
|
* @secid contains the pointer to the generated security ID.
|
|
|
|
* @secdata contains the security context.
|
|
|
|
*
|
|
|
|
* @release_secctx:
|
|
|
|
* Release the security context.
|
|
|
|
* @secdata contains the security context.
|
|
|
|
* @seclen contains the length of the security context.
|
|
|
|
*
|
|
|
|
* Security hooks for Audit
|
|
|
|
*
|
|
|
|
* @audit_rule_init:
|
|
|
|
* Allocate and initialize an LSM audit rule structure.
|
|
|
|
* @field contains the required Audit action.
|
2019-02-26 20:49:12 +00:00
|
|
|
* Fields flags are defined in <include/linux/audit.h>
|
2015-05-02 22:10:53 +00:00
|
|
|
* @op contains the operator the rule uses.
|
|
|
|
* @rulestr contains the context where the rule will be applied to.
|
|
|
|
* @lsmrule contains a pointer to receive the result.
|
|
|
|
* Return 0 if @lsmrule has been successfully set,
|
|
|
|
* -EINVAL in case of an invalid rule.
|
|
|
|
*
|
|
|
|
* @audit_rule_known:
|
2019-02-26 20:49:08 +00:00
|
|
|
* Specifies whether given @krule contains any fields related to
|
2015-05-02 22:10:53 +00:00
|
|
|
* current LSM.
|
2019-02-26 20:49:08 +00:00
|
|
|
* @krule contains the audit rule of interest.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 1 in case of relation found, 0 otherwise.
|
|
|
|
*
|
|
|
|
* @audit_rule_match:
|
|
|
|
* Determine if given @secid matches a rule previously approved
|
|
|
|
* by @audit_rule_known.
|
|
|
|
* @secid contains the security id in question.
|
|
|
|
* @field contains the field which relates to current LSM.
|
|
|
|
* @op contains the operator that will be used for matching.
|
2019-02-26 20:49:08 +00:00
|
|
|
* @lrule points to the audit rule that will be checked against.
|
2015-05-02 22:10:53 +00:00
|
|
|
* Return 1 if secid matches the rule, 0 if it does not, -ERRNO on failure.
|
|
|
|
*
|
|
|
|
* @audit_rule_free:
|
|
|
|
* Deallocate the LSM audit rule structure previously allocated by
|
|
|
|
* audit_rule_init.
|
2019-02-26 20:49:08 +00:00
|
|
|
* @lsmrule contains the allocated rule
|
2015-05-02 22:10:53 +00:00
|
|
|
*
|
2015-12-24 16:09:40 +00:00
|
|
|
* @inode_invalidate_secctx:
|
|
|
|
* Notify the security module that it must revalidate the security context
|
|
|
|
* of an inode.
|
|
|
|
*
|
2015-05-02 22:10:53 +00:00
|
|
|
* @inode_notifysecctx:
|
|
|
|
* Notify the security module of what the security context of an inode
|
|
|
|
* should be. Initializes the incore security context managed by the
|
|
|
|
* security module for this inode. Example usage: NFS client invokes
|
|
|
|
* this hook to initialize the security context in its incore inode to the
|
|
|
|
* value provided by the server for the file when the server returned the
|
|
|
|
* file's attributes to the client.
|
|
|
|
* Must be called with inode->i_mutex locked.
|
|
|
|
* @inode we wish to set the security context of.
|
|
|
|
* @ctx contains the string which we wish to set in the inode.
|
|
|
|
* @ctxlen contains the length of @ctx.
|
|
|
|
*
|
|
|
|
* @inode_setsecctx:
|
|
|
|
* Change the security context of an inode. Updates the
|
|
|
|
* incore security context managed by the security module and invokes the
|
|
|
|
* fs code as needed (via __vfs_setxattr_noperm) to update any backing
|
|
|
|
* xattrs that represent the context. Example usage: NFS server invokes
|
|
|
|
* this hook to change the security context in its incore inode and on the
|
|
|
|
* backing filesystem to a value provided by the client on a SETATTR
|
|
|
|
* operation.
|
|
|
|
* Must be called with inode->i_mutex locked.
|
|
|
|
* @dentry contains the inode we wish to set the security context of.
|
|
|
|
* @ctx contains the string which we wish to set in the inode.
|
|
|
|
* @ctxlen contains the length of @ctx.
|
|
|
|
*
|
|
|
|
* @inode_getsecctx:
|
|
|
|
* On success, returns 0 and fills out @ctx and @ctxlen with the security
|
|
|
|
* context for the given @inode.
|
|
|
|
* @inode we wish to get the security context of.
|
|
|
|
* @ctx is a pointer in which to place the allocated security context.
|
|
|
|
* @ctxlen points to the place to put the length of @ctx.
|
2017-10-18 20:00:24 +00:00
|
|
|
*
|
2020-02-12 13:58:35 +00:00
|
|
|
* Security hooks for the general notification queue:
|
|
|
|
*
|
|
|
|
* @post_notification:
|
|
|
|
* Check to see if a watch notification can be posted to a particular
|
|
|
|
* queue.
|
|
|
|
* @w_cred: The credentials of the whoever set the watch.
|
|
|
|
* @cred: The event-triggerer's credentials
|
|
|
|
* @n: The notification being posted
|
|
|
|
*
|
2020-02-12 13:58:35 +00:00
|
|
|
* @watch_key:
|
|
|
|
* Check to see if a process is allowed to watch for event notifications
|
|
|
|
* from a key or keyring.
|
|
|
|
* @key: The key to watch.
|
|
|
|
*
|
2017-10-18 20:00:24 +00:00
|
|
|
* Security hooks for using the eBPF maps and programs functionalities through
|
|
|
|
* eBPF syscalls.
|
|
|
|
*
|
|
|
|
* @bpf:
|
|
|
|
* Do a initial check for all bpf syscalls after the attribute is copied
|
|
|
|
* into the kernel. The actual security module can implement their own
|
|
|
|
* rules to check the specific cmd they need.
|
|
|
|
*
|
|
|
|
* @bpf_map:
|
|
|
|
* Do a check when the kernel generate and return a file descriptor for
|
|
|
|
* eBPF maps.
|
|
|
|
*
|
|
|
|
* @map: bpf map that we want to access
|
|
|
|
* @mask: the access flags
|
|
|
|
*
|
|
|
|
* @bpf_prog:
|
|
|
|
* Do a check when the kernel generate and return a file descriptor for
|
|
|
|
* eBPF programs.
|
|
|
|
*
|
|
|
|
* @prog: bpf prog that userspace want to use.
|
|
|
|
*
|
|
|
|
* @bpf_map_alloc_security:
|
|
|
|
* Initialize the security field inside bpf map.
|
|
|
|
*
|
|
|
|
* @bpf_map_free_security:
|
|
|
|
* Clean up the security information stored inside bpf map.
|
|
|
|
*
|
|
|
|
* @bpf_prog_alloc_security:
|
|
|
|
* Initialize the security field inside bpf program.
|
|
|
|
*
|
|
|
|
* @bpf_prog_free_security:
|
|
|
|
* Clean up the security information stored inside bpf prog.
|
|
|
|
*
|
2020-02-16 07:08:38 +00:00
|
|
|
* @locked_down:
|
2019-08-20 00:17:38 +00:00
|
|
|
* Determine whether a kernel feature that potentially enables arbitrary
|
|
|
|
* code execution in kernel space should be permitted.
|
|
|
|
*
|
|
|
|
* @what: kernel feature being accessed
|
2020-02-16 07:08:38 +00:00
|
|
|
*
|
|
|
|
* Security hooks for perf events
|
|
|
|
*
|
|
|
|
* @perf_event_open:
|
|
|
|
* Check whether the @type of perf_event_open syscall is allowed.
|
|
|
|
* @perf_event_alloc:
|
|
|
|
* Allocate and save perf_event security info.
|
|
|
|
* @perf_event_free:
|
|
|
|
* Release (free) perf_event security info.
|
|
|
|
* @perf_event_read:
|
|
|
|
* Read perf_event security info if allowed.
|
|
|
|
* @perf_event_write:
|
|
|
|
* Write perf_event security info if allowed.
|
lsm,io_uring: add LSM hooks to io_uring
A full expalantion of io_uring is beyond the scope of this commit
description, but in summary it is an asynchronous I/O mechanism
which allows for I/O requests and the resulting data to be queued
in memory mapped "rings" which are shared between the kernel and
userspace. Optionally, io_uring offers the ability for applications
to spawn kernel threads to dequeue I/O requests from the ring and
submit the requests in the kernel, helping to minimize the syscall
overhead. Rings are accessed in userspace by memory mapping a file
descriptor provided by the io_uring_setup(2), and can be shared
between applications as one might do with any open file descriptor.
Finally, process credentials can be registered with a given ring
and any process with access to that ring can submit I/O requests
using any of the registered credentials.
While the io_uring functionality is widely recognized as offering a
vastly improved, and high performing asynchronous I/O mechanism, its
ability to allow processes to submit I/O requests with credentials
other than its own presents a challenge to LSMs. When a process
creates a new io_uring ring the ring's credentials are inhertied
from the calling process; if this ring is shared with another
process operating with different credentials there is the potential
to bypass the LSMs security policy. Similarly, registering
credentials with a given ring allows any process with access to that
ring to submit I/O requests with those credentials.
In an effort to allow LSMs to apply security policy to io_uring I/O
operations, this patch adds two new LSM hooks. These hooks, in
conjunction with the LSM anonymous inode support previously
submitted, allow an LSM to apply access control policy to the
sharing of io_uring rings as well as any io_uring credential changes
requested by a process.
The new LSM hooks are described below:
* int security_uring_override_creds(cred)
Controls if the current task, executing an io_uring operation,
is allowed to override it's credentials with @cred. In cases
where the current task is a user application, the current
credentials will be those of the user application. In cases
where the current task is a kernel thread servicing io_uring
requests the current credentials will be those of the io_uring
ring (inherited from the process that created the ring).
* int security_uring_sqpoll(void)
Controls if the current task is allowed to create an io_uring
polling thread (IORING_SETUP_SQPOLL). Without a SQPOLL thread
in the kernel processes must submit I/O requests via
io_uring_enter(2) which allows us to compare any requested
credential changes against the application making the request.
With a SQPOLL thread, we can no longer compare requested
credential changes against the application making the request,
the comparison is made against the ring's credentials.
Signed-off-by: Paul Moore <paul@paul-moore.com>
2021-02-02 00:56:49 +00:00
|
|
|
*
|
|
|
|
* Security hooks for io_uring
|
|
|
|
*
|
|
|
|
* @uring_override_creds:
|
|
|
|
* Check if the current task, executing an io_uring operation, is allowed
|
|
|
|
* to override it's credentials with @new.
|
|
|
|
*
|
|
|
|
* @new: the new creds to use
|
|
|
|
*
|
|
|
|
* @uring_sqpoll:
|
|
|
|
* Check whether the current task is allowed to spawn a io_uring polling
|
|
|
|
* thread (IORING_SETUP_SQPOLL).
|
|
|
|
*
|
2022-07-15 19:16:22 +00:00
|
|
|
* @uring_cmd:
|
|
|
|
* Check whether the file_operations uring_cmd is allowed to run.
|
|
|
|
*
|
2015-05-02 22:10:53 +00:00
|
|
|
*/
|
2015-05-02 22:11:42 +00:00
|
|
|
union security_list_options {
|
2020-03-29 00:43:50 +00:00
|
|
|
#define LSM_HOOK(RET, DEFAULT, NAME, ...) RET (*NAME)(__VA_ARGS__);
|
|
|
|
#include "lsm_hook_defs.h"
|
|
|
|
#undef LSM_HOOK
|
2015-05-02 22:10:46 +00:00
|
|
|
};
|
|
|
|
|
2015-05-02 22:11:36 +00:00
|
|
|
struct security_hook_heads {
|
2020-03-29 00:43:50 +00:00
|
|
|
#define LSM_HOOK(RET, DEFAULT, NAME, ...) struct hlist_head NAME;
|
|
|
|
#include "lsm_hook_defs.h"
|
|
|
|
#undef LSM_HOOK
|
2016-10-28 08:22:25 +00:00
|
|
|
} __randomize_layout;
|
2015-05-02 22:11:36 +00:00
|
|
|
|
2015-05-02 22:11:42 +00:00
|
|
|
/*
|
|
|
|
* Security module hook list structure.
|
|
|
|
* For use with generic list macros for common operations.
|
|
|
|
*/
|
|
|
|
struct security_hook_list {
|
2018-03-29 01:28:23 +00:00
|
|
|
struct hlist_node list;
|
|
|
|
struct hlist_head *head;
|
2015-05-02 22:11:42 +00:00
|
|
|
union security_list_options hook;
|
2022-02-17 14:18:57 +00:00
|
|
|
const char *lsm;
|
2016-10-28 08:22:25 +00:00
|
|
|
} __randomize_layout;
|
2015-05-02 22:11:42 +00:00
|
|
|
|
2018-11-12 17:30:56 +00:00
|
|
|
/*
|
|
|
|
* Security blob size or offset data.
|
|
|
|
*/
|
|
|
|
struct lsm_blob_sizes {
|
|
|
|
int lbs_cred;
|
2018-11-12 20:02:49 +00:00
|
|
|
int lbs_file;
|
2018-09-22 00:19:29 +00:00
|
|
|
int lbs_inode;
|
2021-04-22 15:41:15 +00:00
|
|
|
int lbs_superblock;
|
2018-11-20 19:55:02 +00:00
|
|
|
int lbs_ipc;
|
|
|
|
int lbs_msg_msg;
|
2018-09-22 00:19:37 +00:00
|
|
|
int lbs_task;
|
2018-11-12 17:30:56 +00:00
|
|
|
};
|
|
|
|
|
2020-03-29 00:43:50 +00:00
|
|
|
/*
|
|
|
|
* LSM_RET_VOID is used as the default value in LSM_HOOK definitions for void
|
|
|
|
* LSM hooks (in include/linux/lsm_hook_defs.h).
|
|
|
|
*/
|
|
|
|
#define LSM_RET_VOID ((void) 0)
|
|
|
|
|
2015-05-02 22:11:36 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2015-05-02 22:11:42 +00:00
|
|
|
#define LSM_HOOK_INIT(HEAD, HOOK) \
|
|
|
|
{ .head = &security_hook_heads.HEAD, .hook = { .HEAD = HOOK } }
|
|
|
|
|
|
|
|
extern struct security_hook_heads security_hook_heads;
|
2017-01-19 01:09:05 +00:00
|
|
|
extern char *lsm_names;
|
2015-05-02 22:11:42 +00:00
|
|
|
|
2017-01-19 01:09:05 +00:00
|
|
|
extern void security_add_hooks(struct security_hook_list *hooks, int count,
|
2022-02-17 14:18:57 +00:00
|
|
|
const char *lsm);
|
2015-05-02 22:10:46 +00:00
|
|
|
|
2018-09-19 23:13:25 +00:00
|
|
|
#define LSM_FLAG_LEGACY_MAJOR BIT(0)
|
2018-09-20 02:57:06 +00:00
|
|
|
#define LSM_FLAG_EXCLUSIVE BIT(1)
|
2018-09-19 23:13:25 +00:00
|
|
|
|
2018-09-20 00:48:21 +00:00
|
|
|
enum lsm_order {
|
|
|
|
LSM_ORDER_FIRST = -1, /* This is only for capabilities. */
|
|
|
|
LSM_ORDER_MUTABLE = 0,
|
|
|
|
};
|
|
|
|
|
2018-10-11 00:18:21 +00:00
|
|
|
struct lsm_info {
|
2018-10-11 00:18:24 +00:00
|
|
|
const char *name; /* Required. */
|
2018-09-20 00:48:21 +00:00
|
|
|
enum lsm_order order; /* Optional: default is LSM_ORDER_MUTABLE */
|
2018-09-19 23:13:25 +00:00
|
|
|
unsigned long flags; /* Optional: flags describing LSM */
|
2018-10-09 21:42:57 +00:00
|
|
|
int *enabled; /* Optional: controlled by CONFIG_LSM */
|
2018-10-11 00:18:21 +00:00
|
|
|
int (*init)(void); /* Required. */
|
2018-11-12 17:30:56 +00:00
|
|
|
struct lsm_blob_sizes *blobs; /* Optional: for blob sharing. */
|
2018-10-11 00:18:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
extern struct lsm_info __start_lsm_info[], __end_lsm_info[];
|
2019-08-20 00:17:37 +00:00
|
|
|
extern struct lsm_info __start_early_lsm_info[], __end_early_lsm_info[];
|
2018-10-11 00:18:21 +00:00
|
|
|
|
2018-10-11 00:18:23 +00:00
|
|
|
#define DEFINE_LSM(lsm) \
|
2018-10-11 00:18:21 +00:00
|
|
|
static struct lsm_info __lsm_##lsm \
|
2020-10-22 02:36:07 +00:00
|
|
|
__used __section(".lsm_info.init") \
|
2018-10-11 00:18:23 +00:00
|
|
|
__aligned(sizeof(unsigned long))
|
2018-10-11 00:18:21 +00:00
|
|
|
|
2019-08-20 00:17:37 +00:00
|
|
|
#define DEFINE_EARLY_LSM(lsm) \
|
|
|
|
static struct lsm_info __early_lsm_##lsm \
|
2020-10-22 02:36:07 +00:00
|
|
|
__used __section(".early_lsm_info.init") \
|
2019-08-20 00:17:37 +00:00
|
|
|
__aligned(sizeof(unsigned long))
|
|
|
|
|
2015-05-02 22:11:42 +00:00
|
|
|
#ifdef CONFIG_SECURITY_SELINUX_DISABLE
|
|
|
|
/*
|
|
|
|
* Assuring the safety of deleting a security module is up to
|
|
|
|
* the security module involved. This may entail ordering the
|
|
|
|
* module's hook list in a particular way, refusing to disable
|
|
|
|
* the module once a policy is loaded or any number of other
|
|
|
|
* actions better imagined than described.
|
|
|
|
*
|
|
|
|
* The name of the configuration option reflects the only module
|
|
|
|
* that currently uses the mechanism. Any developer who thinks
|
|
|
|
* disabling their module is a good idea needs to be at least as
|
|
|
|
* careful as the SELinux team.
|
|
|
|
*/
|
|
|
|
static inline void security_delete_hooks(struct security_hook_list *hooks,
|
|
|
|
int count)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++)
|
2018-03-29 01:28:23 +00:00
|
|
|
hlist_del_rcu(&hooks[i].list);
|
2015-05-02 22:11:42 +00:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_SECURITY_SELINUX_DISABLE */
|
|
|
|
|
2017-02-14 13:17:24 +00:00
|
|
|
/* Currently required to handle SELinux runtime hook disable. */
|
|
|
|
#ifdef CONFIG_SECURITY_WRITABLE_HOOKS
|
|
|
|
#define __lsm_ro_after_init
|
|
|
|
#else
|
|
|
|
#define __lsm_ro_after_init __ro_after_init
|
|
|
|
#endif /* CONFIG_SECURITY_WRITABLE_HOOKS */
|
|
|
|
|
2018-09-22 00:19:29 +00:00
|
|
|
extern int lsm_inode_alloc(struct inode *inode);
|
|
|
|
|
2015-05-02 22:10:46 +00:00
|
|
|
#endif /* ! __LINUX_LSM_HOOKS_H */
|