Merge branch 'security-next-keys' of... (61d335dd) · Commits · e / devices / android_kernel_oneplus_sm7250

Documentation/security/keys.txt

+66 −1

Original line number	Original line	Diff line number	Diff line
	@@ -412,6 +412,10 @@ The main syscalls are:
	to the keyring. In this case, an error will be generated if the process		to the keyring. In this case, an error will be generated if the process
	does not have permission to write to the keyring.		does not have permission to write to the keyring.

			If the key type supports it, if the description is NULL or an empty
			string, the key type will try and generate a description from the content
			of the payload.

	The payload is optional, and the pointer can be NULL if not required by		The payload is optional, and the pointer can be NULL if not required by
	the type. The payload is plen in size, and plen can be zero for an empty		the type. The payload is plen in size, and plen can be zero for an empty
	payload.		payload.
	@@ -990,6 +994,23 @@ payload contents" for more information.
	reference pointer if successful.		reference pointer if successful.


			(*) A keyring can be created by:

			struct key keyring_alloc(const char description, uid_t uid, gid_t gid,
			const struct cred *cred,
			key_perm_t perm,
			unsigned long flags,
			struct key *dest);

			This creates a keyring with the given attributes and returns it. If dest
			is not NULL, the new keyring will be linked into the keyring to which it
			points. No permission checks are made upon the destination keyring.

			Error EDQUOT can be returned if the keyring would overload the quota (pass
			KEY_ALLOC_NOT_IN_QUOTA in flags if the keyring shouldn't be accounted
			towards the user's quota). Error ENOMEM can also be returned.


	(*) To check the validity of a key, this function can be called:		(*) To check the validity of a key, this function can be called:

	int validate_key(struct key *key);		int validate_key(struct key *key);
	@@ -1114,12 +1135,53 @@ The structure has a number of fields, some of which are mandatory:
	it should return 0.		it should return 0.


	() int (instantiate)(struct key key, const void data, size_t datalen);		() int (preparse)(struct key_preparsed_payload *prep);

			This optional method permits the key type to attempt to parse payload
			before a key is created (add key) or the key semaphore is taken (update or
			instantiate key). The structure pointed to by prep looks like:

			struct key_preparsed_payload {
			char *description;
			void *type_data[2];
			void *payload;
			const void *data;
			size_t datalen;
			size_t quotalen;
			};

			Before calling the method, the caller will fill in data and datalen with
			the payload blob parameters; quotalen will be filled in with the default
			quota size from the key type and the rest will be cleared.

			If a description can be proposed from the payload contents, that should be
			attached as a string to the description field. This will be used for the
			key description if the caller of add_key() passes NULL or "".

			The method can attach anything it likes to type_data[] and payload. These
			are merely passed along to the instantiate() or update() operations.

			The method should return 0 if success ful or a negative error code
			otherwise.


			() void (free_preparse)(struct key_preparsed_payload *prep);

			This method is only required if the preparse() method is provided,
			otherwise it is unused. It cleans up anything attached to the
			description, type_data and payload fields of the key_preparsed_payload
			struct as filled in by the preparse() method.


			() int (instantiate)(struct key key, struct key_preparsed_payload prep);

	This method is called to attach a payload to a key during construction.		This method is called to attach a payload to a key during construction.
	The payload attached need not bear any relation to the data passed to this		The payload attached need not bear any relation to the data passed to this
	function.		function.

			The prep->data and prep->datalen fields will define the original payload
			blob. If preparse() was supplied then other fields may be filled in also.

	If the amount of data attached to the key differs from the size in		If the amount of data attached to the key differs from the size in
	keytype->def_datalen, then key_payload_reserve() should be called.		keytype->def_datalen, then key_payload_reserve() should be called.

	@@ -1135,6 +1197,9 @@ The structure has a number of fields, some of which are mandatory:
	If this type of key can be updated, then this method should be provided.		If this type of key can be updated, then this method should be provided.
	It is called to update a key's payload from the blob of data provided.		It is called to update a key's payload from the blob of data provided.

			The prep->data and prep->datalen fields will define the original payload
			blob. If preparse() was supplied then other fields may be filled in also.

	key_payload_reserve() should be called if the data length might change		key_payload_reserve() should be called if the data length might change
	before any changes are actually made. Note that if this succeeds, the type		before any changes are actually made. Note that if this succeeds, the type
	is committed to changing the key because it's already been altered, so all		is committed to changing the key because it's already been altered, so all

fs/cifs/cifs_spnego.c

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -31,18 +31,18 @@

	/* create a new cifs key */		/* create a new cifs key */
	static int		static int
	cifs_spnego_key_instantiate(struct key key, const void data, size_t datalen)		cifs_spnego_key_instantiate(struct key key, struct key_preparsed_payload prep)
	{		{
	char *payload;		char *payload;
	int ret;		int ret;

	ret = -ENOMEM;		ret = -ENOMEM;
	payload = kmalloc(datalen, GFP_KERNEL);		payload = kmalloc(prep->datalen, GFP_KERNEL);
	if (!payload)		if (!payload)
	goto error;		goto error;

	/* attach the data */		/* attach the data */
	memcpy(payload, data, datalen);		memcpy(payload, prep->data, prep->datalen);
	key->payload.data = payload;		key->payload.data = payload;
	ret = 0;		ret = 0;

fs/cifs/cifsacl.c

+8 −12

Original line number	Original line	Diff line number	Diff line
	@@ -167,17 +167,17 @@ static struct shrinker cifs_shrinker = {
	};		};

	static int		static int
	cifs_idmap_key_instantiate(struct key key, const void data, size_t datalen)		cifs_idmap_key_instantiate(struct key key, struct key_preparsed_payload prep)
	{		{
	char *payload;		char *payload;

	payload = kmalloc(datalen, GFP_KERNEL);		payload = kmalloc(prep->datalen, GFP_KERNEL);
	if (!payload)		if (!payload)
	return -ENOMEM;		return -ENOMEM;

	memcpy(payload, data, datalen);		memcpy(payload, prep->data, prep->datalen);
	key->payload.data = payload;		key->payload.data = payload;
	key->datalen = datalen;		key->datalen = prep->datalen;
	return 0;		return 0;
	}		}

	@@ -537,19 +537,15 @@ init_cifs_idmap(void)
	if (!cred)		if (!cred)
	return -ENOMEM;		return -ENOMEM;

	keyring = key_alloc(&key_type_keyring, ".cifs_idmap", 0, 0, cred,		keyring = keyring_alloc(".cifs_idmap", 0, 0, cred,
	(KEY_POS_ALL & ~KEY_POS_SETATTR) \|		(KEY_POS_ALL & ~KEY_POS_SETATTR) \|
	KEY_USR_VIEW \| KEY_USR_READ,		KEY_USR_VIEW \| KEY_USR_READ,
	KEY_ALLOC_NOT_IN_QUOTA);		KEY_ALLOC_NOT_IN_QUOTA, NULL);
	if (IS_ERR(keyring)) {		if (IS_ERR(keyring)) {
	ret = PTR_ERR(keyring);		ret = PTR_ERR(keyring);
	goto failed_put_cred;		goto failed_put_cred;
	}		}

	ret = key_instantiate_and_link(keyring, NULL, 0, NULL, NULL);
	if (ret < 0)
	goto failed_put_key;

	ret = register_key_type(&cifs_idmap_key_type);		ret = register_key_type(&cifs_idmap_key_type);
	if (ret < 0)		if (ret < 0)
	goto failed_put_key;		goto failed_put_key;

fs/nfs/idmap.c

+4 −8

Original line number	Original line	Diff line number	Diff line
	@@ -192,19 +192,15 @@ static int nfs_idmap_init_keyring(void)
	if (!cred)		if (!cred)
	return -ENOMEM;		return -ENOMEM;

	keyring = key_alloc(&key_type_keyring, ".id_resolver", 0, 0, cred,		keyring = keyring_alloc(".id_resolver", 0, 0, cred,
	(KEY_POS_ALL & ~KEY_POS_SETATTR) \|		(KEY_POS_ALL & ~KEY_POS_SETATTR) \|
	KEY_USR_VIEW \| KEY_USR_READ,		KEY_USR_VIEW \| KEY_USR_READ,
	KEY_ALLOC_NOT_IN_QUOTA);		KEY_ALLOC_NOT_IN_QUOTA, NULL);
	if (IS_ERR(keyring)) {		if (IS_ERR(keyring)) {
	ret = PTR_ERR(keyring);		ret = PTR_ERR(keyring);
	goto failed_put_cred;		goto failed_put_cred;
	}		}

	ret = key_instantiate_and_link(keyring, NULL, 0, NULL, NULL);
	if (ret < 0)
	goto failed_put_key;

	ret = register_key_type(&key_type_id_resolver);		ret = register_key_type(&key_type_id_resolver);
	if (ret < 0)		if (ret < 0)
	goto failed_put_key;		goto failed_put_key;

include/keys/user-type.h

+4 −2

Original line number	Original line	Diff line number	Diff line
	@@ -35,8 +35,10 @@ struct user_key_payload {
	extern struct key_type key_type_user;		extern struct key_type key_type_user;
	extern struct key_type key_type_logon;		extern struct key_type key_type_logon;

	extern int user_instantiate(struct key key, const void data, size_t datalen);		struct key_preparsed_payload;
	extern int user_update(struct key key, const void data, size_t datalen);
			extern int user_instantiate(struct key key, struct key_preparsed_payload prep);
			extern int user_update(struct key key, struct key_preparsed_payload prep);
	extern int user_match(const struct key key, const void criterion);		extern int user_match(const struct key key, const void criterion);
	extern void user_revoke(struct key *key);		extern void user_revoke(struct key *key);
	extern void user_destroy(struct key *key);		extern void user_destroy(struct key *key);