1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * efi_secret module 4 * 5 * Copyright (C) 2022 IBM Corporation 6 * Author: Dov Murik <dovmurik@linux.ibm.com> 7 */ 8 9 /** 10 * DOC: efi_secret: Allow reading EFI confidential computing (coco) secret area 11 * via securityfs interface. 12 * 13 * When the module is loaded (and securityfs is mounted, typically under 14 * /sys/kernel/security), a "secrets/coco" directory is created in securityfs. 15 * In it, a file is created for each secret entry. The name of each such file 16 * is the GUID of the secret entry, and its content is the secret data. 17 */ 18 19 #include <linux/platform_device.h> 20 #include <linux/seq_file.h> 21 #include <linux/fs.h> 22 #include <linux/kernel.h> 23 #include <linux/init.h> 24 #include <linux/module.h> 25 #include <linux/io.h> 26 #include <linux/security.h> 27 #include <linux/efi.h> 28 #include <linux/cacheflush.h> 29 30 #define EFI_SECRET_NUM_FILES 64 31 32 struct efi_secret { 33 struct dentry *secrets_dir; 34 struct dentry *fs_dir; 35 struct dentry *fs_files[EFI_SECRET_NUM_FILES]; 36 void __iomem *secret_data; 37 u64 secret_data_len; 38 }; 39 40 /* 41 * Structure of the EFI secret area 42 * 43 * Offset Length 44 * (bytes) (bytes) Usage 45 * ------- ------- ----- 46 * 0 16 Secret table header GUID (must be 1e74f542-71dd-4d66-963e-ef4287ff173b) 47 * 16 4 Length of bytes of the entire secret area 48 * 49 * 20 16 First secret entry's GUID 50 * 36 4 First secret entry's length in bytes (= 16 + 4 + x) 51 * 40 x First secret entry's data 52 * 53 * 40+x 16 Second secret entry's GUID 54 * 56+x 4 Second secret entry's length in bytes (= 16 + 4 + y) 55 * 60+x y Second secret entry's data 56 * 57 * (... and so on for additional entries) 58 * 59 * The GUID of each secret entry designates the usage of the secret data. 60 */ 61 62 /** 63 * struct secret_header - Header of entire secret area; this should be followed 64 * by instances of struct secret_entry. 65 * @guid: Must be EFI_SECRET_TABLE_HEADER_GUID 66 * @len: Length in bytes of entire secret area, including header 67 */ 68 struct secret_header { 69 efi_guid_t guid; 70 u32 len; 71 } __attribute((packed)); 72 73 /** 74 * struct secret_entry - Holds one secret entry 75 * @guid: Secret-specific GUID (or NULL_GUID if this secret entry was deleted) 76 * @len: Length of secret entry, including its guid and len fields 77 * @data: The secret data (full of zeros if this secret entry was deleted) 78 */ 79 struct secret_entry { 80 efi_guid_t guid; 81 u32 len; 82 u8 data[]; 83 } __attribute((packed)); 84 85 static size_t secret_entry_data_len(struct secret_entry *e) 86 { 87 return e->len - sizeof(*e); 88 } 89 90 static struct efi_secret the_efi_secret; 91 92 static inline struct efi_secret *efi_secret_get(void) 93 { 94 return &the_efi_secret; 95 } 96 97 static int efi_secret_bin_file_show(struct seq_file *file, void *data) 98 { 99 struct secret_entry *e = file->private; 100 101 if (e) 102 seq_write(file, e->data, secret_entry_data_len(e)); 103 104 return 0; 105 } 106 DEFINE_SHOW_ATTRIBUTE(efi_secret_bin_file); 107 108 /* 109 * Overwrite memory content with zeroes, and ensure that dirty cache lines are 110 * actually written back to memory, to clear out the secret. 111 */ 112 static void wipe_memory(void *addr, size_t size) 113 { 114 memzero_explicit(addr, size); 115 #ifdef CONFIG_X86 116 clflush_cache_range(addr, size); 117 #endif 118 } 119 120 static int efi_secret_unlink(struct inode *dir, struct dentry *dentry) 121 { 122 struct efi_secret *s = efi_secret_get(); 123 struct inode *inode = d_inode(dentry); 124 struct secret_entry *e = (struct secret_entry *)inode->i_private; 125 int i; 126 127 if (e) { 128 /* Zero out the secret data */ 129 wipe_memory(e->data, secret_entry_data_len(e)); 130 e->guid = NULL_GUID; 131 } 132 133 inode->i_private = NULL; 134 135 for (i = 0; i < EFI_SECRET_NUM_FILES; i++) 136 if (s->fs_files[i] == dentry) 137 s->fs_files[i] = NULL; 138 139 /* 140 * securityfs_remove tries to lock the directory's inode, but we reach 141 * the unlink callback when it's already locked 142 */ 143 inode_unlock(dir); 144 securityfs_remove(dentry); 145 inode_lock(dir); 146 147 return 0; 148 } 149 150 static const struct inode_operations efi_secret_dir_inode_operations = { 151 .lookup = simple_lookup, 152 .unlink = efi_secret_unlink, 153 }; 154 155 static int efi_secret_map_area(struct platform_device *dev) 156 { 157 int ret; 158 struct efi_secret *s = efi_secret_get(); 159 struct linux_efi_coco_secret_area *secret_area; 160 161 if (efi.coco_secret == EFI_INVALID_TABLE_ADDR) { 162 dev_err(&dev->dev, "Secret area address is not available\n"); 163 return -EINVAL; 164 } 165 166 secret_area = memremap(efi.coco_secret, sizeof(*secret_area), MEMREMAP_WB); 167 if (secret_area == NULL) { 168 dev_err(&dev->dev, "Could not map secret area EFI config entry\n"); 169 return -ENOMEM; 170 } 171 if (!secret_area->base_pa || secret_area->size < sizeof(struct secret_header)) { 172 dev_err(&dev->dev, 173 "Invalid secret area memory location (base_pa=0x%llx size=0x%llx)\n", 174 secret_area->base_pa, secret_area->size); 175 ret = -EINVAL; 176 goto unmap; 177 } 178 179 s->secret_data = ioremap_encrypted(secret_area->base_pa, secret_area->size); 180 if (s->secret_data == NULL) { 181 dev_err(&dev->dev, "Could not map secret area\n"); 182 ret = -ENOMEM; 183 goto unmap; 184 } 185 186 s->secret_data_len = secret_area->size; 187 ret = 0; 188 189 unmap: 190 memunmap(secret_area); 191 return ret; 192 } 193 194 static void efi_secret_securityfs_teardown(struct platform_device *dev) 195 { 196 struct efi_secret *s = efi_secret_get(); 197 int i; 198 199 for (i = (EFI_SECRET_NUM_FILES - 1); i >= 0; i--) { 200 securityfs_remove(s->fs_files[i]); 201 s->fs_files[i] = NULL; 202 } 203 204 securityfs_remove(s->fs_dir); 205 s->fs_dir = NULL; 206 207 securityfs_remove(s->secrets_dir); 208 s->secrets_dir = NULL; 209 210 dev_dbg(&dev->dev, "Removed securityfs entries\n"); 211 } 212 213 static int efi_secret_securityfs_setup(struct platform_device *dev) 214 { 215 struct efi_secret *s = efi_secret_get(); 216 int ret = 0, i = 0, bytes_left; 217 unsigned char *ptr; 218 struct secret_header *h; 219 struct secret_entry *e; 220 struct dentry *dent; 221 char guid_str[EFI_VARIABLE_GUID_LEN + 1]; 222 223 ptr = (void __force *)s->secret_data; 224 h = (struct secret_header *)ptr; 225 if (efi_guidcmp(h->guid, EFI_SECRET_TABLE_HEADER_GUID)) { 226 /* 227 * This is not an error: it just means that EFI defines secret 228 * area but it was not populated by the Guest Owner. 229 */ 230 dev_dbg(&dev->dev, "EFI secret area does not start with correct GUID\n"); 231 return -ENODEV; 232 } 233 if (h->len < sizeof(*h)) { 234 dev_err(&dev->dev, "EFI secret area reported length is too small\n"); 235 return -EINVAL; 236 } 237 if (h->len > s->secret_data_len) { 238 dev_err(&dev->dev, "EFI secret area reported length is too big\n"); 239 return -EINVAL; 240 } 241 242 s->secrets_dir = NULL; 243 s->fs_dir = NULL; 244 memset(s->fs_files, 0, sizeof(s->fs_files)); 245 246 dent = securityfs_create_dir("secrets", NULL); 247 if (IS_ERR(dent)) { 248 dev_err(&dev->dev, "Error creating secrets securityfs directory entry err=%ld\n", 249 PTR_ERR(dent)); 250 return PTR_ERR(dent); 251 } 252 s->secrets_dir = dent; 253 254 dent = securityfs_create_dir("coco", s->secrets_dir); 255 if (IS_ERR(dent)) { 256 dev_err(&dev->dev, "Error creating coco securityfs directory entry err=%ld\n", 257 PTR_ERR(dent)); 258 return PTR_ERR(dent); 259 } 260 d_inode(dent)->i_op = &efi_secret_dir_inode_operations; 261 s->fs_dir = dent; 262 263 bytes_left = h->len - sizeof(*h); 264 ptr += sizeof(*h); 265 while (bytes_left >= (int)sizeof(*e) && i < EFI_SECRET_NUM_FILES) { 266 e = (struct secret_entry *)ptr; 267 if (e->len < sizeof(*e) || e->len > (unsigned int)bytes_left) { 268 dev_err(&dev->dev, "EFI secret area is corrupted\n"); 269 ret = -EINVAL; 270 goto err_cleanup; 271 } 272 273 /* Skip deleted entries (which will have NULL_GUID) */ 274 if (efi_guidcmp(e->guid, NULL_GUID)) { 275 efi_guid_to_str(&e->guid, guid_str); 276 277 dent = securityfs_create_file(guid_str, 0440, s->fs_dir, (void *)e, 278 &efi_secret_bin_file_fops); 279 if (IS_ERR(dent)) { 280 dev_err(&dev->dev, "Error creating efi_secret securityfs entry\n"); 281 ret = PTR_ERR(dent); 282 goto err_cleanup; 283 } 284 285 s->fs_files[i++] = dent; 286 } 287 ptr += e->len; 288 bytes_left -= e->len; 289 } 290 291 dev_info(&dev->dev, "Created %d entries in securityfs secrets/coco\n", i); 292 return 0; 293 294 err_cleanup: 295 efi_secret_securityfs_teardown(dev); 296 return ret; 297 } 298 299 static void efi_secret_unmap_area(void) 300 { 301 struct efi_secret *s = efi_secret_get(); 302 303 if (s->secret_data) { 304 iounmap(s->secret_data); 305 s->secret_data = NULL; 306 s->secret_data_len = 0; 307 } 308 } 309 310 static int efi_secret_probe(struct platform_device *dev) 311 { 312 int ret; 313 314 ret = efi_secret_map_area(dev); 315 if (ret) 316 return ret; 317 318 ret = efi_secret_securityfs_setup(dev); 319 if (ret) 320 goto err_unmap; 321 322 return ret; 323 324 err_unmap: 325 efi_secret_unmap_area(); 326 return ret; 327 } 328 329 static int efi_secret_remove(struct platform_device *dev) 330 { 331 efi_secret_securityfs_teardown(dev); 332 efi_secret_unmap_area(); 333 return 0; 334 } 335 336 static struct platform_driver efi_secret_driver = { 337 .probe = efi_secret_probe, 338 .remove = efi_secret_remove, 339 .driver = { 340 .name = "efi_secret", 341 }, 342 }; 343 344 module_platform_driver(efi_secret_driver); 345 346 MODULE_DESCRIPTION("Confidential computing EFI secret area access"); 347 MODULE_AUTHOR("IBM"); 348 MODULE_LICENSE("GPL"); 349 MODULE_ALIAS("platform:efi_secret"); 350