1// SPDX-License-Identifier: GPL-2.0-only
2/* Copyright(c) 2023 Intel Corporation. All rights reserved. */
3
4#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
5
6#include <linux/tsm.h>
7#include <linux/err.h>
8#include <linux/slab.h>
9#include <linux/rwsem.h>
10#include <linux/string.h>
11#include <linux/module.h>
12#include <linux/cleanup.h>
13#include <linux/configfs.h>
14
15static struct tsm_provider {
16	const struct tsm_ops *ops;
17	const struct config_item_type *type;
18	void *data;
19} provider;
20static DECLARE_RWSEM(tsm_rwsem);
21
22/**
23 * DOC: Trusted Security Module (TSM) Attestation Report Interface
24 *
25 * The TSM report interface is a common provider of blobs that facilitate
26 * attestation of a TVM (confidential computing guest) by an attestation
27 * service. A TSM report combines a user-defined blob (likely a public-key with
28 * a nonce for a key-exchange protocol) with a signed attestation report. That
29 * combined blob is then used to obtain secrets provided by an agent that can
30 * validate the attestation report. The expectation is that this interface is
31 * invoked infrequently, however configfs allows for multiple agents to
32 * own their own report generation instances to generate reports as
33 * often as needed.
34 *
35 * The attestation report format is TSM provider specific, when / if a standard
36 * materializes that can be published instead of the vendor layout. Until then
37 * the 'provider' attribute indicates the format of 'outblob', and optionally
38 * 'auxblob'.
39 */
40
41struct tsm_report_state {
42	struct tsm_report report;
43	unsigned long write_generation;
44	unsigned long read_generation;
45	struct config_item cfg;
46};
47
48enum tsm_data_select {
49	TSM_REPORT,
50	TSM_CERTS,
51};
52
53static struct tsm_report *to_tsm_report(struct config_item *cfg)
54{
55	struct tsm_report_state *state =
56		container_of(cfg, struct tsm_report_state, cfg);
57
58	return &state->report;
59}
60
61static struct tsm_report_state *to_state(struct tsm_report *report)
62{
63	return container_of(report, struct tsm_report_state, report);
64}
65
66static int try_advance_write_generation(struct tsm_report *report)
67{
68	struct tsm_report_state *state = to_state(report);
69
70	lockdep_assert_held_write(&tsm_rwsem);
71
72	/*
73	 * Malicious or broken userspace has written enough times for
74	 * read_generation == write_generation by modular arithmetic without an
75	 * interim read. Stop accepting updates until the current report
76	 * configuration is read.
77	 */
78	if (state->write_generation == state->read_generation - 1)
79		return -EBUSY;
80	state->write_generation++;
81	return 0;
82}
83
84static ssize_t tsm_report_privlevel_store(struct config_item *cfg,
85					  const char *buf, size_t len)
86{
87	struct tsm_report *report = to_tsm_report(cfg);
88	unsigned int val;
89	int rc;
90
91	rc = kstrtouint(buf, 0, &val);
92	if (rc)
93		return rc;
94
95	/*
96	 * The valid privilege levels that a TSM might accept, if it accepts a
97	 * privilege level setting at all, are a max of TSM_PRIVLEVEL_MAX (see
98	 * SEV-SNP GHCB) and a minimum of a TSM selected floor value no less
99	 * than 0.
100	 */
101	if (provider.ops->privlevel_floor > val || val > TSM_PRIVLEVEL_MAX)
102		return -EINVAL;
103
104	guard(rwsem_write)(&tsm_rwsem);
105	rc = try_advance_write_generation(report);
106	if (rc)
107		return rc;
108	report->desc.privlevel = val;
109
110	return len;
111}
112CONFIGFS_ATTR_WO(tsm_report_, privlevel);
113
114static ssize_t tsm_report_privlevel_floor_show(struct config_item *cfg,
115					       char *buf)
116{
117	guard(rwsem_read)(&tsm_rwsem);
118	return sysfs_emit(buf, "%u\n", provider.ops->privlevel_floor);
119}
120CONFIGFS_ATTR_RO(tsm_report_, privlevel_floor);
121
122static ssize_t tsm_report_inblob_write(struct config_item *cfg,
123				       const void *buf, size_t count)
124{
125	struct tsm_report *report = to_tsm_report(cfg);
126	int rc;
127
128	guard(rwsem_write)(&tsm_rwsem);
129	rc = try_advance_write_generation(report);
130	if (rc)
131		return rc;
132
133	report->desc.inblob_len = count;
134	memcpy(report->desc.inblob, buf, count);
135	return count;
136}
137CONFIGFS_BIN_ATTR_WO(tsm_report_, inblob, NULL, TSM_INBLOB_MAX);
138
139static ssize_t tsm_report_generation_show(struct config_item *cfg, char *buf)
140{
141	struct tsm_report *report = to_tsm_report(cfg);
142	struct tsm_report_state *state = to_state(report);
143
144	guard(rwsem_read)(&tsm_rwsem);
145	return sysfs_emit(buf, "%lu\n", state->write_generation);
146}
147CONFIGFS_ATTR_RO(tsm_report_, generation);
148
149static ssize_t tsm_report_provider_show(struct config_item *cfg, char *buf)
150{
151	guard(rwsem_read)(&tsm_rwsem);
152	return sysfs_emit(buf, "%s\n", provider.ops->name);
153}
154CONFIGFS_ATTR_RO(tsm_report_, provider);
155
156static ssize_t __read_report(struct tsm_report *report, void *buf, size_t count,
157			     enum tsm_data_select select)
158{
159	loff_t offset = 0;
160	ssize_t len;
161	u8 *out;
162
163	if (select == TSM_REPORT) {
164		out = report->outblob;
165		len = report->outblob_len;
166	} else {
167		out = report->auxblob;
168		len = report->auxblob_len;
169	}
170
171	/*
172	 * Recall that a NULL @buf is configfs requesting the size of
173	 * the buffer.
174	 */
175	if (!buf)
176		return len;
177	return memory_read_from_buffer(buf, count, &offset, out, len);
178}
179
180static ssize_t read_cached_report(struct tsm_report *report, void *buf,
181				  size_t count, enum tsm_data_select select)
182{
183	struct tsm_report_state *state = to_state(report);
184
185	guard(rwsem_read)(&tsm_rwsem);
186	if (!report->desc.inblob_len)
187		return -EINVAL;
188
189	/*
190	 * A given TSM backend always fills in ->outblob regardless of
191	 * whether the report includes an auxblob or not.
192	 */
193	if (!report->outblob ||
194	    state->read_generation != state->write_generation)
195		return -EWOULDBLOCK;
196
197	return __read_report(report, buf, count, select);
198}
199
200static ssize_t tsm_report_read(struct tsm_report *report, void *buf,
201			       size_t count, enum tsm_data_select select)
202{
203	struct tsm_report_state *state = to_state(report);
204	const struct tsm_ops *ops;
205	ssize_t rc;
206
207	/* try to read from the existing report if present and valid... */
208	rc = read_cached_report(report, buf, count, select);
209	if (rc >= 0 || rc != -EWOULDBLOCK)
210		return rc;
211
212	/* slow path, report may need to be regenerated... */
213	guard(rwsem_write)(&tsm_rwsem);
214	ops = provider.ops;
215	if (!ops)
216		return -ENOTTY;
217	if (!report->desc.inblob_len)
218		return -EINVAL;
219
220	/* did another thread already generate this report? */
221	if (report->outblob &&
222	    state->read_generation == state->write_generation)
223		goto out;
224
225	kvfree(report->outblob);
226	kvfree(report->auxblob);
227	report->outblob = NULL;
228	report->auxblob = NULL;
229	rc = ops->report_new(report, provider.data);
230	if (rc < 0)
231		return rc;
232	state->read_generation = state->write_generation;
233out:
234	return __read_report(report, buf, count, select);
235}
236
237static ssize_t tsm_report_outblob_read(struct config_item *cfg, void *buf,
238				       size_t count)
239{
240	struct tsm_report *report = to_tsm_report(cfg);
241
242	return tsm_report_read(report, buf, count, TSM_REPORT);
243}
244CONFIGFS_BIN_ATTR_RO(tsm_report_, outblob, NULL, TSM_OUTBLOB_MAX);
245
246static ssize_t tsm_report_auxblob_read(struct config_item *cfg, void *buf,
247				       size_t count)
248{
249	struct tsm_report *report = to_tsm_report(cfg);
250
251	return tsm_report_read(report, buf, count, TSM_CERTS);
252}
253CONFIGFS_BIN_ATTR_RO(tsm_report_, auxblob, NULL, TSM_OUTBLOB_MAX);
254
255#define TSM_DEFAULT_ATTRS() \
256	&tsm_report_attr_generation, \
257	&tsm_report_attr_provider
258
259static struct configfs_attribute *tsm_report_attrs[] = {
260	TSM_DEFAULT_ATTRS(),
261	NULL,
262};
263
264static struct configfs_attribute *tsm_report_extra_attrs[] = {
265	TSM_DEFAULT_ATTRS(),
266	&tsm_report_attr_privlevel,
267	&tsm_report_attr_privlevel_floor,
268	NULL,
269};
270
271#define TSM_DEFAULT_BIN_ATTRS() \
272	&tsm_report_attr_inblob, \
273	&tsm_report_attr_outblob
274
275static struct configfs_bin_attribute *tsm_report_bin_attrs[] = {
276	TSM_DEFAULT_BIN_ATTRS(),
277	NULL,
278};
279
280static struct configfs_bin_attribute *tsm_report_bin_extra_attrs[] = {
281	TSM_DEFAULT_BIN_ATTRS(),
282	&tsm_report_attr_auxblob,
283	NULL,
284};
285
286static void tsm_report_item_release(struct config_item *cfg)
287{
288	struct tsm_report *report = to_tsm_report(cfg);
289	struct tsm_report_state *state = to_state(report);
290
291	kvfree(report->auxblob);
292	kvfree(report->outblob);
293	kfree(state);
294}
295
296static struct configfs_item_operations tsm_report_item_ops = {
297	.release = tsm_report_item_release,
298};
299
300const struct config_item_type tsm_report_default_type = {
301	.ct_owner = THIS_MODULE,
302	.ct_bin_attrs = tsm_report_bin_attrs,
303	.ct_attrs = tsm_report_attrs,
304	.ct_item_ops = &tsm_report_item_ops,
305};
306EXPORT_SYMBOL_GPL(tsm_report_default_type);
307
308const struct config_item_type tsm_report_extra_type = {
309	.ct_owner = THIS_MODULE,
310	.ct_bin_attrs = tsm_report_bin_extra_attrs,
311	.ct_attrs = tsm_report_extra_attrs,
312	.ct_item_ops = &tsm_report_item_ops,
313};
314EXPORT_SYMBOL_GPL(tsm_report_extra_type);
315
316static struct config_item *tsm_report_make_item(struct config_group *group,
317						const char *name)
318{
319	struct tsm_report_state *state;
320
321	guard(rwsem_read)(&tsm_rwsem);
322	if (!provider.ops)
323		return ERR_PTR(-ENXIO);
324
325	state = kzalloc(sizeof(*state), GFP_KERNEL);
326	if (!state)
327		return ERR_PTR(-ENOMEM);
328
329	config_item_init_type_name(&state->cfg, name, provider.type);
330	return &state->cfg;
331}
332
333static struct configfs_group_operations tsm_report_group_ops = {
334	.make_item = tsm_report_make_item,
335};
336
337static const struct config_item_type tsm_reports_type = {
338	.ct_owner = THIS_MODULE,
339	.ct_group_ops = &tsm_report_group_ops,
340};
341
342static const struct config_item_type tsm_root_group_type = {
343	.ct_owner = THIS_MODULE,
344};
345
346static struct configfs_subsystem tsm_configfs = {
347	.su_group = {
348		.cg_item = {
349			.ci_namebuf = "tsm",
350			.ci_type = &tsm_root_group_type,
351		},
352	},
353	.su_mutex = __MUTEX_INITIALIZER(tsm_configfs.su_mutex),
354};
355
356int tsm_register(const struct tsm_ops *ops, void *priv,
357		 const struct config_item_type *type)
358{
359	const struct tsm_ops *conflict;
360
361	if (!type)
362		type = &tsm_report_default_type;
363	if (!(type == &tsm_report_default_type || type == &tsm_report_extra_type))
364		return -EINVAL;
365
366	guard(rwsem_write)(&tsm_rwsem);
367	conflict = provider.ops;
368	if (conflict) {
369		pr_err("\"%s\" ops already registered\n", conflict->name);
370		return -EBUSY;
371	}
372
373	provider.ops = ops;
374	provider.data = priv;
375	provider.type = type;
376	return 0;
377}
378EXPORT_SYMBOL_GPL(tsm_register);
379
380int tsm_unregister(const struct tsm_ops *ops)
381{
382	guard(rwsem_write)(&tsm_rwsem);
383	if (ops != provider.ops)
384		return -EBUSY;
385	provider.ops = NULL;
386	provider.data = NULL;
387	provider.type = NULL;
388	return 0;
389}
390EXPORT_SYMBOL_GPL(tsm_unregister);
391
392static struct config_group *tsm_report_group;
393
394static int __init tsm_init(void)
395{
396	struct config_group *root = &tsm_configfs.su_group;
397	struct config_group *tsm;
398	int rc;
399
400	config_group_init(root);
401	rc = configfs_register_subsystem(&tsm_configfs);
402	if (rc)
403		return rc;
404
405	tsm = configfs_register_default_group(root, "report",
406					      &tsm_reports_type);
407	if (IS_ERR(tsm)) {
408		configfs_unregister_subsystem(&tsm_configfs);
409		return PTR_ERR(tsm);
410	}
411	tsm_report_group = tsm;
412
413	return 0;
414}
415module_init(tsm_init);
416
417static void __exit tsm_exit(void)
418{
419	configfs_unregister_default_group(tsm_report_group);
420	configfs_unregister_subsystem(&tsm_configfs);
421}
422module_exit(tsm_exit);
423
424MODULE_LICENSE("GPL");
425MODULE_DESCRIPTION("Provide Trusted Security Module attestation reports via configfs");
426