1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Handling of TPM command and other buffers. 4 */ 5 6 #include <linux/tpm_command.h> 7 #include <linux/module.h> 8 #include <linux/tpm.h> 9 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 */ 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 24 tpm_buf_reset(buf, tag, ordinal); 25 return 0; 26 } 27 EXPORT_SYMBOL_GPL(tpm_buf_init); 28 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 */ 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 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); 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 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 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 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 */ 92 u32 tpm_buf_length(struct tpm_buf *buf) 93 { 94 return buf->length; 95 } 96 EXPORT_SYMBOL_GPL(tpm_buf_length); 97 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) 105 { 106 /* Return silently if overflow has already happened. */ 107 if (buf->flags & TPM_BUF_OVERFLOW) 108 return; 109 110 if ((buf->length + new_length) > PAGE_SIZE) { 111 WARN(1, "tpm_buf: write overflow\n"); 112 buf->flags |= TPM_BUF_OVERFLOW; 113 return; 114 } 115 116 memcpy(&buf->data[buf->length], new_data, new_length); 117 buf->length += new_length; 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); 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); 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); 224