Merge 3.7-rc1 usb-linus (1e91adf7) · Commits · e / devices / android_kernel_xiaomi_markw

.gitignore

+14 −0

Original line number	Original line	Diff line number	Diff line
	@@ -14,6 +14,10 @@
	.o.		.o.
	*.a		*.a
	*.s		*.s
			*.ko.unsigned
			*.ko.stripped
			*.ko.stripped.dig
			*.ko.stripped.sig
	*.ko		*.ko
	*.so		*.so
	*.so.dbg		*.so.dbg
	@@ -84,3 +88,13 @@ GTAGS
	*.orig		*.orig
	*~		*~
	\#*#		\#*#

			#
			# Leavings from module signing
			#
			extra_certificates
			signing_key.priv
			signing_key.x509
			signing_key.x509.keyid
			signing_key.x509.signer
			x509.genkey

Documentation/crypto/asymmetric-keys.txt

0 → 100644

+312 −0

Original line number	Original line	Diff line number	Diff line
			=============================================
			ASYMMETRIC / PUBLIC-KEY CRYPTOGRAPHY KEY TYPE
			=============================================

			Contents:

			- Overview.
			- Key identification.
			- Accessing asymmetric keys.
			- Signature verification.
			- Asymmetric key subtypes.
			- Instantiation data parsers.


			========
			OVERVIEW
			========

			The "asymmetric" key type is designed to be a container for the keys used in
			public-key cryptography, without imposing any particular restrictions on the
			form or mechanism of the cryptography or form of the key.

			The asymmetric key is given a subtype that defines what sort of data is
			associated with the key and provides operations to describe and destroy it.
			However, no requirement is made that the key data actually be stored in the
			key.

			A completely in-kernel key retention and operation subtype can be defined, but
			it would also be possible to provide access to cryptographic hardware (such as
			a TPM) that might be used to both retain the relevant key and perform
			operations using that key. In such a case, the asymmetric key would then
			merely be an interface to the TPM driver.

			Also provided is the concept of a data parser. Data parsers are responsible
			for extracting information from the blobs of data passed to the instantiation
			function. The first data parser that recognises the blob gets to set the
			subtype of the key and define the operations that can be done on that key.

			A data parser may interpret the data blob as containing the bits representing a
			key, or it may interpret it as a reference to a key held somewhere else in the
			system (for example, a TPM).


			==================
			KEY IDENTIFICATION
			==================

			If a key is added with an empty name, the instantiation data parsers are given
			the opportunity to pre-parse a key and to determine the description the key
			should be given from the content of the key.

			This can then be used to refer to the key, either by complete match or by
			partial match. The key type may also use other criteria to refer to a key.

			The asymmetric key type's match function can then perform a wider range of
			comparisons than just the straightforward comparison of the description with
			the criterion string:

			(1) If the criterion string is of the form "id:<hexdigits>" then the match
			function will examine a key's fingerprint to see if the hex digits given
			after the "id:" match the tail. For instance:

			keyctl search @s asymmetric id:5acc2142

			will match a key with fingerprint:

			1A00 2040 7601 7889 DE11 882C 3823 04AD 5ACC 2142

			(2) If the criterion string is of the form "<subtype>:<hexdigits>" then the
			match will match the ID as in (1), but with the added restriction that
			only keys of the specified subtype (e.g. tpm) will be matched. For
			instance:

			keyctl search @s asymmetric tpm:5acc2142

			Looking in /proc/keys, the last 8 hex digits of the key fingerprint are
			displayed, along with the subtype:

			1a39e171 I----- 1 perm 3f010000 0 0 asymmetri modsign.0: DSA 5acc2142 []


			=========================
			ACCESSING ASYMMETRIC KEYS
			=========================

			For general access to asymmetric keys from within the kernel, the following
			inclusion is required:

			#include <crypto/public_key.h>

			This gives access to functions for dealing with asymmetric / public keys.
			Three enums are defined there for representing public-key cryptography
			algorithms:

			enum pkey_algo

			digest algorithms used by those:

			enum pkey_hash_algo

			and key identifier representations:

			enum pkey_id_type

			Note that the key type representation types are required because key
			identifiers from different standards aren't necessarily compatible. For
			instance, PGP generates key identifiers by hashing the key data plus some
			PGP-specific metadata, whereas X.509 has arbitrary certificate identifiers.

			The operations defined upon a key are:

			(1) Signature verification.

			Other operations are possible (such as encryption) with the same key data
			required for verification, but not currently supported, and others
			(eg. decryption and signature generation) require extra key data.


			SIGNATURE VERIFICATION
			----------------------

			An operation is provided to perform cryptographic signature verification, using
			an asymmetric key to provide or to provide access to the public key.

			int verify_signature(const struct key *key,
			const struct public_key_signature *sig);

			The caller must have already obtained the key from some source and can then use
			it to check the signature. The caller must have parsed the signature and
			transferred the relevant bits to the structure pointed to by sig.

			struct public_key_signature {
			u8 *digest;
			u8 digest_size;
			enum pkey_hash_algo pkey_hash_algo : 8;
			u8 nr_mpi;
			union {
			MPI mpi[2];
			...
			};
			};

			The algorithm used must be noted in sig->pkey_hash_algo, and all the MPIs that
			make up the actual signature must be stored in sig->mpi[] and the count of MPIs
			placed in sig->nr_mpi.

			In addition, the data must have been digested by the caller and the resulting
			hash must be pointed to by sig->digest and the size of the hash be placed in
			sig->digest_size.

			The function will return 0 upon success or -EKEYREJECTED if the signature
			doesn't match.

			The function may also return -ENOTSUPP if an unsupported public-key algorithm
			or public-key/hash algorithm combination is specified or the key doesn't
			support the operation; -EBADMSG or -ERANGE if some of the parameters have weird
			data; or -ENOMEM if an allocation can't be performed. -EINVAL can be returned
			if the key argument is the wrong type or is incompletely set up.


			=======================
			ASYMMETRIC KEY SUBTYPES
			=======================

			Asymmetric keys have a subtype that defines the set of operations that can be
			performed on that key and that determines what data is attached as the key
			payload. The payload format is entirely at the whim of the subtype.

			The subtype is selected by the key data parser and the parser must initialise
			the data required for it. The asymmetric key retains a reference on the
			subtype module.

			The subtype definition structure can be found in:

			#include <keys/asymmetric-subtype.h>

			and looks like the following:

			struct asymmetric_key_subtype {
			struct module *owner;
			const char *name;

			void (describe)(const struct key key, struct seq_file *m);
			void (destroy)(void payload);
			int (verify_signature)(const struct key key,
			const struct public_key_signature *sig);
			};

			Asymmetric keys point to this with their type_data[0] member.

			The owner and name fields should be set to the owning module and the name of
			the subtype. Currently, the name is only used for print statements.

			There are a number of operations defined by the subtype:

			(1) describe().

			Mandatory. This allows the subtype to display something in /proc/keys
			against the key. For instance the name of the public key algorithm type
			could be displayed. The key type will display the tail of the key
			identity string after this.

			(2) destroy().

			Mandatory. This should free the memory associated with the key. The
			asymmetric key will look after freeing the fingerprint and releasing the
			reference on the subtype module.

			(3) verify_signature().

			Optional. These are the entry points for the key usage operations.
			Currently there is only the one defined. If not set, the caller will be
			given -ENOTSUPP. The subtype may do anything it likes to implement an
			operation, including offloading to hardware.


			==========================
			INSTANTIATION DATA PARSERS
			==========================

			The asymmetric key type doesn't generally want to store or to deal with a raw
			blob of data that holds the key data. It would have to parse it and error
			check it each time it wanted to use it. Further, the contents of the blob may
			have various checks that can be performed on it (eg. self-signatures, validity
			dates) and may contain useful data about the key (identifiers, capabilities).

			Also, the blob may represent a pointer to some hardware containing the key
			rather than the key itself.

			Examples of blob formats for which parsers could be implemented include:

			- OpenPGP packet stream [RFC 4880].
			- X.509 ASN.1 stream.
			- Pointer to TPM key.
			- Pointer to UEFI key.

			During key instantiation each parser in the list is tried until one doesn't
			return -EBADMSG.

			The parser definition structure can be found in:

			#include <keys/asymmetric-parser.h>

			and looks like the following:

			struct asymmetric_key_parser {
			struct module *owner;
			const char *name;

			int (parse)(struct key_preparsed_payload prep);
			};

			The owner and name fields should be set to the owning module and the name of
			the parser.

			There is currently only a single operation defined by the parser, and it is
			mandatory:

			(1) parse().

			This is called to preparse the key from the key creation and update paths.
			In particular, it is called during the key creation _before_ a key is
			allocated, and as such, is permitted to provide the key's description in
			the case that the caller declines to do so.

			The caller passes a pointer to the following struct with all of the fields
			cleared, except for data, datalen and quotalen [see
			Documentation/security/keys.txt].

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

			The instantiation data is in a blob pointed to by data and is datalen in
			size. The parse() function is not permitted to change these two values at
			all, and shouldn't change any of the other values _unless_ they are
			recognise the blob format and will not return -EBADMSG to indicate it is
			not theirs.

			If the parser is happy with the blob, it should propose a description for
			the key and attach it to ->description, ->type_data[0] should be set to
			point to the subtype to be used, ->payload should be set to point to the
			initialised data for that subtype, ->type_data[1] should point to a hex
			fingerprint and quotalen should be updated to indicate how much quota this
			key should account for.

			When clearing up, the data attached to ->type_data[1] and ->description
			will be kfree()'d and the data attached to ->payload will be passed to the
			subtype's ->destroy() method to be disposed of. A module reference for
			the subtype pointed to by ->type_data[0] will be put.


			If the data format is not recognised, -EBADMSG should be returned. If it
			is recognised, but the key cannot for some reason be set up, some other
			negative error code should be returned. On success, 0 should be returned.

			The key's fingerprint string may be partially matched upon. For a
			public-key algorithm such as RSA and DSA this will likely be a printable
			hex version of the key's fingerprint.

			Functions are provided to register and unregister parsers:

			int register_asymmetric_key_parser(struct asymmetric_key_parser *parser);
			void unregister_asymmetric_key_parser(struct asymmetric_key_parser *subtype);

			Parsers may not have the same name. The names are otherwise only used for
			displaying in debugging messages.

