[thirdparty/linux.git] / fs / verity / signature.c

// SPDX-License-Identifier: GPL-2.0
/*
 * fs/verity/signature.c: verification of builtin signatures
 *
 * Copyright 2019 Google LLC
 */

#include "fsverity_private.h"

#include <linux/cred.h>
#include <linux/key.h>
#include <linux/slab.h>
#include <linux/verification.h>

/*
 * /proc/sys/fs/verity/require_signatures
 * If 1, all verity files must have a valid builtin signature.
 */
static int fsverity_require_signatures;

/*
 * Keyring that contains the trusted X.509 certificates.
 *
 * Only root (kuid=0) can modify this.  Also, root may use
 * keyctl_restrict_keyring() to prevent any more additions.
 */
static struct key *fsverity_keyring;

/**
 * fsverity_verify_signature() - check a verity file's signature
 * @vi: the file's fsverity_info
 * @desc: the file's fsverity_descriptor
 * @desc_size: size of @desc
 *
 * If the file's fs-verity descriptor includes a signature of the file
 * measurement, verify it against the certificates in the fs-verity keyring.
 *
 * Return: 0 on success (signature valid or not required); -errno on failure
 */
int fsverity_verify_signature(const struct fsverity_info *vi,
			      const struct fsverity_descriptor *desc,
			      size_t desc_size)
{
	const struct inode *inode = vi->inode;
	const struct fsverity_hash_alg *hash_alg = vi->tree_params.hash_alg;
	const u32 sig_size = le32_to_cpu(desc->sig_size);
	struct fsverity_signed_digest *d;
	int err;

	if (sig_size == 0) {
		if (fsverity_require_signatures) {
			fsverity_err(inode,
				     "require_signatures=1, rejecting unsigned file!");
			return -EPERM;
		}
		return 0;
	}

	if (sig_size > desc_size - sizeof(*desc)) {
		fsverity_err(inode, "Signature overflows verity descriptor");
		return -EBADMSG;
	}

	d = kzalloc(sizeof(*d) + hash_alg->digest_size, GFP_KERNEL);
	if (!d)
		return -ENOMEM;
	memcpy(d->magic, "FSVerity", 8);
	d->digest_algorithm = cpu_to_le16(hash_alg - fsverity_hash_algs);
	d->digest_size = cpu_to_le16(hash_alg->digest_size);
	memcpy(d->digest, vi->measurement, hash_alg->digest_size);

	err = verify_pkcs7_signature(d, sizeof(*d) + hash_alg->digest_size,
				     desc->signature, sig_size,
				     fsverity_keyring,
				     VERIFYING_UNSPECIFIED_SIGNATURE,
				     NULL, NULL);
	kfree(d);

	if (err) {
		if (err == -ENOKEY)
			fsverity_err(inode,
				     "File's signing cert isn't in the fs-verity keyring");
		else if (err == -EKEYREJECTED)
			fsverity_err(inode, "Incorrect file signature");
		else if (err == -EBADMSG)
			fsverity_err(inode, "Malformed file signature");
		else
			fsverity_err(inode, "Error %d verifying file signature",
				     err);
		return err;
	}

	pr_debug("Valid signature for file measurement %s:%*phN\n",
		 hash_alg->name, hash_alg->digest_size, vi->measurement);
	return 0;
}

#ifdef CONFIG_SYSCTL
static struct ctl_table_header *fsverity_sysctl_header;

static const struct ctl_path fsverity_sysctl_path[] = {
	{ .procname = "fs", },
	{ .procname = "verity", },
	{ }
};

static struct ctl_table fsverity_sysctl_table[] = {
	{
		.procname       = "require_signatures",
		.data           = &fsverity_require_signatures,
		.maxlen         = sizeof(int),
		.mode           = 0644,
		.proc_handler   = proc_dointvec_minmax,
		.extra1         = SYSCTL_ZERO,
		.extra2         = SYSCTL_ONE,
	},
	{ }
};

static int __init fsverity_sysctl_init(void)
{
	fsverity_sysctl_header = register_sysctl_paths(fsverity_sysctl_path,
						       fsverity_sysctl_table);
	if (!fsverity_sysctl_header) {
		pr_err("sysctl registration failed!\n");
		return -ENOMEM;
	}
	return 0;
}
#else /* !CONFIG_SYSCTL */
static inline int __init fsverity_sysctl_init(void)
{
	return 0;
}
#endif /* !CONFIG_SYSCTL */

