1 /**
2 * Describes high level functions for converting an entire CPER log, and functions for parsing
3 * CPER headers and section descriptions into an intermediate JSON format.
4 *
5 * Author: Lawrence.Tang@arm.com
6 **/
7
8 #include <limits.h>
9 #include <stdio.h>
10 #include <string.h>
11 #include <json.h>
12
13 #include <libcper/base64.h>
14 #include <libcper/Cper.h>
15 #include <libcper/log.h>
16 #include <libcper/cper-parse.h>
17 #include <libcper/cper-parse-str.h>
18 #include <libcper/cper-utils.h>
19 #include <libcper/sections/cper-section.h>
20
21 //Private pre-definitions.
22 json_object *cper_header_to_ir(EFI_COMMON_ERROR_RECORD_HEADER *header);
23 json_object *
24 cper_section_descriptor_to_ir(EFI_ERROR_SECTION_DESCRIPTOR *section_descriptor);
25
26 json_object *cper_buf_section_to_ir(const void *cper_section_buf, size_t size,
27 EFI_ERROR_SECTION_DESCRIPTOR *descriptor);
28
header_signature_valid(EFI_COMMON_ERROR_RECORD_HEADER * header)29 static int header_signature_valid(EFI_COMMON_ERROR_RECORD_HEADER *header)
30 {
31 if (header->SignatureStart != EFI_ERROR_RECORD_SIGNATURE_START) {
32 cper_print_log(
33 "Invalid CPER file: Invalid header (incorrect signature). %x\n",
34 header->SignatureStart);
35 return 0;
36 }
37 if (header->SignatureEnd != EFI_ERROR_RECORD_SIGNATURE_END) {
38 cper_print_log(
39 "Invalid CPER file: Invalid header (incorrect signature end). %x\n",
40 header->SignatureEnd);
41 return 0;
42 }
43 if (header->SectionCount == 0) {
44 cper_print_log(
45 "Invalid CPER file: Invalid section count (0).\n");
46 return 0;
47 }
48 return 1;
49 }
50
header_valid(const char * cper_buf,size_t size)51 int header_valid(const char *cper_buf, size_t size)
52 {
53 if (size < sizeof(EFI_COMMON_ERROR_RECORD_HEADER)) {
54 return 0;
55 }
56 EFI_COMMON_ERROR_RECORD_HEADER *header =
57 (EFI_COMMON_ERROR_RECORD_HEADER *)cper_buf;
58 if (!header_signature_valid(header)) {
59 return 0;
60 }
61 return header_signature_valid(header);
62 }
63
cper_buf_to_ir(const unsigned char * cper_buf,size_t size)64 json_object *cper_buf_to_ir(const unsigned char *cper_buf, size_t size)
65 {
66 json_object *parent = NULL;
67 json_object *header_ir = NULL;
68 json_object *section_descriptors_ir = NULL;
69 json_object *sections_ir = NULL;
70
71 const unsigned char *pos = cper_buf;
72 unsigned int remaining = size;
73 if (size < sizeof(EFI_COMMON_ERROR_RECORD_HEADER)) {
74 goto fail;
75 }
76 EFI_COMMON_ERROR_RECORD_HEADER *header =
77 (EFI_COMMON_ERROR_RECORD_HEADER *)cper_buf;
78 if (!header_signature_valid(header)) {
79 goto fail;
80 }
81 pos += sizeof(EFI_COMMON_ERROR_RECORD_HEADER);
82 remaining -= sizeof(EFI_COMMON_ERROR_RECORD_HEADER);
83
84 if (remaining < sizeof(EFI_ERROR_SECTION_DESCRIPTOR)) {
85 cper_print_log(
86 "Invalid CPER file: Invalid section descriptor (section offset + length > size).\n");
87 goto fail;
88 }
89
90 //Create the header JSON object from the read bytes.
91 parent = json_object_new_object();
92 header_ir = cper_header_to_ir(header);
93
94 json_object_object_add(parent, "header", header_ir);
95
96 //Read the appropriate number of section descriptors & sections, and convert them into IR format.
97 section_descriptors_ir = json_object_new_array();
98 sections_ir = json_object_new_array();
99 for (int i = 0; i < header->SectionCount; i++) {
100 //Create the section descriptor.
101 if (remaining < sizeof(EFI_ERROR_SECTION_DESCRIPTOR)) {
102 cper_print_log(
103 "Invalid number of section headers: Header states %d sections, could not read section %d.\n",
104 header->SectionCount, i + 1);
105 goto fail;
106 }
107
108 EFI_ERROR_SECTION_DESCRIPTOR *section_descriptor;
109 section_descriptor = (EFI_ERROR_SECTION_DESCRIPTOR *)(pos);
110 pos += sizeof(EFI_ERROR_SECTION_DESCRIPTOR);
111 remaining -= sizeof(EFI_ERROR_SECTION_DESCRIPTOR);
112
113 if (section_descriptor->SectionOffset > size) {
114 cper_print_log(
115 "Invalid section descriptor: Section offset > size.\n");
116 goto fail;
117 }
118
119 if (section_descriptor->SectionLength <= 0) {
120 cper_print_log(
121 "Invalid section descriptor: Section length <= 0.\n");
122 goto fail;
123 }
124
125 if (section_descriptor->SectionOffset >
126 UINT_MAX - section_descriptor->SectionLength) {
127 cper_print_log(
128 "Invalid section descriptor: Section offset + length would overflow.\n");
129 goto fail;
130 }
131
132 if (section_descriptor->SectionOffset +
133 section_descriptor->SectionLength >
134 size) {
135 cper_print_log(
136 "Invalid section descriptor: Section offset + length > size.\n");
137 goto fail;
138 }
139
140 const unsigned char *section_begin =
141 cper_buf + section_descriptor->SectionOffset;
142 json_object *section_descriptor_ir =
143 cper_section_descriptor_to_ir(section_descriptor);
144
145 json_object_array_add(section_descriptors_ir,
146 section_descriptor_ir);
147
148 //Read the section itself.
149 json_object *section_ir = cper_buf_section_to_ir(
150 section_begin, section_descriptor->SectionLength,
151 section_descriptor);
152 json_object_array_add(sections_ir, section_ir);
153 }
154
155 //Add the header, section descriptors, and sections to a parent object.
156 json_object_object_add(parent, "sectionDescriptors",
157 section_descriptors_ir);
158 json_object_object_add(parent, "sections", sections_ir);
159
160 return parent;
161
162 fail:
163 json_object_put(sections_ir);
164 json_object_put(section_descriptors_ir);
165 json_object_put(parent);
166 cper_print_log("Failed to parse CPER file.\n");
167 return NULL;
168 }
169
170 //Reads a CPER log file at the given file location, and returns an intermediate
171 //JSON representation of this CPER record.
cper_to_ir(FILE * cper_file)172 json_object *cper_to_ir(FILE *cper_file)
173 {
174 //Ensure this is really a CPER log.
175 EFI_COMMON_ERROR_RECORD_HEADER header;
176 if (fread(&header, sizeof(EFI_COMMON_ERROR_RECORD_HEADER), 1,
177 cper_file) != 1) {
178 cper_print_log(
179 "Invalid CPER file: Invalid length (log too short).\n");
180 return NULL;
181 }
182
183 //Check if the header contains the magic bytes ("CPER").
184 if (header.SignatureStart != EFI_ERROR_RECORD_SIGNATURE_START) {
185 cper_print_log(
186 "Invalid CPER file: Invalid header (incorrect signature).\n");
187 return NULL;
188 }
189 fseek(cper_file, -sizeof(EFI_COMMON_ERROR_RECORD_HEADER), SEEK_CUR);
190 unsigned char *cper_buf = malloc(header.RecordLength);
191 int bytes_read = fread(cper_buf, 1, header.RecordLength, cper_file);
192 if (bytes_read < 0) {
193 cper_print_log("File read failed with code %u\n", bytes_read);
194 free(cper_buf);
195 return NULL;
196 }
197 if ((UINT32)bytes_read != header.RecordLength) {
198 int position = ftell(cper_file);
199 cper_print_log(
200 "File read failed file was %u bytes, expecting %u bytes from header.\n",
201 position, header.RecordLength);
202 free(cper_buf);
203 return NULL;
204 }
205
206 json_object *ir = cper_buf_to_ir(cper_buf, bytes_read);
207 free(cper_buf);
208 return ir;
209 }
210
cper_to_str_ir(FILE * cper_file)211 char *cper_to_str_ir(FILE *cper_file)
212 {
213 json_object *jobj = cper_to_ir(cper_file);
214 char *str = jobj ? strdup(json_object_to_json_string(jobj)) : NULL;
215
216 json_object_put(jobj);
217 return str;
218 }
219
cperbuf_to_str_ir(const unsigned char * cper,size_t size)220 char *cperbuf_to_str_ir(const unsigned char *cper, size_t size)
221 {
222 FILE *cper_file = fmemopen((void *)cper, size, "r");
223
224 return cper_file ? cper_to_str_ir(cper_file) : NULL;
225 }
226
227 //Converts a parsed CPER record header into intermediate JSON object format.
cper_header_to_ir(EFI_COMMON_ERROR_RECORD_HEADER * header)228 json_object *cper_header_to_ir(EFI_COMMON_ERROR_RECORD_HEADER *header)
229 {
230 json_object *header_ir = json_object_new_object();
231
232 //Revision/version information.
233 json_object *revision = revision_to_ir(header->Revision);
234 json_object_object_add(header_ir, "revision", revision);
235
236 //Section count.
237 add_int(header_ir, "sectionCount", header->SectionCount);
238
239 //Error severity (with interpreted string version).
240 json_object *error_severity = json_object_new_object();
241 add_uint(error_severity, "code", header->ErrorSeverity);
242 const char *severity_name = severity_to_string(header->ErrorSeverity);
243 add_string(error_severity, "name", severity_name);
244
245 json_object_object_add(header_ir, "severity", error_severity);
246
247 //Total length of the record (including headers) in bytes.
248 add_uint(header_ir, "recordLength", header->RecordLength);
249
250 //If a timestamp exists according to validation bits, then add it.
251 if (header->ValidationBits & 0x2) {
252 char timestamp_string[TIMESTAMP_LENGTH];
253 if (timestamp_to_string(timestamp_string, TIMESTAMP_LENGTH,
254 &header->TimeStamp) >= 0) {
255 add_string(header_ir, "timestamp", timestamp_string);
256
257 add_bool(header_ir, "timestampIsPrecise",
258 header->TimeStamp.Flag);
259 }
260 }
261
262 //If a platform ID exists according to the validation bits, then add it.
263 if (header->ValidationBits & 0x1) {
264 add_guid(header_ir, "platformID", &header->PlatformID);
265 }
266
267 //If a partition ID exists according to the validation bits, then add it.
268 if (header->ValidationBits & 0x4) {
269 add_guid(header_ir, "partitionID", &header->PartitionID);
270 }
271
272 //Creator ID of the header.
273 add_guid(header_ir, "creatorID", &header->CreatorID);
274 //Notification type for the header. Some defined types are available.
275 json_object *notification_type = json_object_new_object();
276 add_guid(notification_type, "guid", &header->NotificationType);
277
278 //Add the human readable notification type if possible.
279 const char *notification_type_readable = "Unknown";
280
281 EFI_GUID *guids[] = {
282 &gEfiEventNotificationTypeCmcGuid,
283 &gEfiEventNotificationTypeCpeGuid,
284 &gEfiEventNotificationTypeMceGuid,
285 &gEfiEventNotificationTypePcieGuid,
286 &gEfiEventNotificationTypeInitGuid,
287 &gEfiEventNotificationTypeNmiGuid,
288 &gEfiEventNotificationTypeBootGuid,
289 &gEfiEventNotificationTypeDmarGuid,
290 &gEfiEventNotificationTypeSeaGuid,
291 &gEfiEventNotificationTypeSeiGuid,
292 &gEfiEventNotificationTypePeiGuid,
293 &gEfiEventNotificationTypeCxlGuid,
294 };
295
296 const char *readable_names[] = {
297 "CMC", "CPE", "MCE", "PCIe", "INIT", "NMI",
298 "Boot", "DMAr", "SEA", "SEI", "PEI", "CXL Component"
299 };
300
301 int index = select_guid_from_list(&header->NotificationType, guids,
302 sizeof(guids) / sizeof(EFI_GUID *));
303 if (index < (int)(sizeof(readable_names) / sizeof(char *))) {
304 notification_type_readable = readable_names[index];
305 }
306
307 add_string(notification_type, "type", notification_type_readable);
308 json_object_object_add(header_ir, "notificationType",
309 notification_type);
310
311 //The record ID for this record, unique on a given system.
312 add_uint(header_ir, "recordID", header->RecordID);
313
314 //Flag for the record, and a human readable form.
315 json_object *flags = integer_to_readable_pair(
316 header->Flags,
317 sizeof(CPER_HEADER_FLAG_TYPES_KEYS) / sizeof(int),
318 CPER_HEADER_FLAG_TYPES_KEYS, CPER_HEADER_FLAG_TYPES_VALUES,
319 "Unknown");
320 json_object_object_add(header_ir, "flags", flags);
321
322 //Persistence information. Outside the scope of specification, so just a uint32 here.
323 add_uint(header_ir, "persistenceInfo", header->PersistenceInfo);
324 return header_ir;
325 }
326
327 //Converts the given EFI section descriptor into JSON IR format.
328 json_object *
cper_section_descriptor_to_ir(EFI_ERROR_SECTION_DESCRIPTOR * section_descriptor)329 cper_section_descriptor_to_ir(EFI_ERROR_SECTION_DESCRIPTOR *section_descriptor)
330 {
331 json_object *section_descriptor_ir = json_object_new_object();
332
333 //The offset of the section from the base of the record header, length.
334 add_uint(section_descriptor_ir, "sectionOffset",
335 section_descriptor->SectionOffset);
336 add_uint(section_descriptor_ir, "sectionLength",
337 section_descriptor->SectionLength);
338
339 //Revision.
340 json_object *revision = revision_to_ir(section_descriptor->Revision);
341 json_object_object_add(section_descriptor_ir, "revision", revision);
342
343 //Flag bits.
344 json_object *flags =
345 bitfield_to_ir(section_descriptor->SectionFlags, 8,
346 CPER_SECTION_DESCRIPTOR_FLAGS_BITFIELD_NAMES);
347 json_object_object_add(section_descriptor_ir, "flags", flags);
348
349 //Section type (GUID).
350 json_object *section_type = json_object_new_object();
351
352 add_guid(section_type, "data", §ion_descriptor->SectionType);
353 //Readable section type, if possible.
354 const char *section_type_readable = "Unknown";
355
356 CPER_SECTION_DEFINITION *section =
357 select_section_by_guid(§ion_descriptor->SectionType);
358 if (section != NULL) {
359 section_type_readable = section->ReadableName;
360 }
361
362 add_string(section_type, "type", section_type_readable);
363 json_object_object_add(section_descriptor_ir, "sectionType",
364 section_type);
365
366 //If validation bits indicate it exists, add FRU ID.
367 if (section_descriptor->SecValidMask & 0x1) {
368 add_guid(section_descriptor_ir, "fruID",
369 §ion_descriptor->FruId);
370 }
371
372 //If validation bits indicate it exists, add FRU text.
373 if ((section_descriptor->SecValidMask & 0x2) >> 1) {
374 add_untrusted_string(section_descriptor_ir, "fruText",
375 section_descriptor->FruString,
376 sizeof(section_descriptor->FruString));
377 }
378
379 //Section severity.
380 json_object *section_severity = json_object_new_object();
381 add_uint(section_severity, "code", section_descriptor->Severity);
382 add_string(section_severity, "name",
383 severity_to_string(section_descriptor->Severity));
384 json_object_object_add(section_descriptor_ir, "severity",
385 section_severity);
386
387 return section_descriptor_ir;
388 }
389
read_section(const unsigned char * cper_section_buf,size_t size,CPER_SECTION_DEFINITION * definition)390 json_object *read_section(const unsigned char *cper_section_buf, size_t size,
391 CPER_SECTION_DEFINITION *definition)
392 {
393 if (definition->ToIR == NULL) {
394 return NULL;
395 }
396 char *cper_description = NULL;
397
398 json_object *section_ir =
399 definition->ToIR(cper_section_buf, size, &cper_description);
400 if (section_ir == NULL) {
401 free(cper_description);
402 return NULL;
403 }
404 json_object *result = json_object_new_object();
405 if (cper_description != NULL) {
406 add_string(result, "message", cper_description);
407 free(cper_description);
408 }
409 json_object_object_add(result, definition->ShortName, section_ir);
410 return result;
411 }
412
select_section_by_guid(EFI_GUID * guid)413 CPER_SECTION_DEFINITION *select_section_by_guid(EFI_GUID *guid)
414 {
415 size_t i = 0;
416 for (; i < section_definitions_len; i++) {
417 if (guid_equal(guid, section_definitions[i].Guid)) {
418 break;
419 }
420 }
421 // It's unlikely fuzzing can reliably come up with a correct guid, given how
422 // much entropy there is. If we're in fuzzing mode, and if we haven't found
423 // a match, try to force a match so we get some coverage. Note, we still
424 // want coverage of the section failed to convert code, so treat index ==
425 // size as section failed to convert.
426 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
427 if (i == section_definitions_len) {
428 i = guid->Data1 % (section_definitions_len + 1);
429 }
430 #endif
431 if (i < section_definitions_len) {
432 return §ion_definitions[i];
433 }
434
435 return NULL;
436 }
437
438 //Converts the section described by a single given section descriptor.
cper_buf_section_to_ir(const void * cper_section_buf,size_t size,EFI_ERROR_SECTION_DESCRIPTOR * descriptor)439 json_object *cper_buf_section_to_ir(const void *cper_section_buf, size_t size,
440 EFI_ERROR_SECTION_DESCRIPTOR *descriptor)
441 {
442 if (descriptor->SectionLength > size) {
443 cper_print_log(
444 "Invalid CPER file: Invalid header (incorrect signature).\n");
445 return NULL;
446 }
447
448 //Parse section to IR based on GUID.
449 json_object *result = NULL;
450 json_object *section_ir = NULL;
451
452 CPER_SECTION_DEFINITION *section =
453 select_section_by_guid(&descriptor->SectionType);
454 if (section == NULL) {
455 cper_print_log("Unknown section type guid\n");
456 } else {
457 result = read_section(cper_section_buf, size, section);
458 }
459
460 //Was it an unknown GUID/failed read?
461 if (result == NULL) {
462 //Output the data as formatted base64.
463 section_ir = json_object_new_object();
464 add_binary_base64(section_ir, "data", cper_section_buf,
465 descriptor->SectionLength);
466
467 result = json_object_new_object();
468 json_object_object_add(result, "Unknown", section_ir);
469 }
470 if (result == NULL) {
471 cper_print_log("RETURNING NULL!! !!\n");
472 }
473 return result;
474 }
475
cper_buf_single_section_to_ir(const unsigned char * cper_buf,size_t size)476 json_object *cper_buf_single_section_to_ir(const unsigned char *cper_buf,
477 size_t size)
478 {
479 const unsigned char *cper_end;
480 const unsigned char *section_begin;
481 json_object *ir;
482
483 cper_end = cper_buf + size;
484
485 //Read the section descriptor out.
486 EFI_ERROR_SECTION_DESCRIPTOR *section_descriptor;
487 if (sizeof(EFI_ERROR_SECTION_DESCRIPTOR) > size) {
488 cper_print_log(
489 "Size of cper buffer was too small to read section descriptor %zu\n",
490 size);
491 return NULL;
492 }
493
494 ir = json_object_new_object();
495 section_descriptor = (EFI_ERROR_SECTION_DESCRIPTOR *)cper_buf;
496 //Convert the section descriptor to IR.
497 json_object *section_descriptor_ir =
498 cper_section_descriptor_to_ir(section_descriptor);
499 json_object_object_add(ir, "sectionDescriptor", section_descriptor_ir);
500 section_begin = cper_buf + section_descriptor->SectionOffset;
501
502 if (section_begin + section_descriptor->SectionLength > cper_end) {
503 json_object_put(ir);
504 //cper_print_log("Invalid CPER file: Invalid section descriptor (section offset + length > size).\n");
505 return NULL;
506 }
507
508 const unsigned char *section =
509 cper_buf + section_descriptor->SectionOffset;
510
511 //Parse the single section.
512 json_object *section_ir = cper_buf_section_to_ir(
513 section, section_descriptor->SectionLength, section_descriptor);
514 if (section_ir == NULL) {
515 cper_print_log("RETURNING NULL2!! !!\n");
516 }
517 json_object_object_add(ir, "section", section_ir);
518 return ir;
519 }
520
521 //Converts a single CPER section, without a header but with a section descriptor, to JSON.
cper_single_section_to_ir(FILE * cper_section_file)522 json_object *cper_single_section_to_ir(FILE *cper_section_file)
523 {
524 json_object *ir = json_object_new_object();
525
526 //Read the current file pointer location as base record position.
527 long base_pos = ftell(cper_section_file);
528
529 //Read the section descriptor out.
530 EFI_ERROR_SECTION_DESCRIPTOR section_descriptor;
531 if (fread(§ion_descriptor, sizeof(EFI_ERROR_SECTION_DESCRIPTOR), 1,
532 cper_section_file) != 1) {
533 cper_print_log(
534 "Failed to read section descriptor for CPER single section (fread() returned an unexpected value).\n");
535 json_object_put(ir);
536 return NULL;
537 }
538
539 //Convert the section descriptor to IR.
540 json_object *section_descriptor_ir =
541 cper_section_descriptor_to_ir(§ion_descriptor);
542 json_object_object_add(ir, "sectionDescriptor", section_descriptor_ir);
543
544 //Save our current position in the stream.
545 long position = ftell(cper_section_file);
546
547 //Read section as described by the section descriptor.
548 fseek(cper_section_file, base_pos + section_descriptor.SectionOffset,
549 SEEK_SET);
550 void *section = malloc(section_descriptor.SectionLength);
551 if (fread(section, section_descriptor.SectionLength, 1,
552 cper_section_file) != 1) {
553 cper_print_log(
554 "Section read failed: Could not read %u bytes from global offset %d.\n",
555 section_descriptor.SectionLength,
556 section_descriptor.SectionOffset);
557 json_object_put(ir);
558 free(section);
559 return NULL;
560 }
561
562 //Seek back to our original position.
563 fseek(cper_section_file, position, SEEK_SET);
564
565 //Parse the single section.
566 json_object *section_ir = cper_buf_section_to_ir(
567 section, section_descriptor.SectionLength, §ion_descriptor);
568 json_object_object_add(ir, "section", section_ir);
569 free(section);
570 return ir;
571 }
572
cperbuf_single_section_to_str_ir(const unsigned char * cper_section,size_t size)573 char *cperbuf_single_section_to_str_ir(const unsigned char *cper_section,
574 size_t size)
575 {
576 json_object *jobj = cper_buf_single_section_to_ir(cper_section, size);
577 char *str = jobj ? strdup(json_object_to_json_string(jobj)) : NULL;
578
579 json_object_put(jobj);
580 return str;
581 }
582