Software APIs
asn1_unittest.cc
1 // Copyright lowRISC contributors (OpenTitan project).
2 // Licensed under the Apache License, Version 2.0, see LICENSE for details.
3 // SPDX-License-Identifier: Apache-2.0
4 
5 #include "sw/device/silicon_creator/lib/cert/asn1.h"
6 
7 #include <array>
8 #include <cstring>
9 
10 #include "gtest/gtest.h"
11 
12 /**
13  * Make sure that an array has the right size and matches
14  *
15  * the content of another constant array.
16  * @param array Pointer to an array.
17  * @param size Size in bytes of the array.
18  * @param expected_result An std::array or vector containing the expected
19  * result.
20  */
21 #define EXPECT_EQ_CONST_ARRAY(array, array_size, expected_result) \
22  do { \
23  EXPECT_EQ(array_size, expected_result.size()); \
24  EXPECT_EQ(true, std::equal(expected_result.begin(), expected_result.end(), \
25  array)); \
26  } while (0)
27 
28 namespace asn1_unittest {
29 namespace {
30 
31 // Make sure that we can start and finish with an empty buffer.
32 TEST(Asn1, CreateFinish) {
33  asn1_state_t state;
34  uint8_t buf[1] = {0xff};
35  // Pretend that buffer has size 0 for testing.
36  EXPECT_EQ(asn1_start(&state, buf, 0), kErrorOk);
37  size_t out_size = 42;
38  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
39  EXPECT_EQ(out_size, 0);
40  EXPECT_EQ(buf[0], 0xff);
41 }
42 
43 // Make sure that we can push a byte and that we cannot overflow.
44 TEST(Asn1, PushByte) {
45  asn1_state_t state;
46  uint8_t buf[1] = {0xff};
47  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
48  asn1_push_byte(&state, 0xa5);
49  EXPECT_EQ(state.error, kErrorOk);
50 
51  // Buffer is full, expect an error.
52  asn1_push_byte(&state, 0xb6);
53  EXPECT_EQ(state.error, kErrorAsn1BufferExhausted);
54  asn1_clear_error(&state);
55 
56  size_t out_size = 42;
57  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
58  EXPECT_EQ(out_size, 1);
59  EXPECT_EQ(buf[0], 0xa5);
60 }
61 
62 // Make sure that we can push multiple bytes.
63 TEST(Asn1, PushBytes) {
64  asn1_state_t state;
65  uint8_t buf[3] = {0xff, 0xff, 0xff};
66  const std::array<uint8_t, 2> kData = {0xa5, 0xb6};
67  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
68  asn1_push_bytes(&state, kData.begin(), kData.size());
69  EXPECT_EQ(state.error, kErrorOk);
70  size_t out_size = 42;
71  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
72  EXPECT_EQ_CONST_ARRAY(buf, out_size, kData);
73  EXPECT_EQ(buf[2], 0xff);
74 }
75 
76 // Make sure that we can push multiple bytes.
77 TEST(Asn1, PushBytesOverflow) {
78  asn1_state_t state;
79  uint8_t buf[3] = {0xff, 0xff, 0xff};
80  const uint8_t kData[] = {0xa5, 0xb6, 0x32, 0xff};
81  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
82  asn1_push_bytes(&state, kData, sizeof(kData));
83  EXPECT_EQ(state.error, kErrorAsn1BufferExhausted);
84  asn1_clear_error(&state);
85 }
86 
87 // Make sure that we can push an empty tag.
88 TEST(Asn1, PushEmptyTag) {
89  asn1_state_t state;
90  uint8_t buf[16];
91  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
92  asn1_tag_t tag;
93  asn1_start_tag(&state, &tag, kAsn1TagNumberSequence);
94  EXPECT_EQ(state.error, kErrorOk);
95  asn1_finish_tag(&tag);
96  EXPECT_EQ(state.error, kErrorOk);
97  size_t out_size;
98  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
99  const std::array<uint8_t, 2> kExpectedResult = {
100  0x30, 0x00, // Identifier octet, length, no contents.
101  };
102  EXPECT_EQ_CONST_ARRAY(buf, out_size, kExpectedResult);
103 }
104 
105 // Make sure that we can push a boolean.
106 TEST(Asn1, PushBoolean) {
107  asn1_state_t state;
108  uint8_t buf[16];
109  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
110  asn1_push_bool(&state, kAsn1TagNumberBoolean, true);
111  EXPECT_EQ(state.error, kErrorOk);
112  asn1_push_bool(&state, kAsn1TagClassContext | 42, false);
113  EXPECT_EQ(state.error, kErrorOk);
114  size_t out_size;
115  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
116  const std::array<uint8_t, 6> kExpectedResult = {
117  // Identifier octet (universal, boolean), length, content (can be any
118  // nonzero value, the library uses 0xff).
119  0x01, 0x01, 0xff, 0xaa, 0x01, 0x00,
120  };
121  EXPECT_EQ_CONST_ARRAY(buf, out_size, kExpectedResult);
122 }
123 
124 // Make sure that we can push small integers.
125 TEST(Asn1, PushInt32) {
126  asn1_state_t state;
127  uint8_t buf[24];
128  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
129  asn1_push_uint32(&state, kAsn1TagNumberInteger, 0);
130  EXPECT_EQ(state.error, kErrorOk);
131  asn1_push_int32(&state, kAsn1TagNumberInteger, 0x1234);
132  EXPECT_EQ(state.error, kErrorOk);
133  asn1_push_uint32(&state, kAsn1TagNumberOctetString, 0x8000);
134  EXPECT_EQ(state.error, kErrorOk);
135  asn1_push_int32(&state, kAsn1TagNumberInteger, -1);
136  EXPECT_EQ(state.error, kErrorOk);
137  asn1_push_int32(&state, kAsn1TagNumberInteger, -3000);
138  EXPECT_EQ(state.error, kErrorOk);
139  size_t out_size;
140  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
141  const std::array<uint8_t, 19> kExpectedResult = {
142  // Identifier octet (universal, integer), length, content (minimal
143  // encoding, always uses one byte at least).
144  0x02, 0x01, 0x0, 0x02, 0x02, 0x12, 0x34,
145  // Identifier octet (universal, octet string), length, content (minimal
146  // encoding, needs 0x00 because MSB is set).
147  0x04, 0x03, 0x00, 0x80, 0x00,
148  // Identifier octet (universal, integer), length, content (minimal
149  // encoding for signed integers).
150  0x02, 0x01, 0xff, 0x02, 0x02, 0xf4, 0x48};
151  EXPECT_EQ_CONST_ARRAY(buf, out_size, kExpectedResult);
152 }
153 
154 // Make sure that we can push big integers.
155 TEST(Asn1, PushIntUnsigned) {
156  asn1_state_t state;
157  uint8_t buf[16];
158  // Integers are in big-endian.
159  const uint8_t kBigInt1[] = {0x00, 0x00, 0x00, 0x00,
160  0x00}; // Extra zeroes for testing.
161  const uint8_t kBigInt2[] = {0x00, 0x12, 0x34}; // Extra zeroes for testing.
162  const uint8_t kBigInt3[] = {0x00, 0x00, 0x00, 0x80,
163  0x00}; // Extra zeroes for testing.
164  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
165  asn1_push_integer(&state, kAsn1TagNumberInteger, false, kBigInt1,
166  sizeof(kBigInt1));
167  EXPECT_EQ(state.error, kErrorOk);
168  asn1_push_integer(&state, kAsn1TagNumberInteger, false, kBigInt2,
169  sizeof(kBigInt2));
170  EXPECT_EQ(state.error, kErrorOk);
171  asn1_push_integer(&state, kAsn1TagNumberInteger, false, kBigInt3,
172  sizeof(kBigInt3));
173  EXPECT_EQ(state.error, kErrorOk);
174  size_t out_size;
175  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
176  const std::array<uint8_t, 12> kExpectedResult = {
177  // Identifier octet (universal, integer), length, content (minimal
178  // encoding, always uses one byte at least).
179  0x02, 0x01, 0x0, 0x02, 0x02, 0x12,
180  0x34, 0x02, 0x03, 0x00, 0x80, 0x00, // Needs 0x00 because MSB is set.
181  };
182  EXPECT_EQ_CONST_ARRAY(buf, out_size, kExpectedResult);
183 }
184 
185 // Make sure that we can push big integers.
186 TEST(Asn1, PushIntSigned) {
187  asn1_state_t state;
188  uint8_t buf[12];
189  // Integers are in big-endian.
190  const uint8_t kBigInt1[] = {0x00, 0x00, 0x00, 0x00,
191  0x00}; // Extra zeroes for testing.
192  const uint8_t kBigInt2[] = {0xff, 0xff, 0xff}; // Extra ones for testing.
193  const uint8_t kBigInt3[] = {0xff, 0xff, 0xf4,
194  0x48}; // Extra zeroes for testing.
195  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
196  asn1_push_integer(&state, kAsn1TagNumberInteger, true, kBigInt1,
197  sizeof(kBigInt1));
198  EXPECT_EQ(state.error, kErrorOk);
199  asn1_push_integer(&state, kAsn1TagNumberInteger, true, kBigInt2,
200  sizeof(kBigInt2));
201  EXPECT_EQ(state.error, kErrorOk);
202  asn1_push_integer(&state, kAsn1TagNumberInteger, true, kBigInt3,
203  sizeof(kBigInt3));
204  EXPECT_EQ(state.error, kErrorOk);
205  size_t out_size;
206  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
207  const std::array<uint8_t, 10> kExpectedResult = {
208  // Identifier octet (universal, integer), length, content (minimal
209  // encoding, always uses one byte at least).
210  0x02, 0x01, 0x0, 0x02, 0x01, 0xff, 0x02, 0x02, 0xf4, 0x48,
211  };
212  EXPECT_EQ_CONST_ARRAY(buf, out_size, kExpectedResult);
213 }
214 
215 // Make sure that we can push big integers with padding.
216 TEST(Asn1, PushIntPad) {
217  asn1_state_t state;
218  uint8_t buf[40];
219  // Integers are in big-endian.
220  const uint8_t kBigInt1[] = {0x42};
221  const uint8_t kBigInt2[] = {0x00, 0x80}; // Extra zeroes for testing.
222  const uint8_t kBigInt3[] = {0x80, 0x01};
223  const uint8_t kBigInt4[] = {0x30, 0x47, 0x80, 0x01};
224  const uint8_t kBigInt5[] = {0x30, 0x47, 0x80, 0x01, 0x17};
225  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
226  asn1_push_integer_pad(&state, false, kBigInt1, sizeof(kBigInt1), 4);
227  EXPECT_EQ(state.error, kErrorOk);
228  asn1_push_integer_pad(&state, true, kBigInt1, sizeof(kBigInt1), 4);
229  EXPECT_EQ(state.error, kErrorOk);
230  asn1_push_integer_pad(&state, false, kBigInt2, sizeof(kBigInt2), 4);
231  EXPECT_EQ(state.error, kErrorOk);
232  asn1_push_integer_pad(&state, true, kBigInt2, sizeof(kBigInt2), 4);
233  EXPECT_EQ(state.error, kErrorOk);
234  asn1_push_integer_pad(&state, false, kBigInt3, sizeof(kBigInt3), 4);
235  EXPECT_EQ(state.error, kErrorOk);
236  asn1_push_integer_pad(&state, true, kBigInt3, sizeof(kBigInt3), 4);
237  EXPECT_EQ(state.error, kErrorOk);
238  asn1_push_integer_pad(&state, false, kBigInt4, sizeof(kBigInt4), 4);
239  EXPECT_EQ(state.error, kErrorOk);
240  asn1_push_integer_pad(&state, true, kBigInt4, sizeof(kBigInt4), 4);
241  EXPECT_EQ(state.error, kErrorOk);
242 
243  asn1_push_integer_pad(&state, true, kBigInt5, sizeof(kBigInt5), 4);
244  EXPECT_EQ(state.error, kErrorAsn1PushIntegerPadInvalidArgument);
245  asn1_clear_error(&state);
246 
247  size_t out_size;
248  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
249  const std::array<uint8_t, 32> kExpectedResult = {
250  // Unsigned: padded with 0.
251  0x00, 0x00, 0x00, 0x42,
252  // Signed and non-negative: padded with 0.
253  0x00, 0x00, 0x00, 0x42,
254  // Unsigned: padded with 0.
255  0x00, 0x00, 0x00, 0x80,
256  // Signed and non-negative: padded with 0.
257  0x00, 0x00, 0x00, 0x80,
258  // Unsigned: padded with 0.
259  0x00, 0x00, 0x80, 0x01,
260  // Signed and negative: padded with 0xff.
261  0xff, 0xff, 0x80, 0x01,
262  // Already at maximum size: no padding.
263  0x30, 0x47, 0x80, 0x01,
264  // Already at maximum size: no padding.
265  0x30, 0x47, 0x80, 0x01};
266  EXPECT_EQ_CONST_ARRAY(buf, out_size, kExpectedResult);
267 }
268 
269 // Make sure that we can push strings.
270 TEST(Asn1, PushStrings) {
271  asn1_state_t state;
272  uint8_t buf[30];
273  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
274  const char kString1[] = "lowRISC";
275  const char kString2[] = "OpenTitanAndMore!";
276  const char kString3[] = "";
277  asn1_push_string(&state, kAsn1TagNumberPrintableString, kString1,
278  strlen(kString1));
279  EXPECT_EQ(state.error, kErrorOk);
280  // Cut the second string short on purpose.
281  asn1_push_string(&state, kAsn1TagNumberUtf8String, kString2, 9);
282  EXPECT_EQ(state.error, kErrorOk);
283  asn1_push_string(&state, kAsn1TagNumberOctetString, kString3,
284  strlen(kString3));
285  EXPECT_EQ(state.error, kErrorOk);
286  size_t out_size;
287  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
288  // clang-format off
289  const std::array<uint8_t, 22> kExpectedResult = {
290  // Identifier octet (universal, printable string), length, content.
291  0x13, 0x07, 0x6c, 0x6f, 0x77, 0x52, 0x49, 0x53, 0x43,
292  // Identifier octet (universal, integer), length, content.
293  0x0c, 0x09, 0x4f, 0x70, 0x65, 0x6e, 0x54, 0x69, 0x74, 0x61, 0x6e,
294  // Identifier octet (universal, integer), length, no content.
295  0x04, 0x00,
296  };
297  // clang-format on
298  EXPECT_EQ_CONST_ARRAY(buf, out_size, kExpectedResult);
299 }
300 
301 // Make sure that we can push bitstrings.
302 TEST(Asn1, PushBitString) {
303  asn1_state_t state;
304  uint8_t buf[20];
305  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
306  asn1_bitstring_t bitstring;
307  asn1_tag_t tag;
308  // Empty bitstring.
309  asn1_start_tag(&state, &tag, kAsn1TagNumberBitString);
310  EXPECT_EQ(state.error, kErrorOk);
311  asn1_start_bitstring(&state, &bitstring);
312  EXPECT_EQ(state.error, kErrorOk);
313  asn1_finish_bitstring(&bitstring);
314  EXPECT_EQ(state.error, kErrorOk);
315  asn1_finish_tag(&tag);
316  EXPECT_EQ(state.error, kErrorOk);
317  // Two trivial bitstrings.
318  asn1_start_tag(&state, &tag, kAsn1TagNumberBitString);
319  EXPECT_EQ(state.error, kErrorOk);
320  asn1_start_bitstring(&state, &bitstring);
321  EXPECT_EQ(state.error, kErrorOk);
322  asn1_bitstring_push_bit(&bitstring, true);
323  EXPECT_EQ(state.error, kErrorOk);
324  asn1_finish_bitstring(&bitstring);
325  EXPECT_EQ(state.error, kErrorOk);
326  asn1_finish_tag(&tag);
327  EXPECT_EQ(state.error, kErrorOk);
328 
329  asn1_start_tag(&state, &tag, kAsn1TagNumberBitString);
330  EXPECT_EQ(state.error, kErrorOk);
331  asn1_start_bitstring(&state, &bitstring);
332  EXPECT_EQ(state.error, kErrorOk);
333  asn1_bitstring_push_bit(&bitstring, false);
334  EXPECT_EQ(state.error, kErrorOk);
335  asn1_finish_bitstring(&bitstring);
336  EXPECT_EQ(state.error, kErrorOk);
337  asn1_finish_tag(&tag);
338  EXPECT_EQ(state.error, kErrorOk);
339  // A longer bitstring.
340  const std::array<bool, 12> kBitString = {
341  true, false, true, true, false, false,
342  false, false, true, false, false, true,
343  };
344  asn1_start_tag(&state, &tag, kAsn1TagNumberBitString);
345  EXPECT_EQ(state.error, kErrorOk);
346  asn1_start_bitstring(&state, &bitstring);
347  EXPECT_EQ(state.error, kErrorOk);
348  for (bool bit : kBitString) {
349  asn1_bitstring_push_bit(&bitstring, bit);
350  EXPECT_EQ(state.error, kErrorOk);
351  }
352  asn1_finish_bitstring(&bitstring);
353  EXPECT_EQ(state.error, kErrorOk);
354  asn1_finish_tag(&tag);
355  EXPECT_EQ(state.error, kErrorOk);
356  size_t out_size;
357  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
358  const std::array<uint8_t, 16> kExpectedResult = {
359  // Identifier octet (bitstring, OID), length, content (encoded as per
360  // X.690 section 8.6).
361  0x03, 0x01, 0x0,
362  // Identifier octet (bitstring, OID), length, content.
363  0x03, 0x02, 0x7, 0x80,
364  // Identifier octet (bitstring, OID), length, content.
365  0x03, 0x02, 0x7, 0x00,
366  // Identifier octet (bitstring, OID), length, content (written in binary
367  // to make it easier to read).
368  0x03, 0x03, 0x04, 0b10110000, 0b10010000};
369  EXPECT_EQ_CONST_ARRAY(buf, out_size, kExpectedResult);
370 }
371 
372 // Make sure that we can push strings.
373 TEST(Asn1, PushRawOid) {
374  asn1_state_t state;
375  uint8_t buf[30];
376  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
377  const uint8_t kRawOid[] = {0x88, 0x037, 0x03}; // Corresponds to "2.999.3".
378  asn1_push_oid_raw(&state, kRawOid, sizeof(kRawOid));
379  EXPECT_EQ(state.error, kErrorOk);
380  size_t out_size;
381  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
382  const std::array<uint8_t, 5> kExpectedResult = {
383  // Identifier octet (universal, OID), length, content (encoded as per
384  // X.690 section 8.19.5).
385  0x06, 0x03, 0x88, 0x037, 0x03,
386  };
387  EXPECT_EQ_CONST_ARRAY(buf, out_size, kExpectedResult);
388 }
389 
390 // Make sure that we can push strings.
391 TEST(Asn1, PushHexStrings) {
392  asn1_state_t state;
393  uint8_t buf[12];
394  EXPECT_EQ(asn1_start(&state, buf, sizeof(buf)), kErrorOk);
395  const uint8_t kData[] = {0x01, 0x23, 0xab, 0xef};
396  asn1_push_hexstring(&state, kAsn1TagNumberPrintableString, kData,
397  sizeof(kData));
398  EXPECT_EQ(state.error, kErrorOk);
399  size_t out_size;
400  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
401  const std::array<uint8_t, 10> kExpectedResult = {
402  // Identifier octet (universal, printable string), length, content.
403  0x13, 0x08, 0x30, 0x31, 0x32, 0x33, 0x61, 0x62, 0x65, 0x66,
404  };
405  EXPECT_EQ_CONST_ARRAY(buf, out_size, kExpectedResult);
406 }
407 
408 // Make sure that the tag routines handle overflow correctly.
409 TEST(Asn1, TagOverflow) {
410  // When creating a tag, `asn1_start_tag` initially assumes that
411  // the length encoding fits on one byte, and this is fixed-up
412  // in `asn1_finish_tag` by moving the data. There is a potential
413  // source of overflow here if (one byte length) + (data) fits into
414  // the buffer but (two byte length) + (data) which is the correct
415  // final value does not. In this test, we create create a buffer that
416  // is big enough to hold the final value but we pretend that it is one
417  // byte smaller. If the code is correct, it should return an error
418  // saying that the buffer is too small. If it is incorrect, it will
419  // (incorrect) proceed and write one byte after the end of the buffer.
420  asn1_state_t state;
421  std::vector<uint8_t> buf;
422  const uint8_t kPattern = 0xa5;
423  // Allocate one byte for the tag, one for the length, 0x100 for the data.
424  const size_t kBufferSize = 1 + 1 + 0x100;
425  buf.resize(kBufferSize + 1, kPattern);
426  EXPECT_EQ(asn1_start(&state, &buf[0], kBufferSize), kErrorOk);
427  // The function will allocate one byte for the tag length.
428  asn1_tag_t tag;
429  asn1_start_tag(&state, &tag, kAsn1TagNumberSequence);
430  EXPECT_EQ(state.error, kErrorOk);
431  // Push 0x100 bytes so that the length tag requires two bytes.
432  std::vector<uint8_t> tmp;
433  tmp.resize(0x100, 0xff);
434  asn1_push_bytes(&state, &tmp[0], tmp.size());
435  EXPECT_EQ(state.error, kErrorOk);
436  // At this point, the function will need to move the data forward by one byte
437  // so it should hit the buffer size.
438  asn1_finish_tag(&tag);
439  EXPECT_EQ(state.error, kErrorAsn1BufferExhausted);
440  asn1_clear_error(&state);
441  // Make sure that that even though it returned an error, the function did not
442  // actually write anything past the end of the buffer.
443  EXPECT_EQ(buf[kBufferSize], kPattern);
444 }
445 
446 // Make sure that the tag encoding is correct.
447 TEST(Asn1, TagLengthEncoding) {
448  asn1_state_t state;
449  std::vector<uint8_t> buf;
450  buf.resize(0xfffff);
451  std::vector<uint8_t> expected;
452 
453 #define ADD_BYTES(fill, fill_size, ...) \
454  do { \
455  std::vector<uint8_t> tmp(fill_size, fill); \
456  const uint8_t kData[] = {__VA_ARGS__}; \
457  expected.push_back(0x30); /* Identifier octet (universal, sequence). */ \
458  expected.insert(expected.end(), kData, \
459  kData + sizeof(kData)); /* Length encoding */ \
460  expected.insert(expected.end(), tmp.begin(), tmp.end()); \
461  asn1_tag_t tag; \
462  asn1_start_tag(&state, &tag, kAsn1TagNumberSequence); \
463  EXPECT_EQ(state.error, kErrorOk); \
464  asn1_push_bytes(&state, &tmp[0], tmp.size()); \
465  EXPECT_EQ(state.error, kErrorOk); \
466  asn1_finish_tag(&tag); \
467  EXPECT_EQ(state.error, kErrorOk); \
468  } while (0)
469 
470  EXPECT_EQ(asn1_start(&state, &buf[0], buf.size()), kErrorOk);
471  ADD_BYTES(0x00, 0, 0x00);
472  ADD_BYTES(0xa5, 0x7f, 0x7f);
473  ADD_BYTES(0xb6, 0x80, 0x81, 0x80);
474  ADD_BYTES(0xc7, 0xff, 0x81, 0xff);
475  ADD_BYTES(0xd8, 0x100, 0x82, 0x01, 0x00);
476  ADD_BYTES(0xe9, 0xffff, 0x82, 0xff, 0xff);
477  size_t out_size;
478  EXPECT_EQ(asn1_finish(&state, &out_size), kErrorOk);
479  EXPECT_EQ(out_size, expected.size());
480  buf.resize(out_size);
481  EXPECT_EQ(buf, expected);
482 }
483 
484 } // namespace
485 } // namespace asn1_unittest
Return to OpenTitan Documentation