Documentation/kernel-parameters.txt

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -1593,6 +1593,12 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
	log everything. Information is printed at KERN_DEBUG		log everything. Information is printed at KERN_DEBUG
	so loglevel=8 may also need to be specified.		so loglevel=8 may also need to be specified.

			module.sig_enforce
			[KNL] When CONFIG_MODULE_SIG is set, this means that
			modules without (valid) signatures will fail to load.
			Note that if CONFIG_MODULE_SIG_ENFORCE is set, that
			is always true, so this option does nothing.

	mousedev.tap_time=		mousedev.tap_time=
	[MOUSE] Maximum time between finger touching and		[MOUSE] Maximum time between finger touching and
	leaving touchpad surface for touch to be considered		leaving touchpad surface for touch to be considered

Documentation/security/keys.txt

+49 −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.
	@@ -1114,12 +1118,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 +1180,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

Makefile

+7 −3

Original line number	Original line	Diff line number	Diff line
	VERSION = 3		VERSION = 3
	PATCHLEVEL = 6		PATCHLEVEL = 7
	SUBLEVEL = 0		SUBLEVEL = 0
	EXTRAVERSION =		EXTRAVERSION = -rc1
	NAME = Terrified Chipmunk		NAME = Terrified Chipmunk

	# DOCUMENTATION		# DOCUMENTATION
	@@ -997,7 +997,10 @@ CLEAN_DIRS += $(MODVERDIR)
	MRPROPER_DIRS += include/config usr/include include/generated \		MRPROPER_DIRS += include/config usr/include include/generated \
	arch/*/include/generated		arch/*/include/generated
	MRPROPER_FILES += .config .config.old .version .old_version $(version_h) \		MRPROPER_FILES += .config .config.old .version .old_version $(version_h) \
	Module.symvers tags TAGS cscope* GPATH GTAGS GRTAGS GSYMS		Module.symvers tags TAGS cscope* GPATH GTAGS GRTAGS GSYMS \
			signing_key.priv signing_key.x509 x509.genkey \
			extra_certificates signing_key.x509.keyid \
			signing_key.x509.signer

	# clean - Delete most, but leave enough to build external modules		# clean - Delete most, but leave enough to build external modules
	#		#
	@@ -1241,6 +1244,7 @@ clean: $(clean-dirs)
	$(call cmd,rmfiles)		$(call cmd,rmfiles)
	@find $(if $(KBUILD_EXTMOD), $(KBUILD_EXTMOD), .) $(RCS_FIND_IGNORE) \		@find $(if $(KBUILD_EXTMOD), $(KBUILD_EXTMOD), .) $(RCS_FIND_IGNORE) \
	\( -name '.[oas]' -o -name '.ko' -o -name '.*.cmd' \		\( -name '.[oas]' -o -name '.ko' -o -name '.*.cmd' \
			-o -name '.ko.' \
	-o -name '..d' -o -name '..tmp' -o -name '*.mod.c' \		-o -name '..d' -o -name '..tmp' -o -name '*.mod.c' \
	-o -name '*.symtypes' -o -name 'modules.order' \		-o -name '*.symtypes' -o -name 'modules.order' \
	-o -name modules.builtin -o -name '.tmp_.o.' \		-o -name modules.builtin -o -name '.tmp_.o.' \