hc
2024-12-19 9370bb92b2d16684ee45cf24e879c93c509162da
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
// SPDX-License-Identifier: BSD-3-Clause
/*
 * Copyright (c) 2020, ARM Limited. All rights reserved.
 */
 
#include <inttypes.h>
#include <pta_system.h>
#include <string.h>
#include <ta_tpm_log.h>
#include <tee_internal_api.h>
 
#define LOG_SIZE        1024
 
static TEE_Result invoke_system_pta(uint32_t cmd_id, uint32_t param_types,
                   TEE_Param params[TEE_NUM_PARAMS])
{
   const TEE_UUID system_uuid = PTA_SYSTEM_UUID;
   TEE_TASessionHandle session = TEE_HANDLE_NULL;
   TEE_Result res = TEE_ERROR_GENERIC;
   uint32_t ret_origin = 0;
 
   res = TEE_OpenTASession(&system_uuid, TEE_TIMEOUT_INFINITE,
               0, NULL, &session, &ret_origin);
   if (res != TEE_SUCCESS)
       return res;
 
   res = TEE_InvokeTACommand(session, TEE_TIMEOUT_INFINITE,
                 cmd_id, param_types, params, &ret_origin);
 
   TEE_CloseTASession(session);
 
   return res;
}
 
/*
 * Test case for the use of right parameters.
 */
static TEE_Result test_with_right_parameters(void)
{
   unsigned char buf[LOG_SIZE] = { 0 };
   const uint32_t param_types = TEE_PARAM_TYPES(
                       TEE_PARAM_TYPE_MEMREF_OUTPUT,
                       TEE_PARAM_TYPE_NONE,
                       TEE_PARAM_TYPE_NONE,
                       TEE_PARAM_TYPE_NONE);
   TEE_Param params[TEE_NUM_PARAMS] = { 0 };
   uint32_t field = 0;
   unsigned char *digestptr = NULL;
   unsigned int i = 0;
 
   params[0].memref.buffer = (void *)buf;
   params[0].memref.size = LOG_SIZE;
 
   if (invoke_system_pta(PTA_SYSTEM_GET_TPM_EVENT_LOG,
                 param_types, params) == TEE_SUCCESS) {
       DMSG("Received %i bytes of event log", params[0].memref.size);
       DMSG("Parsing the event log header:");
 
       memcpy(&field, &buf[0], sizeof(uint32_t));
       DMSG("\tPCRIndex = 0x%" PRIx32, field);
 
       /*
        * PCR Index must be 0 on the header.
        * Ref. Section 5.3 of TCG EFI Protocol Specification.
        * Family 2.0 Level 00 Revision 00.13. March 30, 2016
        */
       if (field != 0) {
           EMSG("PCRIndex must be 0");
           return TEE_ERROR_GENERIC;
       }
 
       memcpy(&field, &buf[4], sizeof(uint32_t));
       DMSG("\tEventType = 0x%" PRIx32, field);
 
       /*
        * Event type must be EV_NO_ACTION on the header.
        * Ref. Section 5.3 of TCG EFI Protocol Specification.
        * Family 2.0 Level 00 Revision 00.13. March 30, 2016
        */
       if (field != 3) {
           EMSG("EventType must be 3 (EV_NO_ACTION)");
           return TEE_ERROR_GENERIC;
       }
 
       /*
        * Header digest must be formed of 20 bytes set to 0.
        * Ref. Section 5.3 of TCG EFI Protocol Specification.
        * Family 2.0 Level 00 Revision 00.12. March 30, 2016
        */
       digestptr = &buf[8];
       for (i = 0; i < 20; i++) {
           if (*(digestptr + i) != 0) {
               EMSG("Digest byte %i must be 0", i);
               return TEE_ERROR_GENERIC;
           }
       }
 
       DMSG("--> Digest value passed");
       return TEE_SUCCESS;
   }
   return TEE_ERROR_ACCESS_DENIED;
}
 
/*
 * Test case for short buffer.
 */
static TEE_Result test_short_buffer(void)
{
   unsigned char buf[LOG_SIZE] = { 0 };
   const uint32_t param_types = TEE_PARAM_TYPES(
                       TEE_PARAM_TYPE_MEMREF_OUTPUT,
                       TEE_PARAM_TYPE_NONE,
                       TEE_PARAM_TYPE_NONE,
                       TEE_PARAM_TYPE_NONE);
   TEE_Param params[TEE_NUM_PARAMS] = { 0 };
   unsigned int i = 0;
 
   params[0].memref.buffer = (void *)buf;
   params[0].memref.size = 1;
 
   if (invoke_system_pta(PTA_SYSTEM_GET_TPM_EVENT_LOG, param_types,
                 params) != TEE_ERROR_SHORT_BUFFER) {
       return TEE_ERROR_GENERIC;
   }
 
   for (i = 0; i < LOG_SIZE; i++) {
       if (buf[i] != 0) {
           EMSG("Buf is expected to be all zeroed");
           return TEE_ERROR_GENERIC;
       }
   }
 
   return TEE_SUCCESS;
}
 
/*
 * Trusted Application Entry Points
 */
 
/* Called each time a new instance is created */
TEE_Result TA_CreateEntryPoint(void)
{
   return TEE_SUCCESS;
}
 
/* Called each time an instance is destroyed */
void TA_DestroyEntryPoint(void)
{
}
 
/* Called each time a session is opened */
TEE_Result TA_OpenSessionEntryPoint(uint32_t nParamTypes __unused,
                   TEE_Param pParams[4] __unused,
                   void **ppSessionContext __unused)
{
   return TEE_SUCCESS;
}
 
/* Called each time a session is closed */
void TA_CloseSessionEntryPoint(void *pSessionContext __unused)
{
}
 
/* Called when a command is invoked */
TEE_Result TA_InvokeCommandEntryPoint(void *pSessionContext __unused,
                     uint32_t nCommandID,
                     uint32_t nParamTypes __unused,
                     TEE_Param pParams[4] __unused)
{
   switch (nCommandID) {
   case TA_TPM_TEST_GET_LOG:
       return test_with_right_parameters();
 
   case TA_TPM_TEST_SHORT_BUF:
       return test_short_buffer();
 
   default:
       return TEE_ERROR_BAD_PARAMETERS;
   }
}