1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include "spdk/stdinc.h" 7 8 #include "spdk_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 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 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 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 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 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 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 328 main(int argc, char **argv) 329 { 330 CU_pSuite suite = NULL; 331 unsigned int num_failures; 332 333 CU_set_error_action(CUEA_ABORT); 334 CU_initialize_registry(); 335 336 suite = CU_add_suite("base64", NULL, NULL); 337 338 CU_ADD_TEST(suite, test_base64_get_encoded_strlen); 339 CU_ADD_TEST(suite, test_base64_get_decoded_len); 340 CU_ADD_TEST(suite, test_base64_encode); 341 CU_ADD_TEST(suite, test_base64_decode); 342 CU_ADD_TEST(suite, test_base64_urlsafe_encode); 343 CU_ADD_TEST(suite, test_base64_urlsafe_decode); 344 345 CU_basic_set_mode(CU_BRM_VERBOSE); 346 347 CU_basic_run_tests(); 348 349 num_failures = CU_get_number_of_failures(); 350 CU_cleanup_registry(); 351 352 return num_failures; 353 } 354