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 <stdlib.h>
12 #include <stdio.h>
13
14 #include <setjmp.h>
15 #include <cmocka.h>
16
17 #include "tss2_mu.h"
18
19 /*
20 * Test case for successful UINT8 marshaling with NULL offset.
21 */
22 void
UINT8_marshal_success(void ** state)23 UINT8_marshal_success (void **state)
24 {
25 UINT8 src = 0x1a;
26 uint8_t buffer [1] = { 0 };
27 size_t buffer_size = sizeof (buffer);
28 TSS2_RC rc;
29
30 rc = Tss2_MU_UINT8_Marshal (src, buffer, buffer_size, NULL);
31
32 assert_int_equal (rc, TSS2_RC_SUCCESS);
33 assert_int_equal (src, buffer [0]);
34 }
35 /*
36 * Test case for successful UINT8 marshaling with offset.
37 */
38 void
UINT8_marshal_success_offset(void ** state)39 UINT8_marshal_success_offset (void **state)
40 {
41 UINT8 src = 0x1a;
42 uint8_t buffer [2] = { 0 };
43 size_t buffer_size = sizeof (buffer);
44 size_t offset = 1;
45 TSS2_RC rc;
46
47 rc = Tss2_MU_UINT8_Marshal (src, buffer, buffer_size, &offset);
48
49 assert_int_equal (rc, TSS2_RC_SUCCESS);
50 assert_int_equal (src, buffer [1]);
51 assert_int_equal (offset, sizeof (buffer));
52 }
53 /*
54 * Test case passing NULL buffer and non-NULL offset. Test to be sure offset
55 * is updated to the size of the src parameter.
56 */
57 void
UINT8_marshal_buffer_null_with_offset(void ** state)58 UINT8_marshal_buffer_null_with_offset (void **state)
59 {
60 UINT8 src = 0x1a;
61 size_t offset = 100;
62 TSS2_RC rc;
63
64 rc = Tss2_MU_UINT8_Marshal (src, NULL, 2, &offset);
65
66 assert_int_equal (rc, TSS2_RC_SUCCESS);
67 assert_int_equal (offset, 100 + sizeof (src));
68 }
69 /*
70 * Test case passing NULL buffer and NULL offset. This
71 */
72 void
UINT8_marshal_buffer_null_offset_null(void ** state)73 UINT8_marshal_buffer_null_offset_null (void **state)
74 {
75 UINT8 src = 0x1a;
76 TSS2_RC rc;
77
78 rc = Tss2_MU_UINT8_Marshal (src, NULL, sizeof (src), NULL);
79
80 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
81 }
82 /*
83 * Test failing case where buffer_size - offset (size of available space
84 * in buffer) is less than sizeof (UINT8). Also check offset is unchanged.
85 */
86 void
UINT8_marshal_buffer_size_lt_data(void ** state)87 UINT8_marshal_buffer_size_lt_data (void **state)
88 {
89 UINT8 src = 0x1a;
90 uint8_t buffer [2] = { 0 };
91 size_t offset = 2;
92 TSS2_RC rc;
93
94 rc = Tss2_MU_UINT8_Marshal (src, buffer, sizeof (src), &offset);
95
96 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
97 assert_int_equal (offset, 2);
98 }
99 /*
100 * Test failing case where buffer_size is less than the offset value.
101 * This should return INSUFFICIENT_BUFFER and the offset should be unchanged.
102 */
103 void
UINT8_marshal_buffer_size_lt_offset(void ** state)104 UINT8_marshal_buffer_size_lt_offset (void **state)
105 {
106 UINT8 src = 0x1a;
107 uint8_t buffer [2] = { 0 };
108 size_t buffer_size = sizeof (buffer);
109 size_t offset = sizeof (buffer) + 1;
110 TSS2_RC rc;
111
112 rc = Tss2_MU_UINT8_Marshal (src, buffer, buffer_size, &offset);
113
114 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
115 assert_int_equal (offset, sizeof (buffer) + 1);
116 }
117 /*
118 * Test case for successful UINT8 unmarshaling.
119 */
120 void
UINT8_unmarshal_success(void ** state)121 UINT8_unmarshal_success (void **state)
122 {
123 uint8_t buffer [1] = { 0xa1 };
124 uint8_t buffer_size = sizeof (buffer);
125 UINT8 dest = 0;
126 TSS2_RC rc;
127
128 rc = Tss2_MU_UINT8_Unmarshal (buffer, buffer_size, NULL, &dest);
129
130 assert_int_equal (rc, TSS2_RC_SUCCESS);
131 assert_int_equal (buffer [0], dest);
132 }
133 /*
134 * Test case for successful UINT8 unmarshaling with offset.
135 */
136 void
UINT8_unmarshal_success_offset(void ** state)137 UINT8_unmarshal_success_offset (void **state)
138 {
139 UINT8 dest = 0;
140 uint8_t buffer [2] = { 0x00, 0xa1 };
141 size_t buffer_size = sizeof (buffer);
142 size_t offset = 1;
143 TSS2_RC rc;
144
145 rc = Tss2_MU_UINT8_Unmarshal (buffer, buffer_size, &offset, &dest);
146
147 assert_int_equal (rc, TSS2_RC_SUCCESS);
148 assert_int_equal (buffer [1], dest);
149 assert_int_equal (offset, 2);
150 }
151 /*
152 * Test case ensures a NULL buffer parameter produces a BAD_REFERENCE RC.
153 */
154 void
UINT8_unmarshal_buffer_null(void ** state)155 UINT8_unmarshal_buffer_null (void **state)
156 {
157 TSS2_RC rc;
158
159 rc = Tss2_MU_UINT8_Unmarshal (NULL, 1, NULL, NULL);
160
161 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
162 }
163 /*
164 * Test case ensures a NULL dest and offset parameters produce an
165 * INSUFFICIENT_BUFFER RC.
166 */
167 void
UINT8_unmarshal_dest_null(void ** state)168 UINT8_unmarshal_dest_null (void **state)
169 {
170 uint8_t buffer [1];
171 TSS2_RC rc;
172
173 rc = Tss2_MU_UINT8_Unmarshal (buffer, sizeof (buffer), NULL, NULL);
174
175 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
176 }
177 /*
178 * Test case ensures the offset is updated when dest is NULL
179 * and offset is valid
180 */
181 void
UINT8_unmarshal_dest_null_offset_valid(void ** state)182 UINT8_unmarshal_dest_null_offset_valid (void **state)
183 {
184 uint8_t buffer [2];
185 size_t offset = 1;
186 TSS2_RC rc;
187
188 rc = Tss2_MU_UINT8_Unmarshal (buffer, sizeof (buffer), &offset, NULL);
189
190 assert_int_equal (rc, TSS2_RC_SUCCESS);
191 assert_int_equal (offset, 2);
192 }
193
194 /*
195 * Test case ensures that INSUFFICIENT_BUFFER is returned when buffer_size
196 * is less than the provided offset.
197 */
198 void
UINT8_unmarshal_buffer_size_lt_offset(void ** state)199 UINT8_unmarshal_buffer_size_lt_offset (void **state)
200 {
201 UINT8 dest = 0;
202 uint8_t buffer [1];
203 size_t offset = sizeof (buffer) + 1;
204 TSS2_RC rc;
205
206 rc = Tss2_MU_UINT8_Unmarshal (buffer, sizeof (buffer), &offset, &dest);
207
208 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
209 assert_int_equal (offset, sizeof (buffer) + 1);
210 assert_int_equal (dest, 0);
211 }
212 /*
213 * Test case ensures that INSUFFICIENT_BUFFER is returned when buffer_size -
214 * local_offset is less than dest (the destination type).
215 */
216 void
UINT8_unmarshal_buffer_size_lt_dest(void ** state)217 UINT8_unmarshal_buffer_size_lt_dest (void **state)
218 {
219 UINT8 dest = 0;
220 uint8_t buffer [1];
221 size_t offset = sizeof (buffer);
222 TSS2_RC rc;
223
224 rc = Tss2_MU_UINT8_Unmarshal (buffer, sizeof (buffer), &offset, &dest);
225
226 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
227 assert_int_equal (offset, sizeof (buffer));
228 assert_int_equal (dest, 0);
229 }
230 int
main(void)231 main (void)
232 {
233 const struct CMUnitTest tests [] = {
234 cmocka_unit_test (UINT8_marshal_success),
235 cmocka_unit_test (UINT8_marshal_success_offset),
236 cmocka_unit_test (UINT8_marshal_buffer_null_with_offset),
237 cmocka_unit_test (UINT8_marshal_buffer_null_offset_null),
238 cmocka_unit_test (UINT8_marshal_buffer_size_lt_data),
239 cmocka_unit_test (UINT8_marshal_buffer_size_lt_offset),
240 cmocka_unit_test (UINT8_unmarshal_success),
241 cmocka_unit_test (UINT8_unmarshal_success_offset),
242 cmocka_unit_test (UINT8_unmarshal_buffer_null),
243 cmocka_unit_test (UINT8_unmarshal_dest_null),
244 cmocka_unit_test (UINT8_unmarshal_dest_null_offset_valid),
245 cmocka_unit_test (UINT8_unmarshal_buffer_size_lt_offset),
246 cmocka_unit_test (UINT8_unmarshal_buffer_size_lt_dest),
247 };
248 return cmocka_run_group_tests (tests, NULL, NULL);
249 }
250