1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
/* Copyright 2020 IBM Corp. */
#include <skiboot.h>
#include <eventlog.h>
#include <eventlib.h>
#include <ibmtss/tssmarshal.h>
int load_eventlog(TpmLogMgr *logmgr, uint8_t *eventlog_ptr,
uint32_t eventlog_size)
{
TCG_PCR_EVENT2 *event2 = NULL;
TCG_PCR_EVENT *event = NULL;
uint8_t *log_ptr, *ptr;
uint32_t size;
int rc = 0;
event = zalloc(sizeof(TCG_PCR_EVENT));
if(!event){
rc = 1;
goto cleanup;
}
event2 = zalloc(sizeof(TCG_PCR_EVENT2));
if(!event2){
rc = 1;
goto cleanup;
}
logmgr->logMaxSize = eventlog_size;
logmgr->eventLogInMem = eventlog_ptr;
logmgr->logSize = 0;
log_ptr = logmgr->eventLogInMem;
size = sizeof(TCG_PCR_EVENT);
//first event in the log is a header
rc = TSS_EVENT_Line_LE_Unmarshal(event, &log_ptr, &size);
if(rc)
{
prlog(PR_INFO, "Couldn't read event log header event, rc=%d",
rc);
rc = 1;
goto cleanup;
}
//now iterate through all events
ptr = log_ptr;
do {
size = sizeof(TCG_PCR_EVENT2);
rc = TSS_EVENT2_Line_LE_Unmarshal(event2, &ptr, &size);
/* something went wrong in parsing (invalid values) or
* digest.count is 0 - which doesn't make sense - we stop.
*/
if (rc || event2->digests.count == 0 )
break;
log_ptr = ptr;
} while(1);
logmgr->logSize = log_ptr - logmgr->eventLogInMem;
logmgr->newEventPtr = log_ptr;
cleanup:
free(event);
free(event2);
return rc;
}
int add_to_eventlog(TpmLogMgr *logmgr, TCG_PCR_EVENT2 *event)
{
uint32_t size = sizeof(TCG_PCR_EVENT2), rc = 0;
uint16_t written = 0, ev_size =0;
/* Calling Marshal function with a NULL buffer to obtain the event size.
* It's a well known and safe pattern used in TSS code.
* Then check if an event that larger will fit in evenlog buffer, and
* only after success here marshal it to eventlog buffer pointed by
* logmgr->newEventPtr.
*/
TSS_EVENT2_Line_LE_Marshal(event, &ev_size, NULL, &size);
if(logmgr->logSize + ev_size > logmgr->logMaxSize){
return 1;
}
rc = TSS_EVENT2_Line_LE_Marshal(event, &written,
&(logmgr->newEventPtr), &size);
if(rc)
return rc;
logmgr->logSize += ev_size;
return rc;
}
int build_event(TCG_PCR_EVENT2 *event, TPMI_DH_PCR pcrHandle,
TPMI_ALG_HASH *hashes, uint8_t hashes_len,
const uint8_t **digests, uint32_t event_type,
const char* logmsg, uint32_t logmsg_len)
{
uint16_t alg_digest_size;
uint32_t size;
memset(event, 0, sizeof(TCG_PCR_EVENT2));
event->pcrIndex = pcrHandle;
event->eventType = event_type;
event->digests.count = hashes_len;
size = sizeof(TPMI_ALG_HASH);
for (int i=0; i < event->digests.count; i++){
event->digests.digests[i].hashAlg = hashes[i];
TSS_TPMI_ALG_HASH_Marshalu(hashes+i, &alg_digest_size, NULL, &size);
if (alg_digest_size == 0)
return 1;
memcpy(&(event->digests.digests[i].digest), digests[i],
strlen(digests[i]) > alg_digest_size ?
strlen(digests[i]) : alg_digest_size);
}
event->eventSize = logmsg_len;
memset(&(event->event), 0, sizeof(event->event));
memcpy(&(event->event), logmsg,
event->eventSize > TCG_EVENT_LEN_MAX ?
TCG_EVENT_LEN_MAX - 1: event->eventSize);
return 0;
}
|
