Commit | Line | Data |
---|---|---|
17d89b2e JB |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Handling of TPM command and other buffers. | |
4 | */ | |
5 | ||
e1b72e1b | 6 | #include <linux/tpm_command.h> |
17d89b2e JB |
7 | #include <linux/module.h> |
8 | #include <linux/tpm.h> | |
9 | ||
e1b72e1b JS |
10 | /** |
11 | * tpm_buf_init() - Allocate and initialize a TPM command | |
12 | * @buf: A &tpm_buf | |
13 | * @tag: TPM_TAG_RQU_COMMAND, TPM2_ST_NO_SESSIONS or TPM2_ST_SESSIONS | |
14 | * @ordinal: A command ordinal | |
15 | * | |
16 | * Return: 0 or -ENOMEM | |
17 | */ | |
17d89b2e JB |
18 | int tpm_buf_init(struct tpm_buf *buf, u16 tag, u32 ordinal) |
19 | { | |
20 | buf->data = (u8 *)__get_free_page(GFP_KERNEL); | |
21 | if (!buf->data) | |
22 | return -ENOMEM; | |
23 | ||
17d89b2e JB |
24 | tpm_buf_reset(buf, tag, ordinal); |
25 | return 0; | |
26 | } | |
27 | EXPORT_SYMBOL_GPL(tpm_buf_init); | |
28 | ||
e1b72e1b JS |
29 | /** |
30 | * tpm_buf_reset() - Initialize a TPM command | |
31 | * @buf: A &tpm_buf | |
32 | * @tag: TPM_TAG_RQU_COMMAND, TPM2_ST_NO_SESSIONS or TPM2_ST_SESSIONS | |
33 | * @ordinal: A command ordinal | |
34 | */ | |
17d89b2e JB |
35 | void tpm_buf_reset(struct tpm_buf *buf, u16 tag, u32 ordinal) |
36 | { | |
37 | struct tpm_header *head = (struct tpm_header *)buf->data; | |
38 | ||
e1b72e1b JS |
39 | WARN_ON(tag != TPM_TAG_RQU_COMMAND && tag != TPM2_ST_NO_SESSIONS && |
40 | tag != TPM2_ST_SESSIONS && tag != 0); | |
41 | ||
42 | buf->flags = 0; | |
43 | buf->length = sizeof(*head); | |
17d89b2e JB |
44 | head->tag = cpu_to_be16(tag); |
45 | head->length = cpu_to_be32(sizeof(*head)); | |
46 | head->ordinal = cpu_to_be32(ordinal); | |
47 | } | |
48 | EXPORT_SYMBOL_GPL(tpm_buf_reset); | |
49 | ||
d926ee92 JS |
50 | /** |
51 | * tpm_buf_init_sized() - Allocate and initialize a sized (TPM2B) buffer | |
52 | * @buf: A @tpm_buf | |
53 | * | |
54 | * Return: 0 or -ENOMEM | |
55 | */ | |
56 | int tpm_buf_init_sized(struct tpm_buf *buf) | |
57 | { | |
58 | buf->data = (u8 *)__get_free_page(GFP_KERNEL); | |
59 | if (!buf->data) | |
60 | return -ENOMEM; | |
61 | ||
62 | tpm_buf_reset_sized(buf); | |
63 | return 0; | |
64 | } | |
65 | EXPORT_SYMBOL_GPL(tpm_buf_init_sized); | |
66 | ||
67 | /** | |
68 | * tpm_buf_reset_sized() - Initialize a sized buffer | |
69 | * @buf: A &tpm_buf | |
70 | */ | |
71 | void tpm_buf_reset_sized(struct tpm_buf *buf) | |
72 | { | |
73 | buf->flags = TPM_BUF_TPM2B; | |
74 | buf->length = 2; | |
75 | buf->data[0] = 0; | |
76 | buf->data[1] = 0; | |
77 | } | |
78 | EXPORT_SYMBOL_GPL(tpm_buf_reset_sized); | |
79 | ||
17d89b2e JB |
80 | void tpm_buf_destroy(struct tpm_buf *buf) |
81 | { | |
82 | free_page((unsigned long)buf->data); | |
83 | } | |
84 | EXPORT_SYMBOL_GPL(tpm_buf_destroy); | |
85 | ||
e1b72e1b JS |
86 | /** |
87 | * tpm_buf_length() - Return the number of bytes consumed by the data | |
88 | * @buf: A &tpm_buf | |
89 | * | |
90 | * Return: The number of bytes consumed by the buffer | |
91 | */ | |
17d89b2e JB |
92 | u32 tpm_buf_length(struct tpm_buf *buf) |
93 | { | |
e1b72e1b | 94 | return buf->length; |
17d89b2e JB |
95 | } |
96 | EXPORT_SYMBOL_GPL(tpm_buf_length); | |
97 | ||
e1b72e1b JS |
98 | /** |
99 | * tpm_buf_append() - Append data to an initialized buffer | |
100 | * @buf: A &tpm_buf | |
101 | * @new_data: A data blob | |
102 | * @new_length: Size of the appended data | |
103 | */ | |
104 | void tpm_buf_append(struct tpm_buf *buf, const u8 *new_data, u16 new_length) | |
17d89b2e | 105 | { |
17d89b2e JB |
106 | /* Return silently if overflow has already happened. */ |
107 | if (buf->flags & TPM_BUF_OVERFLOW) | |
108 | return; | |
109 | ||
e1b72e1b | 110 | if ((buf->length + new_length) > PAGE_SIZE) { |
acd5eb4f | 111 | WARN(1, "tpm_buf: write overflow\n"); |
17d89b2e JB |
112 | buf->flags |= TPM_BUF_OVERFLOW; |
113 | return; | |
114 | } | |
115 | ||
e1b72e1b JS |
116 | memcpy(&buf->data[buf->length], new_data, new_length); |
117 | buf->length += new_length; | |
d926ee92 JS |
118 | |
119 | if (buf->flags & TPM_BUF_TPM2B) | |
120 | ((__be16 *)buf->data)[0] = cpu_to_be16(buf->length - 2); | |
121 | else | |
122 | ((struct tpm_header *)buf->data)->length = cpu_to_be32(buf->length); | |
17d89b2e JB |
123 | } |
124 | EXPORT_SYMBOL_GPL(tpm_buf_append); | |
125 | ||
126 | void tpm_buf_append_u8(struct tpm_buf *buf, const u8 value) | |
127 | { | |
128 | tpm_buf_append(buf, &value, 1); | |
129 | } | |
130 | EXPORT_SYMBOL_GPL(tpm_buf_append_u8); | |
131 | ||
132 | void tpm_buf_append_u16(struct tpm_buf *buf, const u16 value) | |
133 | { | |
134 | __be16 value2 = cpu_to_be16(value); | |
135 | ||
136 | tpm_buf_append(buf, (u8 *)&value2, 2); | |
137 | } | |
138 | EXPORT_SYMBOL_GPL(tpm_buf_append_u16); | |
139 | ||
140 | void tpm_buf_append_u32(struct tpm_buf *buf, const u32 value) | |
141 | { | |
142 | __be32 value2 = cpu_to_be32(value); | |
143 | ||
144 | tpm_buf_append(buf, (u8 *)&value2, 4); | |
145 | } | |
146 | EXPORT_SYMBOL_GPL(tpm_buf_append_u32); | |
acd5eb4f JS |
147 | |
148 | /** | |
149 | * tpm_buf_read() - Read from a TPM buffer | |
150 | * @buf: &tpm_buf instance | |
151 | * @offset: offset within the buffer | |
152 | * @count: the number of bytes to read | |
153 | * @output: the output buffer | |
154 | */ | |
155 | static void tpm_buf_read(struct tpm_buf *buf, off_t *offset, size_t count, void *output) | |
156 | { | |
157 | off_t next_offset; | |
158 | ||
159 | /* Return silently if overflow has already happened. */ | |
160 | if (buf->flags & TPM_BUF_BOUNDARY_ERROR) | |
161 | return; | |
162 | ||
163 | next_offset = *offset + count; | |
164 | if (next_offset > buf->length) { | |
165 | WARN(1, "tpm_buf: read out of boundary\n"); | |
166 | buf->flags |= TPM_BUF_BOUNDARY_ERROR; | |
167 | return; | |
168 | } | |
169 | ||
170 | memcpy(output, &buf->data[*offset], count); | |
171 | *offset = next_offset; | |
172 | } | |
173 | ||
174 | /** | |
175 | * tpm_buf_read_u8() - Read 8-bit word from a TPM buffer | |
176 | * @buf: &tpm_buf instance | |
177 | * @offset: offset within the buffer | |
178 | * | |
179 | * Return: next 8-bit word | |
180 | */ | |
181 | u8 tpm_buf_read_u8(struct tpm_buf *buf, off_t *offset) | |
182 | { | |
183 | u8 value; | |
184 | ||
185 | tpm_buf_read(buf, offset, sizeof(value), &value); | |
186 | ||
187 | return value; | |
188 | } | |
189 | EXPORT_SYMBOL_GPL(tpm_buf_read_u8); | |
190 | ||
191 | /** | |
192 | * tpm_buf_read_u16() - Read 16-bit word from a TPM buffer | |
193 | * @buf: &tpm_buf instance | |
194 | * @offset: offset within the buffer | |
195 | * | |
196 | * Return: next 16-bit word | |
197 | */ | |
198 | u16 tpm_buf_read_u16(struct tpm_buf *buf, off_t *offset) | |
199 | { | |
200 | u16 value; | |
201 | ||
202 | tpm_buf_read(buf, offset, sizeof(value), &value); | |
203 | ||
204 | return be16_to_cpu(value); | |
205 | } | |
206 | EXPORT_SYMBOL_GPL(tpm_buf_read_u16); | |
207 | ||
208 | /** | |
209 | * tpm_buf_read_u32() - Read 32-bit word from a TPM buffer | |
210 | * @buf: &tpm_buf instance | |
211 | * @offset: offset within the buffer | |
212 | * | |
213 | * Return: next 32-bit word | |
214 | */ | |
215 | u32 tpm_buf_read_u32(struct tpm_buf *buf, off_t *offset) | |
216 | { | |
217 | u32 value; | |
218 | ||
219 | tpm_buf_read(buf, offset, sizeof(value), &value); | |
220 | ||
221 | return be32_to_cpu(value); | |
222 | } | |
223 | EXPORT_SYMBOL_GPL(tpm_buf_read_u32); | |
11189d68 JB |
224 | |
225 | static u16 tpm_buf_tag(struct tpm_buf *buf) | |
226 | { | |
227 | struct tpm_header *head = (struct tpm_header *)buf->data; | |
228 | ||
229 | return be16_to_cpu(head->tag); | |
230 | } | |
231 | ||
232 | /** | |
233 | * tpm_buf_parameters - return the TPM response parameters area of the tpm_buf | |
234 | * @buf: tpm_buf to use | |
235 | * | |
236 | * Where the parameters are located depends on the tag of a TPM | |
237 | * command (it's immediately after the header for TPM_ST_NO_SESSIONS | |
238 | * or 4 bytes after for TPM_ST_SESSIONS). Evaluate this and return a | |
239 | * pointer to the first byte of the parameters area. | |
240 | * | |
241 | * @return: pointer to parameters area | |
242 | */ | |
243 | u8 *tpm_buf_parameters(struct tpm_buf *buf) | |
244 | { | |
245 | int offset = TPM_HEADER_SIZE; | |
246 | ||
247 | if (tpm_buf_tag(buf) == TPM2_ST_SESSIONS) | |
248 | offset += 4; | |
249 | ||
250 | return &buf->data[offset]; | |
251 | } |