1 /*
2 * SPDX-License-Identifier: BSD-2-Clause
3 * Copyright 2018-2019, Intel Corporation
4 */
5
6 #include <inttypes.h>
7 #include <limits.h>
8 #include <stdarg.h>
9 #include <stdbool.h>
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <string.h>
13
14 #include <setjmp.h>
15 #include <cmocka.h>
16
17 #include "tss2_tcti.h"
18 #include "tss2_tctildr.h"
19
20 #include "tss2-tcti/tctildr.h"
21 #include "tss2-tcti/tcti-common.h"
22
23 #define TEST_MAGIC 0x1234321
24 #define TEST_VERSION 2
25
26 #define UNUSED(var) (void)(var)
27 TSS2_RC
__wrap_tctildr_get_info(const char * name,const TSS2_TCTI_INFO ** info,void ** data)28 __wrap_tctildr_get_info (const char *name,
29 const TSS2_TCTI_INFO **info,
30 void **data)
31 {
32 TSS2_RC rc = mock_type (TSS2_RC);
33 if (rc == TSS2_RC_SUCCESS) {
34 *info = mock_type (TSS2_TCTI_INFO*);
35 *data = mock_type (void*);
36 }
37 return rc;
38 }
39 TSS2_RC
__wrap_tctildr_get_tcti(const char * name,const char * conf,TSS2_TCTI_CONTEXT ** tcti,void ** data)40 __wrap_tctildr_get_tcti (const char *name,
41 const char* conf,
42 TSS2_TCTI_CONTEXT **tcti,
43 void **data)
44 {
45 TSS2_RC rc = mock_type (TSS2_RC);
46 if (rc == TSS2_RC_SUCCESS) {
47 *tcti= mock_type (TSS2_TCTI_CONTEXT*);
48 *data = mock_type (void*);
49 }
50 return rc;
51 }
__wrap_tctildr_finalize_data(void ** data)52 void __wrap_tctildr_finalize_data (void **data) {}
53
54 static TSS2_RC
tctildr_mock_transmit(TSS2_TCTI_CONTEXT * context,size_t size,uint8_t const * command)55 tctildr_mock_transmit (TSS2_TCTI_CONTEXT *context,
56 size_t size,
57 uint8_t const *command)
58 {
59 return mock_type (TSS2_RC);
60 }
61 TSS2_RC
tctildr_mock_receive(TSS2_TCTI_CONTEXT * context,size_t * size,uint8_t * response,int32_t timeout)62 tctildr_mock_receive (TSS2_TCTI_CONTEXT *context,
63 size_t *size,
64 uint8_t *response,
65 int32_t timeout)
66 {
67 return mock_type (TSS2_RC);
68 }
69 TSS2_RC
tctildr_mock_cancel(TSS2_TCTI_CONTEXT * context)70 tctildr_mock_cancel (TSS2_TCTI_CONTEXT *context)
71 {
72 return mock_type (TSS2_RC);
73 }
74 TSS2_RC
tctildr_mock_get_poll_handles(TSS2_TCTI_CONTEXT * context,TSS2_TCTI_POLL_HANDLE * handles,size_t * num_handles)75 tctildr_mock_get_poll_handles (TSS2_TCTI_CONTEXT *context,
76 TSS2_TCTI_POLL_HANDLE *handles,
77 size_t *num_handles)
78 {
79 return mock_type (TSS2_RC);
80 }
81 TSS2_RC
tctildr_mock_set_locality(TSS2_TCTI_CONTEXT * context,uint8_t locality)82 tctildr_mock_set_locality (TSS2_TCTI_CONTEXT *context,
83 uint8_t locality)
84 {
85 return mock_type (TSS2_RC);
86 }
87 TSS2_RC
tctildr_mock_make_sticky(TSS2_TCTI_CONTEXT * context,TPM2_HANDLE * handle,uint8_t sticky)88 tctildr_mock_make_sticky (TSS2_TCTI_CONTEXT *context,
89 TPM2_HANDLE *handle,
90 uint8_t sticky)
91 {
92 return mock_type (TSS2_RC);
93 }
94 #define TSS2_TCTI_MOCK_CONTEXT TSS2_TCTI_CONTEXT_COMMON_V2
95 #define TEST_TCTI_HANDLE (TSS2_TCTI_LIBRARY_HANDLE)0x9827635
96 static int
tctildr_setup(void ** state)97 tctildr_setup (void **state)
98 {
99 TSS2_TCTILDR_CONTEXT *ldr_ctx;
100 TSS2_TCTI_MOCK_CONTEXT *tmp;
101
102 ldr_ctx = calloc (1, sizeof (TSS2_TCTILDR_CONTEXT));
103 TSS2_TCTI_MAGIC (ldr_ctx) = TCTILDR_MAGIC;
104 TSS2_TCTI_VERSION (ldr_ctx) = TCTI_VERSION;
105 TSS2_TCTI_TRANSMIT (ldr_ctx) = tctildr_transmit;
106 TSS2_TCTI_RECEIVE (ldr_ctx) = tctildr_receive;
107 TSS2_TCTI_CANCEL (ldr_ctx) = tctildr_cancel;
108 TSS2_TCTI_GET_POLL_HANDLES (ldr_ctx) = tctildr_get_poll_handles;
109 TSS2_TCTI_SET_LOCALITY (ldr_ctx) = tctildr_set_locality;
110 TSS2_TCTI_MAKE_STICKY (ldr_ctx) = tctildr_make_sticky;
111 ldr_ctx->library_handle = TEST_TCTI_HANDLE;
112
113 tmp = calloc (1, sizeof (TSS2_TCTI_MOCK_CONTEXT));
114 ldr_ctx->tcti = (TSS2_TCTI_CONTEXT*)tmp;
115 TSS2_TCTI_MAGIC (ldr_ctx->tcti) = TEST_MAGIC;
116 TSS2_TCTI_VERSION (ldr_ctx->tcti) = TEST_VERSION;
117 TSS2_TCTI_TRANSMIT (ldr_ctx->tcti) = tctildr_mock_transmit;
118 TSS2_TCTI_RECEIVE (ldr_ctx->tcti) = tctildr_mock_receive;
119 TSS2_TCTI_CANCEL (ldr_ctx->tcti) = tctildr_mock_cancel;
120 TSS2_TCTI_GET_POLL_HANDLES (ldr_ctx->tcti) = tctildr_mock_get_poll_handles;
121 TSS2_TCTI_SET_LOCALITY (ldr_ctx->tcti) = tctildr_mock_set_locality;
122 TSS2_TCTI_MAKE_STICKY (ldr_ctx->tcti) = tctildr_mock_make_sticky;
123
124 *state = ldr_ctx;
125
126 return 0;
127 }
128 static int
tctildr_teardown(void ** state)129 tctildr_teardown (void **state)
130 {
131 TSS2_TCTI_CONTEXT *context = (TSS2_TCTI_CONTEXT*)*state;
132
133 tctildr_finalize (context);
134
135 free (context);
136
137 return 0;
138 }
139 static void
tctildr_transmit_test(void ** state)140 tctildr_transmit_test (void **state)
141 {
142 TSS2_RC rc;
143 TSS2_TCTI_CONTEXT *context = (TSS2_TCTI_CONTEXT*)*state;
144 uint8_t buffer [64] = { 0 };
145 size_t size = sizeof (buffer);
146
147 will_return (tctildr_mock_transmit, TSS2_RC_SUCCESS);
148 rc = Tss2_Tcti_Transmit (context, size, buffer);
149 assert_int_equal (rc, TSS2_RC_SUCCESS);
150 }
151 static void
tctildr_transmit_null_test(void ** state)152 tctildr_transmit_null_test (void **state)
153 {
154 TSS2_RC rc;
155 uint8_t buffer [64] = { 0 };
156 size_t size = sizeof (buffer);
157
158 rc = tctildr_transmit (NULL, size, buffer);
159 assert_int_equal (rc, TSS2_TCTI_RC_BAD_CONTEXT);
160 }
161 static void
tctildr_receive_test(void ** state)162 tctildr_receive_test (void **state)
163 {
164 TSS2_RC rc;
165 TSS2_TCTI_CONTEXT *context = (TSS2_TCTI_CONTEXT*)*state;
166 uint8_t buffer [64] = { 0 };
167 size_t size = sizeof (buffer);
168 int32_t timeout = TSS2_TCTI_TIMEOUT_BLOCK;
169
170 will_return (tctildr_mock_receive, TSS2_RC_SUCCESS);
171 rc = Tss2_Tcti_Receive (context, &size, buffer, timeout);
172 assert_int_equal (rc, TSS2_RC_SUCCESS);
173 }
174 static void
tctildr_receive_null_test(void ** state)175 tctildr_receive_null_test (void **state)
176 {
177 TSS2_RC rc;
178 uint8_t buffer [64] = { 0 };
179 size_t size = sizeof (buffer);
180 int32_t timeout = TSS2_TCTI_TIMEOUT_BLOCK;
181
182 rc = tctildr_receive (NULL, &size, buffer, timeout);
183 assert_int_equal (rc, TSS2_TCTI_RC_BAD_CONTEXT);
184 }
185 static void
tctildr_cancel_test(void ** state)186 tctildr_cancel_test (void **state)
187 {
188 TSS2_RC rc;
189 TSS2_TCTI_CONTEXT *context = (TSS2_TCTI_CONTEXT*)*state;
190
191 will_return (tctildr_mock_cancel, TSS2_RC_SUCCESS);
192 rc = Tss2_Tcti_Cancel (context);
193 assert_int_equal (rc, TSS2_RC_SUCCESS);
194 }
195 static void
tctildr_cancel_null_test(void ** state)196 tctildr_cancel_null_test (void **state)
197 {
198 TSS2_RC rc;
199 UNUSED (state);
200
201 rc = tctildr_cancel (NULL);
202 assert_int_equal (rc, TSS2_TCTI_RC_BAD_CONTEXT);
203 }
204 #define TEST_NUM_HANDLES 3
205 static void
tctildr_get_poll_handles_test(void ** state)206 tctildr_get_poll_handles_test (void **state)
207 {
208 TSS2_RC rc;
209 TSS2_TCTI_CONTEXT *context = (TSS2_TCTI_CONTEXT*)*state;
210 TSS2_TCTI_POLL_HANDLE handles [TEST_NUM_HANDLES] = { 0 };
211 size_t num_handles = sizeof (handles);
212
213 will_return (tctildr_mock_get_poll_handles, TSS2_RC_SUCCESS);
214 rc = Tss2_Tcti_GetPollHandles (context, handles, &num_handles);
215 assert_int_equal (rc, TSS2_RC_SUCCESS);
216 }
217 static void
tctildr_get_poll_handles_null_test(void ** state)218 tctildr_get_poll_handles_null_test (void **state)
219 {
220 TSS2_RC rc;
221 TSS2_TCTI_POLL_HANDLE handles [TEST_NUM_HANDLES] = { 0 };
222 size_t num_handles = sizeof (handles);
223 UNUSED (state);
224
225 rc = tctildr_get_poll_handles (NULL, handles, &num_handles);
226 assert_int_equal (rc, TSS2_TCTI_RC_BAD_CONTEXT);
227 }
228 static void
tctildr_set_locality_test(void ** state)229 tctildr_set_locality_test (void **state)
230 {
231 TSS2_RC rc;
232 TSS2_TCTI_CONTEXT *context = (TSS2_TCTI_CONTEXT*)*state;
233
234 will_return (tctildr_mock_set_locality, TSS2_RC_SUCCESS);
235 rc = Tss2_Tcti_SetLocality (context, 1);
236 assert_int_equal (rc, TSS2_RC_SUCCESS);
237 }
238 static void
tctildr_set_locality_null_test(void ** state)239 tctildr_set_locality_null_test (void **state)
240 {
241 TSS2_RC rc;
242 UNUSED (state);
243
244 rc = tctildr_set_locality (NULL, 1);
245 assert_int_equal (rc, TSS2_TCTI_RC_BAD_CONTEXT);
246 }
247 #define TEST_HANDLE 0x1
248 static void
tctildr_make_sticky_test(void ** state)249 tctildr_make_sticky_test (void **state)
250 {
251 TSS2_RC rc;
252 TSS2_TCTI_CONTEXT *context = (TSS2_TCTI_CONTEXT*)*state;
253 TPM2_HANDLE handle = TEST_HANDLE;
254
255 will_return (tctildr_mock_make_sticky, TSS2_RC_SUCCESS);
256 rc = Tss2_Tcti_MakeSticky (context, &handle, TPM2_YES);
257 assert_int_equal (rc, TSS2_RC_SUCCESS);
258 }
259 static void
tctildr_make_sticky_null_test(void ** state)260 tctildr_make_sticky_null_test (void **state)
261 {
262 TSS2_RC rc;
263 TPM2_HANDLE handle = TEST_HANDLE;
264 UNUSED (state);
265
266 rc = tctildr_make_sticky (NULL, &handle, TPM2_YES);
267 assert_int_equal (rc, TSS2_TCTI_RC_BAD_CONTEXT);
268 }
269 /*
270 * This test covers the 'sanity test' path in the tctildr finalize
271 * function. There's not really a way to check whether or not this test
272 * passes / does what's intended beyond checking the report from the code
273 * coverage tool.
274 */
275 static void
tctildr_finalize_null_ctx_test(void ** state)276 tctildr_finalize_null_ctx_test (void **state)
277 {
278 TSS2_TCTI_CONTEXT *context = NULL;
279 tctildr_finalize (context);
280 assert_true (true);
281 }
282 int
main(int argc,char * arvg[])283 main (int argc, char* arvg[])
284 {
285 const struct CMUnitTest tests[] = {
286 cmocka_unit_test_setup_teardown (tctildr_transmit_test,
287 tctildr_setup,
288 tctildr_teardown),
289 cmocka_unit_test_setup_teardown (tctildr_transmit_null_test,
290 tctildr_setup,
291 tctildr_teardown),
292 cmocka_unit_test_setup_teardown (tctildr_receive_test,
293 tctildr_setup,
294 tctildr_teardown),
295 cmocka_unit_test_setup_teardown (tctildr_receive_null_test,
296 tctildr_setup,
297 tctildr_teardown),
298 cmocka_unit_test_setup_teardown (tctildr_cancel_test,
299 tctildr_setup,
300 tctildr_teardown),
301 cmocka_unit_test_setup_teardown (tctildr_cancel_null_test,
302 tctildr_setup,
303 tctildr_teardown),
304 cmocka_unit_test_setup_teardown (tctildr_get_poll_handles_test,
305 tctildr_setup,
306 tctildr_teardown),
307 cmocka_unit_test_setup_teardown (tctildr_get_poll_handles_null_test,
308 tctildr_setup,
309 tctildr_teardown),
310 cmocka_unit_test_setup_teardown (tctildr_set_locality_test,
311 tctildr_setup,
312 tctildr_teardown),
313 cmocka_unit_test_setup_teardown (tctildr_set_locality_null_test,
314 tctildr_setup,
315 tctildr_teardown),
316 cmocka_unit_test_setup_teardown (tctildr_make_sticky_test,
317 tctildr_setup,
318 tctildr_teardown),
319 cmocka_unit_test_setup_teardown (tctildr_make_sticky_null_test,
320 tctildr_setup,
321 tctildr_teardown),
322 cmocka_unit_test (tctildr_finalize_null_ctx_test),
323 };
324 return cmocka_run_group_tests (tests, NULL, NULL);
325 }
326