1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /***********************************************************************
3 * Copyright (c) 2017-2018, Intel Corporation
4 *
5 * All rights reserved.
6 ***********************************************************************/
7 #ifdef HAVE_CONFIG_H
8 #include <config.h>
9 #endif
10
11 #include <stdarg.h>
12 #include <stddef.h>
13 #include <setjmp.h>
14 #include <cmocka.h>
15 #include <stdio.h>
16 #include "tss2_mu.h"
17 #include "util/tss2_endian.h"
18
19 /*
20 * Success case
21 */
22 static void
tpma_marshal_success(void ** state)23 tpma_marshal_success(void **state)
24 {
25 TPMA_ALGORITHM alg = {0}, *ptr;
26 TPMA_SESSION session = {0}, *ptr2;
27 uint8_t buffer[sizeof(alg)] = { 0 };
28 size_t buffer_size = sizeof(buffer);
29 uint8_t buffer2[sizeof(session)] = { 0 };
30 size_t buffer_size2 = sizeof(buffer2);
31 uint32_t alg_expected = HOST_TO_BE_32(TPMA_ALGORITHM_ASYMMETRIC | TPMA_ALGORITHM_SIGNING);
32 uint8_t session_expected = TPMA_SESSION_AUDIT | TPMA_SESSION_AUDITRESET | TPMA_SESSION_DECRYPT;
33 TSS2_RC rc;
34
35 alg |= TPMA_ALGORITHM_ASYMMETRIC;
36 alg |= TPMA_ALGORITHM_SIGNING;
37 ptr = (TPMA_ALGORITHM *)buffer;
38
39 rc = Tss2_MU_TPMA_ALGORITHM_Marshal(alg, buffer, buffer_size, NULL);
40 assert_int_equal (rc, TSS2_RC_SUCCESS);
41 assert_int_equal (*ptr, alg_expected);
42
43 session |= TPMA_SESSION_AUDIT;
44 session |= TPMA_SESSION_DECRYPT;
45 session |= TPMA_SESSION_AUDITRESET;
46 ptr2 = (TPMA_SESSION *)buffer2;
47
48 rc = Tss2_MU_TPMA_SESSION_Marshal(session, buffer2, buffer_size2, NULL);
49 assert_int_equal (rc, TSS2_RC_SUCCESS);
50 assert_int_equal (*ptr2, session_expected);
51 }
52
53 /*
54 * Success case with a valid offset
55 */
56 static void
tpma_marshal_success_offset(void ** state)57 tpma_marshal_success_offset(void **state)
58 {
59 TPMA_ALGORITHM alg = {0}, *ptr;
60 TPMA_SESSION session = {0}, *ptr2;
61 uint8_t buffer[sizeof(alg) + 10] = { 0 };
62 size_t buffer_size = sizeof(buffer);
63 uint8_t buffer2[sizeof(session) + 14] = { 0 };
64 size_t buffer_size2 = sizeof(buffer2);
65 size_t offset = 10;
66 uint32_t alg_expected = HOST_TO_BE_32(TPMA_ALGORITHM_ASYMMETRIC | TPMA_ALGORITHM_SIGNING);
67 uint8_t session_expected = TPMA_SESSION_AUDIT | TPMA_SESSION_AUDITRESET | TPMA_SESSION_DECRYPT;
68 TSS2_RC rc;
69
70 alg |= TPMA_ALGORITHM_ASYMMETRIC;
71 alg |= TPMA_ALGORITHM_SIGNING;
72 ptr = (TPMA_ALGORITHM *)&buffer[10];
73
74 rc = Tss2_MU_TPMA_ALGORITHM_Marshal(alg, buffer, buffer_size, &offset);
75 assert_int_equal (rc, TSS2_RC_SUCCESS);
76 assert_int_equal (*ptr, alg_expected);
77 assert_int_equal (offset, sizeof (buffer));
78
79 session |= TPMA_SESSION_AUDIT;
80 session |= TPMA_SESSION_DECRYPT;
81 session |= TPMA_SESSION_AUDITRESET;
82 ptr2 = (TPMA_SESSION *)&buffer2[14];
83
84 rc = Tss2_MU_TPMA_SESSION_Marshal(session, buffer2, buffer_size2, &offset);
85 assert_int_equal (rc, TSS2_RC_SUCCESS);
86 assert_int_equal (*ptr2, session_expected);
87 assert_int_equal (offset, sizeof (buffer2));
88 }
89
90 /*
91 * Success case with a null buffer
92 */
93 static void
tpma_marshal_buffer_null_with_offset(void ** state)94 tpma_marshal_buffer_null_with_offset(void **state)
95 {
96 TPMA_ALGORITHM alg = {0};
97 TPMA_SESSION session = {0};
98 size_t offset = 100;
99 TSS2_RC rc;
100
101 alg |= TPMA_ALGORITHM_ASYMMETRIC;
102 alg |= TPMA_ALGORITHM_SIGNING;
103
104 rc = Tss2_MU_TPMA_ALGORITHM_Marshal(alg, NULL, sizeof(alg), &offset);
105 assert_int_equal (rc, TSS2_RC_SUCCESS);
106 assert_int_equal (offset, 100 + sizeof(alg));
107
108 session |= TPMA_SESSION_AUDIT;
109 session |= TPMA_SESSION_DECRYPT;
110 session |= TPMA_SESSION_AUDITRESET;
111 offset = 100;
112
113 rc = Tss2_MU_TPMA_SESSION_Marshal(session, NULL, sizeof(session), &offset);
114 assert_int_equal (rc, TSS2_RC_SUCCESS);
115 assert_int_equal (offset, 100 + sizeof(session));
116 }
117
118 /*
119 * Invalid case with a null buffer and a null offset
120 */
121 static void
tpma_marshal_buffer_null_offset_null(void ** state)122 tpma_marshal_buffer_null_offset_null(void **state)
123 {
124 TPMA_ALGORITHM alg = {0};
125 TPMA_SESSION session = {0};
126 TSS2_RC rc;
127
128 alg |= TPMA_ALGORITHM_ASYMMETRIC;
129 alg |= TPMA_ALGORITHM_SIGNING;
130
131 rc = Tss2_MU_TPMA_ALGORITHM_Marshal(alg, NULL, sizeof(alg), NULL);
132 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
133
134 session |= TPMA_SESSION_AUDIT;
135 session |= TPMA_SESSION_DECRYPT;
136 session |= TPMA_SESSION_AUDITRESET;
137
138 rc = Tss2_MU_TPMA_SESSION_Marshal(session, NULL, sizeof(session), NULL);
139 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
140 }
141
142 /*
143 * Invalid case with not big enough buffer
144 */
145 static void
tpma_marshal_buffer_size_lt_data_nad_lt_offset(void ** state)146 tpma_marshal_buffer_size_lt_data_nad_lt_offset(void **state)
147 {
148 TPMA_ALGORITHM alg = {0};
149 TPMA_SESSION session = {0};
150 uint8_t buffer[sizeof(alg)] = { 0 };
151 size_t buffer_size = sizeof(buffer);
152 uint8_t buffer2[sizeof(session)] = { 0 };
153 size_t buffer_size2 = sizeof(buffer2);
154 size_t offset = 2;
155 TSS2_RC rc;
156
157 alg |= TPMA_ALGORITHM_ASYMMETRIC;
158 alg |= TPMA_ALGORITHM_SIGNING;
159
160 rc = Tss2_MU_TPMA_ALGORITHM_Marshal(alg, buffer, buffer_size, &offset);
161 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
162 assert_int_equal (offset, 2);
163
164 session |= TPMA_SESSION_AUDIT;
165 session |= TPMA_SESSION_DECRYPT;
166 session |= TPMA_SESSION_AUDITRESET;
167
168 rc = Tss2_MU_TPMA_SESSION_Marshal(session, buffer2, buffer_size2, &offset);
169 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
170 assert_int_equal (offset, 2);
171 }
172
173 /*
174 * Success case
175 */
176 static void
tpma_unmarshal_success(void ** state)177 tpma_unmarshal_success(void **state)
178 {
179 TPMA_ALGORITHM alg = {0};
180 TPMA_SESSION session = {0};
181 uint8_t buffer[sizeof(alg) + sizeof(session)] = { 0 };
182 size_t buffer_size = sizeof(buffer);
183 size_t offset = 0;
184 uint32_t alg_expected = HOST_TO_BE_32(TPMA_ALGORITHM_ASYMMETRIC | TPMA_ALGORITHM_SIGNING);
185 uint8_t session_expected = TPMA_SESSION_AUDIT | TPMA_SESSION_AUDITRESET | TPMA_SESSION_DECRYPT;
186 uint32_t *ptr;
187 uint8_t *ptr2;
188 TSS2_RC rc;
189
190 ptr = (uint32_t *)buffer;
191 ptr2 = (uint8_t *)ptr + 4;
192
193 *ptr = alg_expected;
194 *ptr2 = session_expected;
195
196 rc = Tss2_MU_TPMA_ALGORITHM_Unmarshal(buffer, buffer_size, &offset, &alg);
197 assert_int_equal (rc, TSS2_RC_SUCCESS);
198 assert_int_equal (alg, BE_TO_HOST_32(alg_expected));
199 assert_int_equal (offset, 4);
200
201
202 rc = Tss2_MU_TPMA_SESSION_Unmarshal(buffer, buffer_size, &offset, &session);
203 assert_int_equal (rc, TSS2_RC_SUCCESS);
204 assert_int_equal (session, session_expected);
205 assert_int_equal (offset, 5);
206 }
207
208 /*
209 * Invalid test case with buffer null and dest null
210 */
211 static void
tpma_unmarshal_dest_null_buff_null(void ** state)212 tpma_unmarshal_dest_null_buff_null(void **state)
213 {
214 size_t offset = 0;
215 TSS2_RC rc;
216
217 rc = Tss2_MU_TPMA_ALGORITHM_Unmarshal(NULL, 20, &offset, NULL);
218 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
219 assert_int_equal (offset, 0);
220
221
222 rc = Tss2_MU_TPMA_SESSION_Unmarshal(NULL, 20, &offset, NULL);
223 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
224 assert_int_equal (offset, 0);
225 }
226
227 /*
228 * Invalid test case with offset null and dest null
229 */
230 static void
tpma_unmarshal_buffer_null_offset_null(void ** state)231 tpma_unmarshal_buffer_null_offset_null(void **state)
232 {
233 TPMA_ALGORITHM alg = {0};
234 TPMA_SESSION session = {0};
235 uint8_t buffer[sizeof(alg) + sizeof(session)] = { 0 };
236 size_t buffer_size = sizeof(buffer);
237 TSS2_RC rc;
238
239 rc = Tss2_MU_TPMA_ALGORITHM_Unmarshal(buffer, buffer_size, NULL, NULL);
240 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
241
242
243 rc = Tss2_MU_TPMA_SESSION_Unmarshal(buffer, buffer_size, NULL, NULL);
244 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
245 }
246 /*
247 * Test case ensures the offset is updated when dest is NULL
248 * and offset is valid
249 */
250 static void
tpma_unmarshal_dest_null_offset_valid(void ** state)251 tpma_unmarshal_dest_null_offset_valid(void **state)
252 {
253 TPMA_SESSION session = {0};
254 uint8_t buffer[sizeof(TPMA_ALGORITHM) + sizeof(session)] = { 0 };
255 size_t buffer_size = sizeof(buffer);
256 size_t offset = 0;
257 uint32_t alg_expected = HOST_TO_BE_32(TPMA_ALGORITHM_ASYMMETRIC | TPMA_ALGORITHM_SIGNING);
258 uint8_t session_expected = TPMA_SESSION_AUDIT | TPMA_SESSION_AUDITRESET | TPMA_SESSION_DECRYPT;
259 uint32_t *ptr;
260 uint8_t *ptr2;
261 TSS2_RC rc;
262
263 ptr = (uint32_t *)buffer;
264 ptr2 = (uint8_t *)ptr + 4;
265
266 *ptr = alg_expected;
267 *ptr2 = session_expected;
268
269 rc = Tss2_MU_TPMA_ALGORITHM_Unmarshal(buffer, buffer_size, &offset, NULL);
270 assert_int_equal (rc, TSS2_RC_SUCCESS);
271 assert_int_equal (offset, sizeof(TPMA_ALGORITHM));
272
273 rc = Tss2_MU_TPMA_SESSION_Unmarshal(buffer, buffer_size, &offset, NULL);
274 assert_int_equal (rc, TSS2_RC_SUCCESS);
275 assert_int_equal (offset, sizeof(buffer));
276 }
277 /*
278 * Invalid case with not big enough buffer
279 */
280 static void
tpma_unmarshal_buffer_size_lt_data_nad_lt_offset(void ** state)281 tpma_unmarshal_buffer_size_lt_data_nad_lt_offset(void **state)
282 {
283 TPMA_ALGORITHM alg = {0};
284 TPMA_SESSION session = {0};
285 uint8_t buffer[sizeof(alg) + sizeof(session)] = { 0 };
286 size_t offset = 1;
287 TSS2_RC rc;
288
289 alg |= TPMA_ALGORITHM_ASYMMETRIC;
290 alg |= TPMA_ALGORITHM_SIGNING;
291
292 rc = Tss2_MU_TPMA_ALGORITHM_Unmarshal(buffer, sizeof(alg), &offset, &alg);
293 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
294 assert_int_equal (offset, 1);
295
296 session |= TPMA_SESSION_AUDIT;
297 session |= TPMA_SESSION_DECRYPT;
298 session |= TPMA_SESSION_AUDITRESET;
299
300 rc = Tss2_MU_TPMA_SESSION_Unmarshal(buffer, 1, &offset, &session);
301 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
302 assert_int_equal (offset, 1);
303 }
304
main(void)305 int main(void) {
306 const struct CMUnitTest tests[] = {
307 cmocka_unit_test (tpma_marshal_success),
308 cmocka_unit_test (tpma_marshal_success_offset),
309 cmocka_unit_test (tpma_marshal_buffer_null_with_offset),
310 cmocka_unit_test (tpma_marshal_buffer_null_offset_null),
311 cmocka_unit_test (tpma_marshal_buffer_size_lt_data_nad_lt_offset),
312 cmocka_unit_test (tpma_unmarshal_success),
313 cmocka_unit_test (tpma_unmarshal_dest_null_buff_null),
314 cmocka_unit_test (tpma_unmarshal_buffer_null_offset_null),
315 cmocka_unit_test (tpma_unmarshal_dest_null_offset_valid),
316 cmocka_unit_test (tpma_unmarshal_buffer_size_lt_data_nad_lt_offset),
317 };
318 return cmocka_run_group_tests(tests, NULL, NULL);
319 }
320