1 /*-
2 * SSLsplit - transparent SSL/TLS interception
3 * https://www.roe.ch/SSLsplit
4 *
5 * Copyright (c) 2009-2019, Daniel Roethlisberger <daniel@roe.ch>.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 * 1. Redistributions of source code must retain the above copyright notice,
11 * this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright notice,
13 * this list of conditions and the following disclaimer in the documentation
14 * and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "base64.h"
30
31 #include <string.h>
32
33 #include <check.h>
34
35 static const char *plain01 = "any carnal pleasure.";
36 static const char *plain02 = "any carnal pleasure";
37 static const char *plain03 = "any carnal pleasur";
38 static const char *plain04 = "any carnal pleasu";
39 static const char *plain05 = "any carnal pleas";
40
41 static const char *coded01 = "YW55IGNhcm5hbCBwbGVhc3VyZS4=";
42 static const char *coded02 = "YW55IGNhcm5hbCBwbGVhc3VyZQ==";
43 static const char *coded03 = "YW55IGNhcm5hbCBwbGVhc3Vy";
44 static const char *coded04 = "YW55IGNhcm5hbCBwbGVhc3U=";
45 static const char *coded05 = "YW55IGNhcm5hbCBwbGVhcw==";
46
47 static const char *coded06 = "YW55=GNhcm5hbCBwbGVhcw==";
48 static const char *coded07 = "YW55I=Nhcm5hbCBwbGVhcw==";
49 static const char *coded08 = "YW55IG=hcm5hbCBwbGVhcw==";
50 static const char *coded09 = "YW55IGN=cm5hbCBwbGVhcw==";
51 static const char *coded10 = "YW55\nGNhcm5hbCBwbGVhcw==";
52 static const char *coded11 = "YW55 GNhcm5hbCBwbGVhcw==";
53 static const char *coded12 = "YW55-GNhcm5hbCBwbGVhcw==";
54 static const char *coded13 = "YW55%GNhcm5hbCBwbGVhcw==";
55 static const char *coded14 = "YW55IGNhcm5hbCBwbGVhcw=";
56 static const char *coded15 = "YW55IGNhcm5hbCBwbGVhcw";
57
START_TEST(base64_enc_01)58 START_TEST(base64_enc_01)
59 {
60 char *buf;
61 size_t sz;
62
63 buf = base64_enc((unsigned char *)plain01, strlen(plain01), &sz);
64 fail_unless(!!buf, "no buffer returned");
65 fail_unless(sz == strlen(coded01), "wrong length");
66 fail_unless(!memcmp(coded01, buf, sz), "wrong data");
67 free(buf);
68 }
69 END_TEST
70
START_TEST(base64_enc_02)71 START_TEST(base64_enc_02)
72 {
73 char *buf;
74 size_t sz;
75
76 buf = base64_enc((unsigned char *)plain02, strlen(plain02), &sz);
77 fail_unless(!!buf, "no buffer returned");
78 fail_unless(sz == strlen(coded02), "wrong length");
79 fail_unless(!memcmp(coded02, buf, sz), "wrong data");
80 free(buf);
81 }
82 END_TEST
83
START_TEST(base64_enc_03)84 START_TEST(base64_enc_03)
85 {
86 char *buf;
87 size_t sz;
88
89 buf = base64_enc((unsigned char *)plain03, strlen(plain03), &sz);
90 fail_unless(!!buf, "no buffer returned");
91 fail_unless(sz == strlen(coded03), "wrong length");
92 fail_unless(!memcmp(coded03, buf, sz), "wrong data");
93 free(buf);
94 }
95 END_TEST
96
START_TEST(base64_enc_04)97 START_TEST(base64_enc_04)
98 {
99 char *buf;
100 size_t sz;
101
102 buf = base64_enc((unsigned char *)plain04, strlen(plain04), &sz);
103 fail_unless(!!buf, "no buffer returned");
104 fail_unless(sz == strlen(coded04), "wrong length");
105 fail_unless(!memcmp(coded04, buf, sz), "wrong data");
106 free(buf);
107 }
108 END_TEST
109
START_TEST(base64_enc_05)110 START_TEST(base64_enc_05)
111 {
112 char *buf;
113 size_t sz;
114
115 buf = base64_enc((unsigned char *)plain05, strlen(plain05), &sz);
116 fail_unless(!!buf, "no buffer returned");
117 fail_unless(sz == strlen(coded05), "wrong length");
118 fail_unless(!memcmp(coded05, buf, sz), "wrong data");
119 free(buf);
120 }
121 END_TEST
122
START_TEST(base64_enc_06)123 START_TEST(base64_enc_06)
124 {
125 char *buf;
126 size_t sz;
127
128 buf = base64_enc((unsigned char *)"", 0, &sz);
129 fail_unless(!!buf, "no buffer returned");
130 fail_unless(!sz, "length not 0");
131 fail_unless(!buf[0], "not empty string");
132 free(buf);
133 }
134 END_TEST
135
START_TEST(base64_dec_01)136 START_TEST(base64_dec_01)
137 {
138 unsigned char *buf;
139 size_t sz;
140
141 buf = base64_dec(coded01, strlen(coded01), &sz);
142 fail_unless(!!buf, "no buffer returned");
143 fail_unless(sz == strlen(plain01), "wrong length");
144 fail_unless(!memcmp(plain01, buf, sz), "wrong data");
145 free(buf);
146 }
147 END_TEST
148
START_TEST(base64_dec_02)149 START_TEST(base64_dec_02)
150 {
151 unsigned char *buf;
152 size_t sz;
153
154 buf = base64_dec(coded02, strlen(coded02), &sz);
155 fail_unless(!!buf, "no buffer returned");
156 fail_unless(sz == strlen(plain02), "wrong length");
157 fail_unless(!memcmp(plain02, buf, sz), "wrong data");
158 free(buf);
159 }
160 END_TEST
161
START_TEST(base64_dec_03)162 START_TEST(base64_dec_03)
163 {
164 unsigned char *buf;
165 size_t sz;
166
167 buf = base64_dec(coded03, strlen(coded03), &sz);
168 fail_unless(!!buf, "no buffer returned");
169 fail_unless(sz == strlen(plain03), "wrong length");
170 fail_unless(!memcmp(plain03, buf, sz), "wrong data");
171 free(buf);
172 }
173 END_TEST
174
START_TEST(base64_dec_04)175 START_TEST(base64_dec_04)
176 {
177 unsigned char *buf;
178 size_t sz;
179
180 buf = base64_dec(coded04, strlen(coded04), &sz);
181 fail_unless(!!buf, "no buffer returned");
182 fail_unless(sz == strlen(plain04), "wrong length");
183 fail_unless(!memcmp(plain04, buf, sz), "wrong data");
184 free(buf);
185 }
186 END_TEST
187
START_TEST(base64_dec_05)188 START_TEST(base64_dec_05)
189 {
190 unsigned char *buf;
191 size_t sz;
192
193 buf = base64_dec(coded05, strlen(coded05), &sz);
194 fail_unless(!!buf, "no buffer returned");
195 fail_unless(sz == strlen(plain05), "wrong length");
196 fail_unless(!memcmp(plain05, buf, sz), "wrong data");
197 free(buf);
198 }
199 END_TEST
200
START_TEST(base64_dec_06)201 START_TEST(base64_dec_06)
202 {
203 unsigned char *buf;
204 size_t sz;
205
206 buf = base64_dec(coded06, strlen(coded06), &sz);
207 fail_unless(!buf, "buffer returned");
208 }
209 END_TEST
210
START_TEST(base64_dec_07)211 START_TEST(base64_dec_07)
212 {
213 unsigned char *buf;
214 size_t sz;
215
216 buf = base64_dec(coded07, strlen(coded07), &sz);
217 fail_unless(!buf, "buffer returned");
218 }
219 END_TEST
220
START_TEST(base64_dec_08)221 START_TEST(base64_dec_08)
222 {
223 unsigned char *buf;
224 size_t sz;
225
226 buf = base64_dec(coded08, strlen(coded08), &sz);
227 fail_unless(!buf, "buffer returned");
228 }
229 END_TEST
230
START_TEST(base64_dec_09)231 START_TEST(base64_dec_09)
232 {
233 unsigned char *buf;
234 size_t sz;
235
236 buf = base64_dec(coded09, strlen(coded09), &sz);
237 fail_unless(!buf, "buffer returned");
238 }
239 END_TEST
240
START_TEST(base64_dec_10)241 START_TEST(base64_dec_10)
242 {
243 unsigned char *buf;
244 size_t sz;
245
246 buf = base64_dec(coded10, strlen(coded10), &sz);
247 fail_unless(!buf, "buffer returned");
248 }
249 END_TEST
250
START_TEST(base64_dec_11)251 START_TEST(base64_dec_11)
252 {
253 unsigned char *buf;
254 size_t sz;
255
256 buf = base64_dec(coded11, strlen(coded11), &sz);
257 fail_unless(!buf, "buffer returned");
258 }
259 END_TEST
260
START_TEST(base64_dec_12)261 START_TEST(base64_dec_12)
262 {
263 unsigned char *buf;
264 size_t sz;
265
266 buf = base64_dec(coded12, strlen(coded12), &sz);
267 fail_unless(!buf, "buffer returned");
268 }
269 END_TEST
270
START_TEST(base64_dec_13)271 START_TEST(base64_dec_13)
272 {
273 unsigned char *buf;
274 size_t sz;
275
276 buf = base64_dec(coded13, strlen(coded13), &sz);
277 fail_unless(!buf, "buffer returned");
278 }
279 END_TEST
280
START_TEST(base64_dec_14)281 START_TEST(base64_dec_14)
282 {
283 unsigned char *buf;
284 size_t sz;
285
286 buf = base64_dec(coded14, strlen(coded14), &sz);
287 fail_unless(!buf, "buffer returned");
288 }
289 END_TEST
290
START_TEST(base64_dec_15)291 START_TEST(base64_dec_15)
292 {
293 unsigned char *buf;
294 size_t sz;
295
296 buf = base64_dec(coded15, strlen(coded15), &sz);
297 fail_unless(!buf, "buffer returned");
298 }
299 END_TEST
300
START_TEST(base64_dec_16)301 START_TEST(base64_dec_16)
302 {
303 unsigned char *buf;
304 size_t sz;
305
306 buf = base64_dec("", 0, &sz);
307 fail_unless(!!buf, "no buffer returned");
308 fail_unless(!sz, "length not 0");
309 fail_unless(!buf[0], "not empty string");
310 free(buf);
311 }
312 END_TEST
313
314 Suite *
base64_suite(void)315 base64_suite(void)
316 {
317 Suite *s;
318 TCase *tc;
319
320 s = suite_create("base64");
321
322 tc = tcase_create("base64_enc");
323 tcase_add_test(tc, base64_enc_01);
324 tcase_add_test(tc, base64_enc_02);
325 tcase_add_test(tc, base64_enc_03);
326 tcase_add_test(tc, base64_enc_04);
327 tcase_add_test(tc, base64_enc_05);
328 tcase_add_test(tc, base64_enc_06);
329 suite_add_tcase(s, tc);
330
331 tc = tcase_create("base64_dec");
332 tcase_add_test(tc, base64_dec_01);
333 tcase_add_test(tc, base64_dec_02);
334 tcase_add_test(tc, base64_dec_03);
335 tcase_add_test(tc, base64_dec_04);
336 tcase_add_test(tc, base64_dec_05);
337 tcase_add_test(tc, base64_dec_06);
338 tcase_add_test(tc, base64_dec_07);
339 tcase_add_test(tc, base64_dec_08);
340 tcase_add_test(tc, base64_dec_09);
341 tcase_add_test(tc, base64_dec_10);
342 tcase_add_test(tc, base64_dec_11);
343 tcase_add_test(tc, base64_dec_12);
344 tcase_add_test(tc, base64_dec_13);
345 tcase_add_test(tc, base64_dec_14);
346 tcase_add_test(tc, base64_dec_15);
347 tcase_add_test(tc, base64_dec_16);
348 suite_add_tcase(s, tc);
349
350 return s;
351 }
352
353 /* vim: set noet ft=c: */
354