1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (C) 2018 Intel Corporation.
3 * All rights reserved.
4 */
5
6 #include "spdk/stdinc.h"
7
8 #include "spdk_internal/cunit.h"
9
10 #include "util/base64.c"
11
12 char text_A[] = "FZB3";
13 uint8_t raw_A[] = {0x15, 0x90, 0x77};
14 char text_B[] = "AbC/1+c=";
15 char text_urlsafe_B[] = "AbC_1-c=";
16 uint8_t raw_B[] = {0x01, 0xB0, 0xBF, 0xD7, 0xE7};
17 char text_C[] = "AbC/1+cC";
18 char text_urlsafe_C[] = "AbC_1-cC";
19 uint8_t raw_C[] = {0x01, 0xB0, 0xBF, 0xD7, 0xE7, 0x02};
20 char text_D[] = "AbC/1w==";
21 char text_urlsafe_D[] = "AbC_1w==";
22 uint8_t raw_D[] = {0x01, 0xB0, 0xBF, 0xD7};
23 char text_E[] = "AbC12===";
24 char text_F[] = "AbCd112";
25 char text_G[] = "AbCd12";
26 char text_H[] = "AbC12";
27 char text_I[] = "AQu/1+cCCBUnOBFWv+HzoL3BOVUBItP2mRDdqhnxAtIT4hD1wbQ30Ylm8R+7khPS";//64 bytes
28 char text_urlsafe_I[] =
29 "AQu_1-cCCBUnOBFWv-HzoL3BOVUBItP2mRDdqhnxAtIT4hD1wbQ30Ylm8R-7khPS";//64 bytes
30 uint8_t raw_I[] = {0x01, 0x0B, 0xBF, 0xD7, 0xE7, 0x02, 0x08, 0x15, 0x27, 0x38, 0x11, 0x56, 0xBF, 0xE1, 0xF3, 0xA0,
31 0xBD, 0xC1, 0x39, 0x55, 0x01, 0x22, 0xD3, 0xF6, 0x99, 0x10, 0xDD, 0xAA, 0x19, 0xF1, 0x02, 0xD2,
32 0x13, 0xE2, 0x10, 0xF5, 0xC1, 0xB4, 0x37, 0xD1, 0x89, 0x66, 0xF1, 0x1F, 0xBB, 0x92, 0x13, 0xD2
33 };
34 char text_J[] =
35 "AQu/1+cCCBUnOBFWv+HzoL3BOVUBItP2mRDdqhnxAtIT4hD1wbQ30Ylm8R+7khPSvcE5VecCCBUZ8QLiEPVm8b3BOVUBItP2GfEC4hD1ZvE5VQEi0/aJZvEfu5LiEPUTvcE5VQEi0/YZEQ==";
36 char text_urlsafe_J[] =
37 "AQu_1-cCCBUnOBFWv-HzoL3BOVUBItP2mRDdqhnxAtIT4hD1wbQ30Ylm8R-7khPSvcE5VecCCBUZ8QLiEPVm8b3BOVUBItP2GfEC4hD1ZvE5VQEi0_aJZvEfu5LiEPUTvcE5VQEi0_YZEQ==";
38 uint8_t raw_J[] = {0x01, 0x0B, 0xBF, 0xD7, 0xE7, 0x02, 0x08, 0x15, 0x27, 0x38, 0x11, 0x56, 0xBF, 0xE1, 0xF3, 0xA0,
39 0xBD, 0xC1, 0x39, 0x55, 0x01, 0x22, 0xD3, 0xF6, 0x99, 0x10, 0xDD, 0xAA, 0x19, 0xF1, 0x02, 0xD2,
40 0x13, 0xE2, 0x10, 0xF5, 0xC1, 0xB4, 0x37, 0xD1, 0x89, 0x66, 0xF1, 0x1F, 0xBB, 0x92, 0x13, 0xD2,
41 0xBD, 0xC1, 0x39, 0x55, 0xE7, 0x02, 0x08, 0x15, 0x19, 0xF1, 0x02, 0xE2, 0x10, 0xF5, 0x66, 0xF1,
42 0xBD, 0xC1, 0x39, 0x55, 0x01, 0x22, 0xD3, 0xF6, 0x19, 0xF1, 0x02, 0xE2, 0x10, 0xF5, 0x66, 0xF1,
43 0x39, 0x55, 0x01, 0x22, 0xD3, 0xF6, 0x89, 0x66, 0xF1, 0x1F, 0xBB, 0x92, 0xE2, 0x10, 0xF5, 0x13,
44 0xBD, 0xC1, 0x39, 0x55, 0x01, 0x22, 0xD3, 0xF6, 0x19, 0x11
45 };
46
47 static void
test_base64_get_encoded_strlen(void)48 test_base64_get_encoded_strlen(void)
49 {
50 uint32_t raw_lens[4] = {8, 9, 10, 11};
51 uint32_t text_strlens[4] = {12, 12, 16, 16};
52 uint32_t text_strlen;
53 int i;
54
55 for (i = 0; i < 4; i++) {
56 text_strlen = spdk_base64_get_encoded_strlen(raw_lens[i]);
57 CU_ASSERT_EQUAL(text_strlen, text_strlens[i]);
58 }
59 }
60
61 static void
test_base64_get_decoded_len(void)62 test_base64_get_decoded_len(void)
63 {
64 uint32_t text_strlens[4] = {8, 10, 11, 12};
65 uint32_t raw_lens[4] = {6, 7, 8, 9};
66 uint32_t bin_len;
67 int i;
68
69 for (i = 0; i < 4; i++) {
70 bin_len = spdk_base64_get_decoded_len(text_strlens[i]);
71 CU_ASSERT_EQUAL(bin_len, raw_lens[i]);
72 }
73 }
74
75 static void
test_base64_encode(void)76 test_base64_encode(void)
77 {
78 char text[200];
79 int ret;
80
81 ret = spdk_base64_encode(text, raw_A, sizeof(raw_A));
82 CU_ASSERT_EQUAL(ret, 0);
83 CU_ASSERT(strcmp(text, text_A) == 0);
84 CU_ASSERT_EQUAL(strlen(text), strlen(text_A));
85
86 ret = spdk_base64_encode(text, raw_B, sizeof(raw_B));
87 CU_ASSERT_EQUAL(ret, 0);
88 CU_ASSERT(strcmp(text, text_B) == 0);
89 CU_ASSERT_EQUAL(strlen(text), strlen(text_B));
90
91 ret = spdk_base64_encode(text, raw_C, sizeof(raw_C));
92 CU_ASSERT_EQUAL(ret, 0);
93 CU_ASSERT(strcmp(text, text_C) == 0);
94
95 ret = spdk_base64_encode(text, raw_D, sizeof(raw_D));
96 CU_ASSERT_EQUAL(ret, 0);
97 CU_ASSERT(strcmp(text, text_D) == 0);
98
99 ret = spdk_base64_encode(text, raw_I, sizeof(raw_I));
100 CU_ASSERT_EQUAL(ret, 0);
101 CU_ASSERT(strcmp(text, text_I) == 0);
102
103 ret = spdk_base64_encode(text, raw_J, sizeof(raw_J));
104 CU_ASSERT_EQUAL(ret, 0);
105 CU_ASSERT(strcmp(text, text_J) == 0);
106
107 ret = spdk_base64_encode(NULL, raw_A, sizeof(raw_A));
108 CU_ASSERT_EQUAL(ret, -EINVAL);
109 ret = spdk_base64_encode(text, NULL, sizeof(raw_A));
110 CU_ASSERT_EQUAL(ret, -EINVAL);
111 ret = spdk_base64_encode(text, raw_A, 0);
112 CU_ASSERT_EQUAL(ret, -EINVAL);
113 }
114
115 static void
test_base64_decode(void)116 test_base64_decode(void)
117 {
118 char raw_buf[200];
119 void *raw = (void *)raw_buf;
120 size_t raw_len;
121 int ret;
122
123 /* len */
124 ret = spdk_base64_decode(NULL, &raw_len, text_A);
125 CU_ASSERT_EQUAL(ret, 0);
126 CU_ASSERT_EQUAL(raw_len, sizeof(raw_A));
127
128 /* decode */
129 ret = spdk_base64_decode(raw, &raw_len, text_A);
130 CU_ASSERT_EQUAL(ret, 0);
131 CU_ASSERT_EQUAL(raw_len, sizeof(raw_A));
132 CU_ASSERT(memcmp(raw, raw_A, sizeof(raw_A)) == 0);
133
134 /* len */
135 ret = spdk_base64_decode(NULL, &raw_len, text_B);
136 CU_ASSERT_EQUAL(ret, 0);
137 CU_ASSERT_EQUAL(raw_len, sizeof(raw_B));
138
139 /* decode */
140 ret = spdk_base64_decode(raw, &raw_len, text_B);
141 CU_ASSERT_EQUAL(ret, 0);
142 CU_ASSERT_EQUAL(raw_len, sizeof(raw_B));
143 CU_ASSERT(memcmp(raw, raw_B, sizeof(raw_B)) == 0);
144
145 /* len */
146 ret = spdk_base64_decode(NULL, &raw_len, text_C);
147 CU_ASSERT_EQUAL(ret, 0);
148 CU_ASSERT_EQUAL(raw_len, sizeof(raw_C));
149
150 /* decode */
151 ret = spdk_base64_decode(raw, &raw_len, text_C);
152 CU_ASSERT_EQUAL(ret, 0);
153 CU_ASSERT_EQUAL(raw_len, sizeof(raw_C));
154 CU_ASSERT(memcmp(raw, raw_C, sizeof(raw_C)) == 0);
155
156 /* len */
157 ret = spdk_base64_decode(NULL, &raw_len, text_D);
158 CU_ASSERT_EQUAL(ret, 0);
159 CU_ASSERT_EQUAL(raw_len, sizeof(raw_D));
160
161 /* decode */
162 ret = spdk_base64_decode(raw, &raw_len, text_D);
163 CU_ASSERT_EQUAL(ret, 0);
164 CU_ASSERT_EQUAL(raw_len, sizeof(raw_D));
165 CU_ASSERT(memcmp(raw, raw_D, sizeof(raw_D)) == 0);
166
167 /* len */
168 ret = spdk_base64_decode(NULL, &raw_len, text_I);
169 CU_ASSERT_EQUAL(ret, 0);
170 CU_ASSERT_EQUAL(raw_len, sizeof(raw_I));
171
172 /* decode */
173 ret = spdk_base64_decode(raw, &raw_len, text_I);
174 CU_ASSERT_EQUAL(ret, 0);
175 CU_ASSERT_EQUAL(raw_len, sizeof(raw_I));
176 CU_ASSERT(memcmp(raw, raw_I, sizeof(raw_I)) == 0);
177
178 /* len */
179 ret = spdk_base64_decode(NULL, &raw_len, text_J);
180 CU_ASSERT_EQUAL(ret, 0);
181 CU_ASSERT_EQUAL(raw_len, sizeof(raw_J));
182
183 /* decode */
184 ret = spdk_base64_decode(raw, &raw_len, text_J);
185 CU_ASSERT_EQUAL(ret, 0);
186 CU_ASSERT_EQUAL(raw_len, sizeof(raw_J));
187 CU_ASSERT(memcmp(raw, raw_J, sizeof(raw_J)) == 0);
188
189 ret = spdk_base64_decode(raw, &raw_len, text_E);
190 CU_ASSERT_EQUAL(ret, -EINVAL);
191 ret = spdk_base64_decode(raw, &raw_len, text_F);
192 CU_ASSERT_EQUAL(ret, -EINVAL);
193 ret = spdk_base64_decode(raw, &raw_len, text_G);
194 CU_ASSERT_EQUAL(ret, -EINVAL);
195 ret = spdk_base64_decode(raw, &raw_len, text_H);
196 CU_ASSERT_EQUAL(ret, -EINVAL);
197 ret = spdk_base64_decode(raw, &raw_len, NULL);
198 CU_ASSERT_EQUAL(ret, -EINVAL);
199 }
200
201 static void
test_base64_urlsafe_encode(void)202 test_base64_urlsafe_encode(void)
203 {
204 char text[200];
205 int ret;
206
207 ret = spdk_base64_urlsafe_encode(text, raw_A, sizeof(raw_A));
208 CU_ASSERT_EQUAL(ret, 0);
209 CU_ASSERT(strcmp(text, text_A) == 0);
210 CU_ASSERT_EQUAL(strlen(text), strlen(text_A));
211
212 ret = spdk_base64_urlsafe_encode(text, raw_B, sizeof(raw_B));
213 CU_ASSERT_EQUAL(ret, 0);
214 CU_ASSERT(strcmp(text, text_urlsafe_B) == 0);
215 CU_ASSERT_EQUAL(strlen(text), strlen(text_urlsafe_B));
216
217 ret = spdk_base64_urlsafe_encode(text, raw_C, sizeof(raw_C));
218 CU_ASSERT_EQUAL(ret, 0);
219 CU_ASSERT(strcmp(text, text_urlsafe_C) == 0);
220
221 ret = spdk_base64_urlsafe_encode(text, raw_D, sizeof(raw_D));
222 CU_ASSERT_EQUAL(ret, 0);
223 CU_ASSERT(strcmp(text, text_urlsafe_D) == 0);
224
225 ret = spdk_base64_urlsafe_encode(text, raw_I, sizeof(raw_I));
226 CU_ASSERT_EQUAL(ret, 0);
227 CU_ASSERT(strcmp(text, text_urlsafe_I) == 0);
228
229 ret = spdk_base64_urlsafe_encode(text, raw_J, sizeof(raw_J));
230 CU_ASSERT_EQUAL(ret, 0);
231 CU_ASSERT(strcmp(text, text_urlsafe_J) == 0);
232
233 ret = spdk_base64_urlsafe_encode(NULL, raw_A, sizeof(raw_A));
234 CU_ASSERT_EQUAL(ret, -EINVAL);
235 ret = spdk_base64_urlsafe_encode(text, NULL, sizeof(raw_A));
236 CU_ASSERT_EQUAL(ret, -EINVAL);
237 ret = spdk_base64_urlsafe_encode(text, raw_A, 0);
238 CU_ASSERT_EQUAL(ret, -EINVAL);
239 }
240
241 static void
test_base64_urlsafe_decode(void)242 test_base64_urlsafe_decode(void)
243 {
244 char raw_buf[200];
245 void *raw = (void *)raw_buf;
246 size_t raw_len = 0;
247 int ret;
248
249 /* len */
250 ret = spdk_base64_urlsafe_decode(NULL, &raw_len, text_A);
251 CU_ASSERT_EQUAL(ret, 0);
252 CU_ASSERT_EQUAL(raw_len, sizeof(raw_A));
253
254 /* decode */
255 ret = spdk_base64_urlsafe_decode(raw, &raw_len, text_A);
256 CU_ASSERT_EQUAL(ret, 0);
257 CU_ASSERT_EQUAL(raw_len, sizeof(raw_A));
258 CU_ASSERT(memcmp(raw, raw_A, sizeof(raw_A)) == 0);
259
260 /* len */
261 ret = spdk_base64_urlsafe_decode(NULL, &raw_len, text_urlsafe_B);
262 CU_ASSERT_EQUAL(ret, 0);
263 CU_ASSERT_EQUAL(raw_len, sizeof(raw_B));
264
265 /* decode */
266 ret = spdk_base64_urlsafe_decode(raw, &raw_len, text_urlsafe_B);
267 CU_ASSERT_EQUAL(ret, 0);
268 CU_ASSERT_EQUAL(raw_len, sizeof(raw_B));
269 CU_ASSERT(memcmp(raw, raw_B, sizeof(raw_B)) == 0);
270
271 /* len */
272 ret = spdk_base64_urlsafe_decode(NULL, &raw_len, text_urlsafe_C);
273 CU_ASSERT_EQUAL(ret, 0);
274 CU_ASSERT_EQUAL(raw_len, sizeof(raw_C));
275
276 /* decode */
277 ret = spdk_base64_urlsafe_decode(raw, &raw_len, text_urlsafe_C);
278 CU_ASSERT_EQUAL(ret, 0);
279 CU_ASSERT_EQUAL(raw_len, sizeof(raw_C));
280 CU_ASSERT(memcmp(raw, raw_C, sizeof(raw_C)) == 0);
281
282 /* len */
283 ret = spdk_base64_urlsafe_decode(NULL, &raw_len, text_urlsafe_D);
284 CU_ASSERT_EQUAL(ret, 0);
285 CU_ASSERT_EQUAL(raw_len, sizeof(raw_D));
286
287 /* decode */
288 ret = spdk_base64_urlsafe_decode(raw, &raw_len, text_urlsafe_D);
289 CU_ASSERT_EQUAL(ret, 0);
290 CU_ASSERT_EQUAL(raw_len, sizeof(raw_D));
291 CU_ASSERT(memcmp(raw, raw_D, sizeof(raw_D)) == 0);
292
293 /* len */
294 ret = spdk_base64_urlsafe_decode(NULL, &raw_len, text_urlsafe_I);
295 CU_ASSERT_EQUAL(ret, 0);
296 CU_ASSERT_EQUAL(raw_len, sizeof(raw_I));
297
298 /* decode */
299 ret = spdk_base64_urlsafe_decode(raw, &raw_len, text_urlsafe_I);
300 CU_ASSERT_EQUAL(ret, 0);
301 CU_ASSERT_EQUAL(raw_len, sizeof(raw_I));
302 CU_ASSERT(memcmp(raw, raw_I, sizeof(raw_I)) == 0);
303
304 /* len */
305 ret = spdk_base64_urlsafe_decode(NULL, &raw_len, text_urlsafe_J);
306 CU_ASSERT_EQUAL(ret, 0);
307 CU_ASSERT_EQUAL(raw_len, sizeof(raw_J));
308
309 /* decode */
310 ret = spdk_base64_urlsafe_decode(raw, &raw_len, text_urlsafe_J);
311 CU_ASSERT_EQUAL(ret, 0);
312 CU_ASSERT_EQUAL(raw_len, sizeof(raw_J));
313 CU_ASSERT(memcmp(raw, raw_J, sizeof(raw_J)) == 0);
314
315 ret = spdk_base64_urlsafe_decode(raw, &raw_len, text_E);
316 CU_ASSERT_EQUAL(ret, -EINVAL);
317 ret = spdk_base64_urlsafe_decode(raw, &raw_len, text_F);
318 CU_ASSERT_EQUAL(ret, -EINVAL);
319 ret = spdk_base64_urlsafe_decode(raw, &raw_len, text_G);
320 CU_ASSERT_EQUAL(ret, -EINVAL);
321 ret = spdk_base64_urlsafe_decode(raw, &raw_len, text_H);
322 CU_ASSERT_EQUAL(ret, -EINVAL);
323 ret = spdk_base64_urlsafe_decode(raw, &raw_len, NULL);
324 CU_ASSERT_EQUAL(ret, -EINVAL);
325 }
326
327 int
main(int argc,char ** argv)328 main(int argc, char **argv)
329 {
330 CU_pSuite suite = NULL;
331 unsigned int num_failures;
332
333 CU_initialize_registry();
334
335 suite = CU_add_suite("base64", NULL, NULL);
336
337 CU_ADD_TEST(suite, test_base64_get_encoded_strlen);
338 CU_ADD_TEST(suite, test_base64_get_decoded_len);
339 CU_ADD_TEST(suite, test_base64_encode);
340 CU_ADD_TEST(suite, test_base64_decode);
341 CU_ADD_TEST(suite, test_base64_urlsafe_encode);
342 CU_ADD_TEST(suite, test_base64_urlsafe_decode);
343
344
345 num_failures = spdk_ut_run_tests(argc, argv, NULL);
346
347 CU_cleanup_registry();
348
349 return num_failures;
350 }
351