drivers/char/tpm/eventlog/tpm1.c

   1 /*
   2  * Copyright (C) 2005, 2012 IBM Corporation
   3  *
   4  * Authors:
   5  *      Kent Yoder <key@linux.vnet.ibm.com>
   6  *      Seiji Munetoh <munetoh@jp.ibm.com>
   7  *      Stefan Berger <stefanb@us.ibm.com>
   8  *      Reiner Sailer <sailer@watson.ibm.com>
   9  *      Kylene Hall <kjhall@us.ibm.com>
  10  *      Nayna Jain <nayna@linux.vnet.ibm.com>
  11  *
  12  * Maintained by: <tpmdd-devel@lists.sourceforge.net>
  13  *
  14  * Access to the event log created by a system's firmware / BIOS
  15  *
  16  * This program is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU General Public License
  18  * as published by the Free Software Foundation; either version
  19  * 2 of the License, or (at your option) any later version.
  20  *
  21  */
  22
  23 #include <linux/seq_file.h>
  24 #include <linux/efi.h>
  25 #include <linux/fs.h>
  26 #include <linux/security.h>
  27 #include <linux/module.h>
  28 #include <linux/slab.h>
  29 #include <linux/tpm_eventlog.h>
  30
  31 #include "../tpm.h"
  32 #include "common.h"
  33
  34
  35 static const char* tcpa_event_type_strings[] = {
  36         "PREBOOT",
  37         "POST CODE",
  38         "",
  39         "NO ACTION",
  40         "SEPARATOR",
  41         "ACTION",
  42         "EVENT TAG",
  43         "S-CRTM Contents",
  44         "S-CRTM Version",
  45         "CPU Microcode",
  46         "Platform Config Flags",
  47         "Table of Devices",
  48         "Compact Hash",
  49         "IPL",
  50         "IPL Partition Data",
  51         "Non-Host Code",
  52         "Non-Host Config",
  53         "Non-Host Info"
  54 };
  55
  56 static const char* tcpa_pc_event_id_strings[] = {
  57         "",
  58         "SMBIOS",
  59         "BIS Certificate",
  60         "POST BIOS ",
  61         "ESCD ",
  62         "CMOS",
  63         "NVRAM",
  64         "Option ROM",
  65         "Option ROM config",
  66         "",
  67         "Option ROM microcode ",
  68         "S-CRTM Version",
  69         "S-CRTM Contents ",
  70         "POST Contents ",
  71         "Table of Devices",
  72 };
  73
  74 /* returns pointer to start of pos. entry of tcg log */
  75 static void *tpm1_bios_measurements_start(struct seq_file *m, loff_t *pos)
  76 {
  77         loff_t i = 0;
  78         struct tpm_chip *chip = m->private;
  79         struct tpm_bios_log *log = &chip->log;
  80         void *addr = log->bios_event_log;
  81         void *limit = log->bios_event_log_end;
  82         struct tcpa_event *event;
  83         u32 converted_event_size;
  84         u32 converted_event_type;
  85
  86         /* read over *pos measurements */
  87         do {
  88                 event = addr;
  89
  90                 /* check if current entry is valid */
  91                 if (addr + sizeof(struct tcpa_event) > limit)
  92                         return NULL;
  93
  94                 converted_event_size =
  95                     do_endian_conversion(event->event_size);
  96                 converted_event_type =
  97                     do_endian_conversion(event->event_type);
  98
  99                 if (((converted_event_type == 0) && (converted_event_size == 0))
 100                     || ((addr + sizeof(struct tcpa_event) + converted_event_size)
 101                         > limit))
 102                         return NULL;
 103
 104                 if (i++ == *pos)
 105                         break;
 106
 107                 addr += (sizeof(struct tcpa_event) + converted_event_size);
 108         } while (1);
 109
 110         return addr;
 111 }
 112
 113 static void *tpm1_bios_measurements_next(struct seq_file *m, void *v,
 114                                         loff_t *pos)
 115 {
 116         struct tcpa_event *event = v;
 117         struct tpm_chip *chip = m->private;
 118         struct tpm_bios_log *log = &chip->log;
 119         void *limit = log->bios_event_log_end;
 120         u32 converted_event_size;
 121         u32 converted_event_type;
 122
 123         converted_event_size = do_endian_conversion(event->event_size);
 124
 125         v += sizeof(struct tcpa_event) + converted_event_size;
 126
 127         /* now check if current entry is valid */
 128         if ((v + sizeof(struct tcpa_event)) > limit)
 129                 return NULL;
 130
 131         event = v;
 132
 133         converted_event_size = do_endian_conversion(event->event_size);
 134         converted_event_type = do_endian_conversion(event->event_type);
 135
 136         if (((converted_event_type == 0) && (converted_event_size == 0)) ||
 137             ((v + sizeof(struct tcpa_event) + converted_event_size) > limit))
 138                 return NULL;
 139
 140         (*pos)++;
 141         return v;
 142 }
 143
 144 static void tpm1_bios_measurements_stop(struct seq_file *m, void *v)
 145 {
 146 }
 147
 148 static int get_event_name(char *dest, struct tcpa_event *event,
 149                         unsigned char * event_entry)
 150 {
 151         const char *name = "";
 152         /* 41 so there is room for 40 data and 1 nul */
 153         char data[41] = "";
 154         int i, n_len = 0, d_len = 0;
 155         struct tcpa_pc_event *pc_event;
 156
 157         switch (do_endian_conversion(event->event_type)) {
 158         case PREBOOT:
 159         case POST_CODE:
 160         case UNUSED:
 161         case NO_ACTION:
 162         case SCRTM_CONTENTS:
 163         case SCRTM_VERSION:
 164         case CPU_MICROCODE:
 165         case PLATFORM_CONFIG_FLAGS:
 166         case TABLE_OF_DEVICES:
 167         case COMPACT_HASH:
 168         case IPL:
 169         case IPL_PARTITION_DATA:
 170         case NONHOST_CODE:
 171         case NONHOST_CONFIG:
 172         case NONHOST_INFO:
 173                 name = tcpa_event_type_strings[do_endian_conversion
 174                                                 (event->event_type)];
 175                 n_len = strlen(name);
 176                 break;
 177         case SEPARATOR:
 178         case ACTION:
 179                 if (MAX_TEXT_EVENT >
 180                     do_endian_conversion(event->event_size)) {
 181                         name = event_entry;
 182                         n_len = do_endian_conversion(event->event_size);
 183                 }
 184                 break;
 185         case EVENT_TAG:
 186                 pc_event = (struct tcpa_pc_event *)event_entry;
 187
 188                 /* ToDo Row data -> Base64 */
 189
 190                 switch (do_endian_conversion(pc_event->event_id)) {
 191                 case SMBIOS:
 192                 case BIS_CERT:
 193                 case CMOS:
 194                 case NVRAM:
 195                 case OPTION_ROM_EXEC:
 196                 case OPTION_ROM_CONFIG:
 197                 case S_CRTM_VERSION:
 198                         name = tcpa_pc_event_id_strings[do_endian_conversion
 199                                                         (pc_event->event_id)];
 200                         n_len = strlen(name);
 201                         break;
 202                 /* hash data */
 203                 case POST_BIOS_ROM:
 204                 case ESCD:
 205                 case OPTION_ROM_MICROCODE:
 206                 case S_CRTM_CONTENTS:
 207                 case POST_CONTENTS:
 208                         name = tcpa_pc_event_id_strings[do_endian_conversion
 209                                                         (pc_event->event_id)];
 210                         n_len = strlen(name);
 211                         for (i = 0; i < 20; i++)
 212                                 d_len += sprintf(&data[2*i], "%02x",
 213                                                 pc_event->event_data[i]);
 214                         break;
 215                 default:
 216                         break;
 217                 }
 218         default:
 219                 break;
 220         }
 221
 222         return snprintf(dest, MAX_TEXT_EVENT, "[%.*s%.*s]",
 223                         n_len, name, d_len, data);
 224
 225 }
 226
 227 static int tpm1_binary_bios_measurements_show(struct seq_file *m, void *v)
 228 {
 229         struct tcpa_event *event = v;
 230         struct tcpa_event temp_event;
 231         char *temp_ptr;
 232         int i;
 233
 234         memcpy(&temp_event, event, sizeof(struct tcpa_event));
 235
 236         /* convert raw integers for endianness */
 237         temp_event.pcr_index = do_endian_conversion(event->pcr_index);
 238         temp_event.event_type = do_endian_conversion(event->event_type);
 239         temp_event.event_size = do_endian_conversion(event->event_size);
 240
 241         temp_ptr = (char *) &temp_event;
 242
 243         for (i = 0; i < (sizeof(struct tcpa_event) - 1) ; i++)
 244                 seq_putc(m, temp_ptr[i]);
 245
 246         temp_ptr = (char *) v;
 247
 248         for (i = (sizeof(struct tcpa_event) - 1);
 249              i < (sizeof(struct tcpa_event) + temp_event.event_size); i++)
 250                 seq_putc(m, temp_ptr[i]);
 251
 252         return 0;
 253
 254 }
 255
 256 static int tpm1_ascii_bios_measurements_show(struct seq_file *m, void *v)
 257 {
 258         int len = 0;
 259         char *eventname;
 260         struct tcpa_event *event = v;
 261         unsigned char *event_entry =
 262             (unsigned char *)(v + sizeof(struct tcpa_event));
 263
 264         eventname = kmalloc(MAX_TEXT_EVENT, GFP_KERNEL);
 265         if (!eventname) {
 266                 printk(KERN_ERR "%s: ERROR - No Memory for event name\n ",
 267                        __func__);
 268                 return -EFAULT;
 269         }
 270
 271         /* 1st: PCR */
 272         seq_printf(m, "%2d ", do_endian_conversion(event->pcr_index));
 273
 274         /* 2nd: SHA1 */
 275         seq_printf(m, "%20phN", event->pcr_value);
 276
 277         /* 3rd: event type identifier */
 278         seq_printf(m, " %02x", do_endian_conversion(event->event_type));
 279
 280         len += get_event_name(eventname, event, event_entry);
 281
 282         /* 4th: eventname <= max + \'0' delimiter */
 283         seq_printf(m, " %s\n", eventname);
 284
 285         kfree(eventname);
 286         return 0;
 287 }
 288
 289 const struct seq_operations tpm1_ascii_b_measurements_seqops = {
 290         .start = tpm1_bios_measurements_start,
 291         .next = tpm1_bios_measurements_next,
 292         .stop = tpm1_bios_measurements_stop,
 293         .show = tpm1_ascii_bios_measurements_show,
 294 };
 295
 296 const struct seq_operations tpm1_binary_b_measurements_seqops = {
 297         .start = tpm1_bios_measurements_start,
 298         .next = tpm1_bios_measurements_next,
 299         .stop = tpm1_bios_measurements_stop,
 300         .show = tpm1_binary_bios_measurements_show,
 301 };