1 /* Start of run.c test */
8 #include <ccan/base64/base64.h>
9 #include <ccan/tap/tap.h>
11 #include <ccan/base64/base64.c>
14 static void * xmalloc(size_t size);
16 /* not defined in terms of test_encode_using_maps so we cross
17 appropriate paths in library */
18 #define test_encode(src,srclen,expected) \
22 destlen = base64_encoded_length(srclen); \
23 destlen++; /* null termination */ \
24 dest = xmalloc(destlen); \
25 ok1(base64_encode(dest,destlen,src,srclen) != -1); \
26 is_str(dest,expected); \
30 #define test_encode_using_alphabet(alphastring,src,srclen,expected) \
35 base64_init_maps(&maps,alphastring); \
36 destlen = base64_encoded_length(srclen); \
37 destlen++; /* null termination */ \
38 dest = xmalloc(destlen); \
39 ok1(base64_encode_using_maps(&maps,dest,destlen,src,srclen) != -1); \
40 is_str(dest,expected); \
44 /* not defined in terms of test_decode_using_alphabet so we cross
45 appropriate paths in library */
46 #define test_decode(src,srclen,expected,expectedlen) \
51 destlen = base64_decoded_length(srclen); \
52 dest = xmalloc(destlen); \
53 ok1((bytes_used = base64_decode(dest,destlen,src,srclen)) != -1); \
54 is_size_t(bytes_used,expectedlen); \
55 is_mem(dest,expected,bytes_used); \
59 #define test_decode_using_alphabet(alphastring,src,srclen,expected,expectedlen) \
66 base64_init_maps(&maps,alphastring); \
67 destlen = base64_decoded_length(srclen); \
68 dest = xmalloc(destlen); \
69 ok1((bytes_used = base64_decode_using_maps(&maps,dest,destlen,src,srclen)) != -1); \
70 is_size_t(bytes_used,expectedlen); \
71 is_mem(dest,expected,bytes_used); \
75 #define check_bad_range_decode(stuff_to_test,stufflen) \
79 is_size_t(base64_decode(dest,sizeof(dest),stuff_to_test,(size_t)stufflen), \
85 main(int argc, char *argv[])
89 is_size_t(base64_encoded_length(0),(size_t)0);
90 is_size_t(base64_encoded_length(1),(size_t)4);
91 is_size_t(base64_encoded_length(2),(size_t)4);
92 is_size_t(base64_encoded_length(3),(size_t)4);
93 is_size_t(base64_encoded_length(512),(size_t)684);
95 /* straight from page 11 of http://tools.ietf.org/html/rfc4648 */
97 test_encode("f",1,"Zg==");
98 test_encode("fo",2,"Zm8=");
100 test_encode("foo",3,"Zm9v");
101 test_encode("foob",4,"Zm9vYg==");
102 test_encode("fooba",5,"Zm9vYmE=");
103 test_encode("foobar",6,"Zm9vYmFy");
106 test_encode("foobarb",7,"Zm9vYmFyYg==");
107 test_encode("foobarba",8,"Zm9vYmFyYmE=");
108 test_encode("foobarbaz",9,"Zm9vYmFyYmF6");
110 test_encode("foobart",7,"Zm9vYmFydA==");
112 test_encode("abcdefghijklmnopqrstuvwxyz",26,"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo=");
113 test_encode("\x05\x05\x01\x00\x07",5,"BQUBAAc=");
115 test_encode("FOO",3,"Rk9P");
116 test_encode("Z",1,"Wg==");
120 test_decode("",0,"",0);
121 test_decode("Zg==",4,"f",1);
122 test_decode("Zm8=",4,"fo",2);
123 test_decode("Zm9v",4,"foo",3);
124 test_decode("Zm9vYg==",8,"foob",4);
125 test_decode("Zm9vYmE=",8,"fooba",5);
126 test_decode("Zm9vYmFy",8,"foobar",6);
127 test_decode("Zm9vYmFyYg==",12,"foobarb",7);
128 test_decode("Zm9vYmFyYmE=",12,"foobarba",8);
129 test_decode("Zm9vYmFyYmF6",12,"foobarbaz",9);
131 test_decode("Rk9P",4,"FOO",3);
133 test_decode("Wg==",4,"Z",1);
134 test_decode("AA==",4,"\0",1);
135 test_decode("AAA=",4,"\0\0",2);
138 const char *binary = "\x01\x00\x03";
139 const size_t binarylen = 3;
145 size_t decoded_space_required;
147 size_t encoded_space_required = base64_encoded_length(binarylen);
148 encoded_space_required++; /* null termination */
149 encoded = xmalloc(encoded_space_required);
150 encoded_len = base64_encode(encoded,encoded_space_required,binary,binarylen);
151 is_mem(encoded,"AQAD",encoded_len);
153 decoded_space_required = base64_decoded_length(encoded_len);
154 decoded = xmalloc(decoded_space_required);
155 decoded_len = base64_decode(decoded,decoded_space_required,encoded,encoded_len);
156 is_size_t(decoded_len,binarylen);
157 is_mem(binary,decoded,decoded_len);
160 /* some expected encode failures: */
165 is_size_t(base64_encode(dest,destlen,"A",1),(size_t)-1);
166 is_int(errno,EOVERFLOW);
169 /* some expected decode failures: */
172 const char * src = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
173 base64_init_maps(&maps,src);
175 is_int(sixbit_from_b64(&maps,'\xfe'),(signed char)-1);
182 is_size_t(base64_decode(dest,destlen,"A",1),(size_t)-1);
183 is_int(errno,EINVAL);
189 is_size_t(base64_decode(dest,destlen,"A",1),(size_t)-1);
190 is_int(errno,EOVERFLOW);
193 /* (char)1 is not a valid base64 character: */
194 check_bad_range_decode("A\x01",2);
195 /* (char)255 is not a valid base64 character: (char is signed on most platforms, so this is actually < 0 */
196 check_bad_range_decode("\xff""A",2);
197 check_bad_range_decode("A\xff",2);
198 check_bad_range_decode("AA\xff",3);
199 check_bad_range_decode("A\xff""A",3);
200 check_bad_range_decode("\xff""AA",3);
201 check_bad_range_decode("AAA\xff",4);
202 check_bad_range_decode("\xff\x41\x41\x41\x41",5);
203 check_bad_range_decode("A\xff\x41\x41\x41\x41",6);
204 check_bad_range_decode("AA\xff\x41\x41\x41\x41",7);
205 check_bad_range_decode("AAA\xff\x41\x41\x41\x41",8);
207 /* trigger some failures in the sixbit-to-b64 encoder: */
208 /* this function now aborts rather than returning -1/setting errno */
210 /* is_int(sixbit_to_b64(base64_maps_rfc4648,'\x70'),(char)-1); */
211 /* is_int(sixbit_to_b64(base64_maps_rfc4648,'\xff'),(char)-1); */
213 /* following tests all of the mapping from b64 chars to 6-bit values: */
214 test_decode("//+FwHRSRIsFU2IhAEGD+AMPhOA=",28,"\xff\xff\x85\xc0\x74\x52\x44\x8b\x05\x53\x62\x21\x00\x41\x83\xf8\x03\x0f\x84\xe0",20);
215 test_encode("\xff\xff\x85\xc0\x74\x52\x44\x8b\x05\x53\x62\x21\x00\x41\x83\xf8\x03\x0f\x84\xe0",20,"//+FwHRSRIsFU2IhAEGD+AMPhOA=");
218 /* check the null-padding stuff */
222 memset(dest,'\1',sizeof(dest));
223 is_size_t(base64_encode(dest,destlen,"A",1),(size_t)4);
224 is_mem(&dest[4],"\0\0\0\0",4);
229 memset(dest,'\1',sizeof(dest));
230 is_size_t(base64_decode(dest,destlen,"Wg==",4), 1);
231 is_mem(&dest[1],"\0",2);
234 /* test encoding using different alphabets */
236 char alphabet_fs_safe[64];
237 memcpy(alphabet_fs_safe,base64_maps_rfc4648.encode_map,sizeof(alphabet_fs_safe));
238 alphabet_fs_safe[62] = '-';
239 alphabet_fs_safe[63] = '_';
240 test_encode_using_alphabet(alphabet_fs_safe,"\xff\xff\x85\xc0\x74\x52\x44\x8b\x05\x53\x62\x21\x00\x41\x83\xf8\x03\x0f\x84\xe0",20,"__-FwHRSRIsFU2IhAEGD-AMPhOA=");
243 /* test decoding using different alphabets */
245 char alphabet_fs_safe[64];
246 #define src "__-FwHRSRIsFU2IhAEGD-AMPhOA="
247 #define expected "\xff\xff\x85\xc0\x74\x52\x44\x8b\x05\x53\x62\x21\x00\x41\x83\xf8\x03\x0f\x84\xe0"
249 memcpy(alphabet_fs_safe,base64_maps_rfc4648.encode_map,sizeof(alphabet_fs_safe));
250 alphabet_fs_safe[62] = '-';
251 alphabet_fs_safe[63] = '_';
253 test_decode_using_alphabet(alphabet_fs_safe,src,strlen(src),expected,20);
258 /* explicitly test the non-maps encode_triplet and
259 encode_tail functions */
263 const char *src = "AB\04";
264 memset(dest,'\1',sizeof(dest));
265 base64_encode_triplet(dest,src);
266 is_mem(dest,"QUIE",sizeof(dest));
271 const char *src = "A";
272 memset(dest,'\1',sizeof(dest));
273 base64_encode_tail(dest,src,strlen(src));
274 is_mem(dest,"QQ==",sizeof(dest));
277 /* test the alphabet inversion */
280 const char expected_inverse[] =
281 "\xff\xff\xff\xff\xff" /* 0 */
282 "\xff\xff\xff\xff\xff" /* 5 */
283 "\xff\xff\xff\xff\xff" /* 10 */
284 "\xff\xff\xff\xff\xff" /* 15 */
285 "\xff\xff\xff\xff\xff" /* 20 */
286 "\xff\xff\xff\xff\xff" /* 25 */
287 "\xff\xff\xff\xff\xff" /* 30 */
288 "\xff\xff\xff\xff\xff" /* 35 */
289 "\xff\xff\xff\x3e\xff" /* 40 */
290 "\xff\xff\x3f\x34\x35" /* 45 - */
291 "\x36\x37\x38\x39\x3a" /* 50 */
292 "\x3b\x3c\x3d\xff\xff" /* 55 */
293 "\xff\xff\xff\xff\xff" /* 60 */
294 "\x00\x01\x02\x03\x04" /* 65 A */
295 "\x05\x06\x07\x08\x09" /* 70 */
296 "\x0a\x0b\x0c\x0d\x0e" /* 75 */
297 "\x0f\x10\x11\x12\x13" /* 80 */
298 "\x14\x15\x16\x17\x18" /* 85 */
299 "\x19\xff\xff\xff\xff" /* 90 */
300 "\xff\xff\x1a\x1b\x1c" /* 95 _ */
301 "\x1d\x1e\x1f\x20\x21" /* 100 */
302 "\x22\x23\x24\x25\x26" /* 105 */
303 "\x27\x28\x29\x2a\x2b" /* 110 */
304 "\x2c\x2d\x2e\x2f\x30" /* 115 */
305 "\x31\x32\x33\xff\xff" /* 120 */
306 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" /* 125 */
307 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
308 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
309 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" /* 155 */
310 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
311 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
312 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" /* 185 */
313 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
314 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
315 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" /* 215 */
316 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
317 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
318 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" /* 245 */
320 const char * src = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
321 base64_init_maps(&dest, src);
322 is_mem((const char *)dest.decode_map, expected_inverse, 256);
323 ok1(base64_char_in_alphabet(&dest,'A'));
324 ok1(!base64_char_in_alphabet(&dest,'\n'));
327 /* explicitly test the non-alpha decode_tail and decode_quartet */
330 const char *src = "QQ==";
331 const char * expected = "A";
332 memset(dest, '%', sizeof(dest));
333 base64_decode_tail(dest,src,4);
334 is_mem(dest, expected, 1);
338 const char *src = "Zm9v";
339 const char * expected = "foo";
340 memset(dest, '%', sizeof(dest));
341 base64_decode_quartet(dest,src);
342 is_mem(dest, expected, 1);
348 static void * xmalloc(size_t size)
359 /* End of run.c test */