int __init fsverity_init_signature(void)
{
	struct key *ring;
	int err;

	ring = keyring_alloc(".fs-verity", KUIDT_INIT(0), KGIDT_INIT(0),
			     current_cred(), KEY_POS_SEARCH |
				KEY_USR_VIEW | KEY_USR_READ | KEY_USR_WRITE |
				KEY_USR_SEARCH | KEY_USR_SETATTR,
			     KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL);
	if (IS_ERR(ring))
		return PTR_ERR(ring);

	err = fsverity_sysctl_init();
	if (err)
		goto err_put_ring;

	fsverity_keyring = ring;
	return 0;

err_put_ring:
	key_put(ring);
	return err;
}
Commit	Line	Data
432434c9 EB	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* fs/verity/signature.c: verification of builtin signatures
	4	*
	5	* Copyright 2019 Google LLC
	6	*/
	7
	8	#include "fsverity_private.h"
	9
	10	#include <linux/cred.h>
	11	#include <linux/key.h>
	12	#include <linux/slab.h>
	13	#include <linux/verification.h>
	14
	15	/*
	16	* /proc/sys/fs/verity/require_signatures
	17	* If 1, all verity files must have a valid builtin signature.
	18	*/
	19	static int fsverity_require_signatures;
	20
	21	/*
	22	* Keyring that contains the trusted X.509 certificates.
	23	*
	24	* Only root (kuid=0) can modify this. Also, root may use
	25	* keyctl_restrict_keyring() to prevent any more additions.
	26	*/
	27	static struct key *fsverity_keyring;
	28
	29	/**
	30	* fsverity_verify_signature() - check a verity file's signature
6377a38b EB	31	* @vi: the file's fsverity_info
	32	* @desc: the file's fsverity_descriptor
	33	* @desc_size: size of @desc
432434c9 EB	34	*
	35	* If the file's fs-verity descriptor includes a signature of the file
	36	* measurement, verify it against the certificates in the fs-verity keyring.
	37	*
	38	* Return: 0 on success (signature valid or not required); -errno on failure
	39	*/
	40	int fsverity_verify_signature(const struct fsverity_info *vi,
	41	const struct fsverity_descriptor *desc,
	42	size_t desc_size)
	43	{
	44	const struct inode *inode = vi->inode;
	45	const struct fsverity_hash_alg *hash_alg = vi->tree_params.hash_alg;
	46	const u32 sig_size = le32_to_cpu(desc->sig_size);
	47	struct fsverity_signed_digest *d;
	48	int err;
	49
	50	if (sig_size == 0) {
	51	if (fsverity_require_signatures) {
	52	fsverity_err(inode,
	53	"require_signatures=1, rejecting unsigned file!");
	54	return -EPERM;
	55	}
	56	return 0;
	57	}
	58
	59	if (sig_size > desc_size - sizeof(*desc)) {
	60	fsverity_err(inode, "Signature overflows verity descriptor");
	61	return -EBADMSG;
	62	}
	63
	64	d = kzalloc(sizeof(*d) + hash_alg->digest_size, GFP_KERNEL);
	65	if (!d)
	66	return -ENOMEM;
	67	memcpy(d->magic, "FSVerity", 8);
	68	d->digest_algorithm = cpu_to_le16(hash_alg - fsverity_hash_algs);
	69	d->digest_size = cpu_to_le16(hash_alg->digest_size);
	70	memcpy(d->digest, vi->measurement, hash_alg->digest_size);
	71
	72	err = verify_pkcs7_signature(d, sizeof(*d) + hash_alg->digest_size,
	73	desc->signature, sig_size,
	74	fsverity_keyring,
	75	VERIFYING_UNSPECIFIED_SIGNATURE,
	76	NULL, NULL);
	77	kfree(d);
	78
	79	if (err) {
	80	if (err == -ENOKEY)
	81	fsverity_err(inode,
	82	"File's signing cert isn't in the fs-verity keyring");
	83	else if (err == -EKEYREJECTED)
	84	fsverity_err(inode, "Incorrect file signature");
	85	else if (err == -EBADMSG)
	86	fsverity_err(inode, "Malformed file signature");
	87	else
	88	fsverity_err(inode, "Error %d verifying file signature",
	89	err);
	90	return err;
	91	}
	92
	93	pr_debug("Valid signature for file measurement %s:%*phN\n",
	94	hash_alg->name, hash_alg->digest_size, vi->measurement);
	95	return 0;
	96	}
	97
98	#ifdef CONFIG_SYSCTL
99	static struct ctl_table_header *fsverity_sysctl_header;
100
101	static const struct ctl_path fsverity_sysctl_path[] = {
102	{ .procname = "fs", },
103	{ .procname = "verity", },
104	{ }
105	};
106
107	static struct ctl_table fsverity_sysctl_table[] = {
108	{
109	.procname = "require_signatures",
110	.data = &fsverity_require_signatures,
111	.maxlen = sizeof(int),
112	.mode = 0644,
113	.proc_handler = proc_dointvec_minmax,
114	.extra1 = SYSCTL_ZERO,
115	.extra2 = SYSCTL_ONE,
116	},
117	{ }
118	};
119
120	static int __init fsverity_sysctl_init(void)
121	{
122	fsverity_sysctl_header = register_sysctl_paths(fsverity_sysctl_path,
123	fsverity_sysctl_table);
124	if (!fsverity_sysctl_header) {
125	pr_err("sysctl registration failed!\n");
126	return -ENOMEM;
127	}
128	return 0;
129	}
130	#else /* !CONFIG_SYSCTL */
131	static inline int __init fsverity_sysctl_init(void)
132	{
133	return 0;
134	}
135	#endif /* !CONFIG_SYSCTL */
136
137	int __init fsverity_init_signature(void)
138	{
139	struct key *ring;
140	int err;
141
142	ring = keyring_alloc(".fs-verity", KUIDT_INIT(0), KGIDT_INIT(0),
143	current_cred(), KEY_POS_SEARCH \|
144	KEY_USR_VIEW \| KEY_USR_READ \| KEY_USR_WRITE \|
145	KEY_USR_SEARCH \| KEY_USR_SETATTR,
146	KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL);
147	if (IS_ERR(ring))
148	return PTR_ERR(ring);
149
150	err = fsverity_sysctl_init();
151	if (err)
152	goto err_put_ring;
153
154	fsverity_keyring = ring;
155	return 0;
156
157	err_put_ring:
158	key_put(ring);
159	return err;
160	}