1 // Copyright 2021 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "dice/cbor_reader.h"
16
17 #include "dice/test_framework.h"
18
19 namespace {
20
21 extern "C" {
22
TEST(CborReaderTest,Int1Byte)23 TEST(CborReaderTest, Int1Byte) {
24 const uint8_t buffer[] = {0, 23, 0x20, 0x37};
25 int64_t val;
26 CborIn in;
27 CborInInit(buffer, sizeof(buffer), &in);
28 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
29 EXPECT_EQ(0, val);
30 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
31 EXPECT_EQ(23, val);
32 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
33 EXPECT_EQ(-1, val);
34 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
35 EXPECT_EQ(-24, val);
36 EXPECT_TRUE(CborInAtEnd(&in));
37 }
38
TEST(CborReaderTest,Int2Bytes)39 TEST(CborReaderTest, Int2Bytes) {
40 const uint8_t buffer[] = {24, 24, 24, 0xff, 0x38, 24, 0x38, 0xff};
41 int64_t val;
42 CborIn in;
43 CborInInit(buffer, sizeof(buffer), &in);
44 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
45 EXPECT_EQ(24, val);
46 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
47 EXPECT_EQ(0xff, val);
48 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
49 EXPECT_EQ(-25, val);
50 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
51 EXPECT_EQ(-0x100, val);
52 EXPECT_TRUE(CborInAtEnd(&in));
53 }
54
TEST(CborReaderTest,Int3Bytes)55 TEST(CborReaderTest, Int3Bytes) {
56 const uint8_t buffer[] = {25, 0x01, 0x00, 25, 0xff, 0xff,
57 0x39, 0x01, 0x00, 0x39, 0xff, 0xff};
58 int64_t val;
59 CborIn in;
60 CborInInit(buffer, sizeof(buffer), &in);
61 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
62 EXPECT_EQ(0x100, val);
63 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
64 EXPECT_EQ(0xffff, val);
65 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
66 EXPECT_EQ(-0x101, val);
67 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
68 EXPECT_EQ(-0x10000, val);
69 EXPECT_TRUE(CborInAtEnd(&in));
70 }
71
TEST(CborReaderTest,Int5Bytes)72 TEST(CborReaderTest, Int5Bytes) {
73 const uint8_t buffer[] = {26, 0x00, 0x01, 0x00, 0x00, 26, 0xff,
74 0xff, 0xff, 0xff, 0x3a, 0x00, 0x01, 0x00,
75 0x00, 0x3a, 0xff, 0xff, 0xff, 0xff};
76 int64_t val;
77 CborIn in;
78 CborInInit(buffer, sizeof(buffer), &in);
79 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
80 EXPECT_EQ(0x10000, val);
81 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
82 EXPECT_EQ(0xffffffff, val);
83 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
84 EXPECT_EQ(-0x10001, val);
85 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
86 EXPECT_EQ(-0x100000000, val);
87 EXPECT_TRUE(CborInAtEnd(&in));
88 }
89
TEST(CborReaderTest,Int9Bytes)90 TEST(CborReaderTest, Int9Bytes) {
91 const uint8_t buffer[] = {
92 27, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 27, 0x7f, 0xff,
93 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3b, 0x00, 0x00, 0x00, 0x01, 0x00,
94 0x00, 0x00, 0x00, 0x3b, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
95 int64_t val;
96 CborIn in;
97 CborInInit(buffer, sizeof(buffer), &in);
98 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
99 EXPECT_EQ(0x100000000, val);
100 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
101 EXPECT_EQ(INT64_MAX, val);
102 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
103 EXPECT_EQ(-0x100000001, val);
104 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
105 EXPECT_EQ(INT64_MIN, val);
106 EXPECT_TRUE(CborInAtEnd(&in));
107 }
108
TEST(CborReaderTest,Uint9Bytes)109 TEST(CborReaderTest, Uint9Bytes) {
110 const uint8_t buffer[] = {27, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
111 27, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
112 uint64_t val;
113 CborIn in;
114 CborInInit(buffer, sizeof(buffer), &in);
115 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadUint(&in, &val));
116 EXPECT_EQ(0x100000000u, val);
117 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadUint(&in, &val));
118 EXPECT_EQ(UINT64_MAX, val);
119 EXPECT_TRUE(CborInAtEnd(&in));
120 }
121
TEST(CborReaderTest,IntByteOrder)122 TEST(CborReaderTest, IntByteOrder) {
123 const uint8_t buffer[] = {
124 25, 0x12, 0x34, 26, 0x12, 0x34, 0x56, 0x78, 27,
125 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
126 };
127 int64_t val;
128 CborIn in;
129 CborInInit(buffer, sizeof(buffer), &in);
130 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
131 EXPECT_EQ(0x1234, val);
132 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
133 EXPECT_EQ(0x12345678, val);
134 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
135 EXPECT_EQ(0x123456789abcdef0, val);
136 EXPECT_TRUE(CborInAtEnd(&in));
137 }
138
TEST(CborReaderTest,IntMalformed)139 TEST(CborReaderTest, IntMalformed) {
140 const uint8_t kTooBigBuffer[] = {27, 0x80, 0, 0, 0, 0, 0, 0, 0};
141 const uint8_t kTooSmallBuffer[] = {0x3b, 0x80, 0, 0, 0, 0, 0, 0, 0};
142 const uint8_t kBadAddlBuffer[] = {30};
143 const uint8_t kNegBadAddlBuffer[] = {0x3c};
144 int64_t val;
145 CborIn in;
146 CborInInit(kTooBigBuffer, sizeof(kTooBigBuffer), &in);
147 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadInt(&in, &val));
148 CborInInit(kTooSmallBuffer, sizeof(kTooSmallBuffer), &in);
149 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadInt(&in, &val));
150 CborInInit(kBadAddlBuffer, sizeof(kBadAddlBuffer), &in);
151 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadInt(&in, &val));
152 CborInInit(kNegBadAddlBuffer, sizeof(kNegBadAddlBuffer), &in);
153 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadInt(&in, &val));
154 EXPECT_FALSE(CborInAtEnd(&in));
155 }
156
TEST(CborReaderTest,IntTooShort)157 TEST(CborReaderTest, IntTooShort) {
158 const uint8_t buffer[] = {27, 0x40, 0, 0, 0, 0, 0, 0};
159 int64_t val;
160 CborIn in;
161 CborInInit(buffer, sizeof(buffer), &in);
162 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadInt(&in, &val));
163 EXPECT_FALSE(CborInAtEnd(&in));
164 }
165
TEST(CborReaderTest,BstrEncoding)166 TEST(CborReaderTest, BstrEncoding) {
167 const uint8_t buffer[] = {0x45, 'h', 'e', 'l', 'l', 'o'};
168 const uint8_t kData[] = {'h', 'e', 'l', 'l', 'o'};
169 size_t data_size;
170 const uint8_t* data;
171 CborIn in;
172 CborInInit(buffer, sizeof(buffer), &in);
173 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadBstr(&in, &data_size, &data));
174 EXPECT_EQ(sizeof(kData), data_size);
175 EXPECT_EQ(0, memcmp(data, kData, data_size));
176 EXPECT_TRUE(CborInAtEnd(&in));
177 }
178
TEST(CborReaderTest,BstrLongEncoding)179 TEST(CborReaderTest, BstrLongEncoding) {
180 const uint8_t buffer[] = {
181 0x58, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x00,
182 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00,
183 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x99,
184 };
185 size_t data_size;
186 const uint8_t* data;
187 CborIn in;
188 CborInInit(buffer, sizeof(buffer), &in);
189 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadBstr(&in, &data_size, &data));
190 EXPECT_EQ(32u, data_size);
191 EXPECT_EQ(0, memcmp(data, buffer + 2, 32));
192 EXPECT_TRUE(CborInAtEnd(&in));
193 }
194
TEST(CborReaderTest,TstrEncoding)195 TEST(CborReaderTest, TstrEncoding) {
196 const uint8_t buffer[] = {0x65, 'w', 'o', 'r', 'l', 'd'};
197 const char kStr[] = "world";
198 size_t size;
199 const char* str;
200 CborIn in;
201 CborInInit(buffer, sizeof(buffer), &in);
202 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTstr(&in, &size, &str));
203 EXPECT_EQ(strlen(kStr), size);
204 EXPECT_EQ(0, memcmp(str, kStr, size));
205 EXPECT_TRUE(CborInAtEnd(&in));
206 }
207
TEST(CborReaderTest,ArrayEncoding)208 TEST(CborReaderTest, ArrayEncoding) {
209 const uint8_t buffer[] = {0x98, 29};
210 size_t num_elements;
211 CborIn in;
212 CborInInit(buffer, sizeof(buffer), &in);
213 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadArray(&in, &num_elements));
214 EXPECT_EQ(29u, num_elements);
215 EXPECT_TRUE(CborInAtEnd(&in));
216 }
217
TEST(CborReaderTest,MapEncoding)218 TEST(CborReaderTest, MapEncoding) {
219 const uint8_t buffer[] = {0xb9, 0x02, 0x50};
220 size_t num_pairs;
221 CborIn in;
222 CborInInit(buffer, sizeof(buffer), &in);
223 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadMap(&in, &num_pairs));
224 EXPECT_EQ(592u, num_pairs);
225 EXPECT_TRUE(CborInAtEnd(&in));
226 }
227
TEST(CborReaderTest,FalseEncoding)228 TEST(CborReaderTest, FalseEncoding) {
229 const uint8_t buffer[] = {0xf4};
230 CborIn in;
231 CborInInit(buffer, sizeof(buffer), &in);
232 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadFalse(&in));
233 EXPECT_TRUE(CborInAtEnd(&in));
234 }
235
TEST(CborReaderTest,TrueEncoding)236 TEST(CborReaderTest, TrueEncoding) {
237 const uint8_t buffer[] = {0xf5};
238 CborIn in;
239 CborInInit(buffer, sizeof(buffer), &in);
240 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTrue(&in));
241 EXPECT_TRUE(CborInAtEnd(&in));
242 }
243
TEST(CborReaderTest,NullEncoding)244 TEST(CborReaderTest, NullEncoding) {
245 const uint8_t buffer[] = {0xf6};
246 CborIn in;
247 CborInInit(buffer, sizeof(buffer), &in);
248 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadNull(&in));
249 EXPECT_TRUE(CborInAtEnd(&in));
250 }
251
TEST(CborReaderTest,Skip)252 TEST(CborReaderTest, Skip) {
253 const uint8_t buffer[] = {0x84, 0x03, 0xa2, 0x82, 0x23, 0x05, 0xf4,
254 0x16, 0xf6, 0x61, 0x44, 0x41, 0xaa};
255 CborIn in;
256 CborInInit(buffer, sizeof(buffer), &in);
257 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadSkip(&in));
258 EXPECT_TRUE(CborInAtEnd(&in));
259 }
260
TEST(CborReaderTest,SkipTooDeeplyNestedMalformed)261 TEST(CborReaderTest, SkipTooDeeplyNestedMalformed) {
262 const uint8_t map[] = {0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
263 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1};
264 const uint8_t array[] = {0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
265 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
266 0x82, 0x82, 0x82, 0x82, 0x82, 0x82};
267 CborIn in;
268 CborInInit(map, sizeof(map), &in);
269 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
270 EXPECT_EQ(0u, CborInOffset(&in));
271 CborInInit(array, sizeof(array), &in);
272 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
273 EXPECT_EQ(0u, CborInOffset(&in));
274 }
275
TEST(CborReaderTest,SkipTagMalformed)276 TEST(CborReaderTest, SkipTagMalformed) {
277 const uint8_t tag[] = {0xc4, 0xf5};
278 const uint8_t nested_tag[] = {0x82, 0xa1, 0x02, 0xc7, 0x04, 0x09};
279 CborIn in;
280 CborInInit(tag, sizeof(tag), &in);
281 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
282 EXPECT_EQ(0u, CborInOffset(&in));
283 CborInInit(nested_tag, sizeof(nested_tag), &in);
284 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
285 EXPECT_EQ(0u, CborInOffset(&in));
286 }
287
TEST(CborReaderTest,EmptyBufferAtEnd)288 TEST(CborReaderTest, EmptyBufferAtEnd) {
289 int64_t val;
290 uint64_t uval;
291 size_t size;
292 const uint8_t* data;
293 const char* str;
294 CborIn in;
295 CborInInit(nullptr, 0, &in);
296 EXPECT_TRUE(CborInAtEnd(&in));
297 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadInt(&in, &val));
298 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadUint(&in, &uval));
299 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadBstr(&in, &size, &data));
300 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadTstr(&in, &size, &str));
301 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadArray(&in, &size));
302 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadMap(&in, &size));
303 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadFalse(&in));
304 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadTrue(&in));
305 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadNull(&in));
306 EXPECT_EQ(0u, CborInOffset(&in));
307 }
308
TEST(CborReaderTest,NotFound)309 TEST(CborReaderTest, NotFound) {
310 const uint8_t buffer[] = {0xc0, 0x08};
311 int64_t val;
312 uint64_t uval;
313 size_t size;
314 const uint8_t* data;
315 const char* str;
316 CborIn in;
317 CborInInit(buffer, sizeof(buffer), &in);
318 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadInt(&in, &val));
319 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadUint(&in, &uval));
320 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadBstr(&in, &size, &data));
321 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadTstr(&in, &size, &str));
322 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadArray(&in, &size));
323 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadMap(&in, &size));
324 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadFalse(&in));
325 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadTrue(&in));
326 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadNull(&in));
327 EXPECT_EQ(0u, CborInOffset(&in));
328 }
329
TEST(CborReaderTest,SimpleValueNotFound)330 TEST(CborReaderTest, SimpleValueNotFound) {
331 const uint8_t buffer[] = {0xf7};
332 CborIn in;
333 CborInInit(buffer, sizeof(buffer), &in);
334 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadFalse(&in));
335 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadTrue(&in));
336 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadNull(&in));
337 EXPECT_EQ(0u, CborInOffset(&in));
338 }
339
TEST(CborReaderTest,IndefiniteLengthMalformed)340 TEST(CborReaderTest, IndefiniteLengthMalformed) {
341 size_t size;
342 const uint8_t* data;
343 const char* str;
344 CborIn in;
345 const uint8_t bstr[] = {0x5f, 0x44, 0xaa, 0xbb, 0xcc, 0xdd,
346 0x43, 0xee, 0xff, 0x99, 0xff};
347 CborInInit(bstr, sizeof(bstr), &in);
348 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadBstr(&in, &size, &data));
349 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
350 EXPECT_EQ(0u, CborInOffset(&in));
351 const uint8_t tstr[] = {0x7f, 0x64, 0x41, 0x42, 0x43, 0x44,
352 0x63, 0x30, 0x31, 0x32, 0xff};
353 CborInInit(tstr, sizeof(tstr), &in);
354 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadTstr(&in, &size, &str));
355 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
356 EXPECT_EQ(0u, CborInOffset(&in));
357 const uint8_t array[] = {0x9f, 0x01, 0x82, 0x02, 0x03,
358 0x82, 0x04, 0x05, 0xff};
359 CborInInit(array, sizeof(array), &in);
360 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadArray(&in, &size));
361 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
362 EXPECT_EQ(0u, CborInOffset(&in));
363 const uint8_t map[] = {0xbf, 0x63, 0x46, 0x75, 0x6e, 0xf5,
364 0x63, 0x41, 0x6d, 0x74, 0x21, 0xff};
365 CborInInit(map, sizeof(map), &in);
366 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadMap(&in, &size));
367 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
368 EXPECT_EQ(0u, CborInOffset(&in));
369 }
370 }
371
372 } // namespace
373