commit 902aa5b3a46da72a3e080d3c1844cc65c8bd169d Author: Zack Weinberg zackw@cmu.edu Date: Fri Jun 15 13:38:34 2012 -0700

Overhaul base64 cookie generation. Add unit testing of base64. This fixes the bug where an HTTP cookie header could have a newline in it. --- Makefile.am | 1 + src/base64.cc | 69 +++++++----- src/base64.h | 21 +++- src/steg/b64cookies.cc | 262 +++++++++--------------------------------- src/steg/b64cookies.h | 7 +- src/steg/http.cc | 69 ++++-------- src/test/unittest_base64.cc | 194 ++++++++++++++++++++++++++++++++ 7 files changed, 336 insertions(+), 287 deletions(-)

diff --git a/Makefile.am b/Makefile.am index d21fdde..513e848 100644 --- a/Makefile.am +++ b/Makefile.am @@ -54,6 +54,7 @@ stegotorus_SOURCES = \ src/main.cc

UTGROUPS = \ + src/test/unittest_base64.cc \ src/test/unittest_compression.cc \ src/test/unittest_config.cc \ src/test/unittest_crypt.cc \ diff --git a/src/base64.cc b/src/base64.cc index 8d53d0f..f742e2d 100644 --- a/src/base64.cc +++ b/src/base64.cc @@ -8,18 +8,25 @@ const int CHARS_PER_LINE = 72;

static char -encode1(char v) +encode1(unsigned int value, char plus, char slash, char eq) { const char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz0123456789+/"; - unsigned int value_in = v; - if (value_in > sizeof(encoding)-1) return '='; - return encoding[value_in]; + if (value > sizeof encoding - 1) + return eq; + + char rv = encoding[value]; + if (rv == '+') + return plus; + else if (rv == '/') + return slash; + else + return rv; }

/* assumes ASCII */ static int -decode1(char v) +decode1(unsigned int value, char plus, char slash) { const signed char decoding[] = { // + , - . / 0 1 2 3 4 5 6 7 8 9 @@ -38,11 +45,15 @@ decode1(char v) 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 };

- unsigned int value_in = v; - value_in -= 43; - if (value_in > sizeof(decoding)) + if (value == (unsigned int)plus) + value = '+'; + else if (value == (unsigned int)slash) + value = '/'; + + value -= 43; + if (value > sizeof(decoding)) return -1; - return decoding[value_in]; + return decoding[value]; }

namespace base64 @@ -69,7 +80,7 @@ encoder::encode(const char* plaintext_in, size_t length_in, char* code_out) } fragment = *plainchar++; result = (fragment & 0x0fc) >> 2; - *codechar++ = encode1(result); + *codechar++ = encode1(result, plus, slash, equals); result = (fragment & 0x003) << 4; case step_B: if (plainchar == plaintextend) { @@ -79,7 +90,7 @@ encoder::encode(const char* plaintext_in, size_t length_in, char* code_out) } fragment = *plainchar++; result |= (fragment & 0x0f0) >> 4; - *codechar++ = encode1(result); + *codechar++ = encode1(result, plus, slash, equals); result = (fragment & 0x00f) << 2; case step_C: if (plainchar == plaintextend) { @@ -89,14 +100,16 @@ encoder::encode(const char* plaintext_in, size_t length_in, char* code_out) } fragment = *plainchar++; result |= (fragment & 0x0c0) >> 6; - *codechar++ = encode1(result); + *codechar++ = encode1(result, plus, slash, equals); result = (fragment & 0x03f) >> 0; - *codechar++ = encode1(result); + *codechar++ = encode1(result, plus, slash, equals);

- ++(this->stepcount); - if (this->stepcount == CHARS_PER_LINE/4) { - *codechar++ = '\n'; - this->stepcount = 0; + if (wrap) { + ++(this->stepcount); + if (this->stepcount == CHARS_PER_LINE/4) { + *codechar++ = '\n'; + this->stepcount = 0; + } } } default: @@ -111,18 +124,20 @@ encoder::encode_end(char* code_out)

switch (this->step) { case step_B: - *codechar++ = encode1(this->result); - *codechar++ = '='; - *codechar++ = '='; + *codechar++ = encode1(this->result, plus, slash, equals); + *codechar++ = equals; + *codechar++ = equals; break; case step_C: - *codechar++ = encode1(this->result); - *codechar++ = '='; + *codechar++ = encode1(this->result, plus, slash, equals); + *codechar++ = equals; break; case step_A: break; } - *codechar++ = '\n'; + if (wrap) + *codechar++ = '\n'; + *codechar = '\0';

/* reset */ this->step = step_A; @@ -149,7 +164,7 @@ decoder::decode(const char* code_in, size_t length_in, char* plaintext_out) this->plainchar = *plainchar; return plainchar - plaintext_out; } - fragment = decode1(*codechar++); + fragment = decode1(*codechar++, plus, slash); } while (fragment < 0); *plainchar = (fragment & 0x03f) << 2; case step_B: @@ -159,7 +174,7 @@ decoder::decode(const char* code_in, size_t length_in, char* plaintext_out) this->plainchar = *plainchar; return plainchar - plaintext_out; } - fragment = decode1(*codechar++); + fragment = decode1(*codechar++, plus, slash); } while (fragment < 0); *plainchar++ |= (fragment & 0x030) >> 4; *plainchar = (fragment & 0x00f) << 4; @@ -170,7 +185,7 @@ decoder::decode(const char* code_in, size_t length_in, char* plaintext_out) this->plainchar = *plainchar; return plainchar - plaintext_out; } - fragment = decode1(*codechar++); + fragment = decode1(*codechar++, plus, slash); } while (fragment < 0); *plainchar++ |= (fragment & 0x03c) >> 2; *plainchar = (fragment & 0x003) << 6; @@ -181,7 +196,7 @@ decoder::decode(const char* code_in, size_t length_in, char* plaintext_out) this->plainchar = *plainchar; return plainchar - plaintext_out; } - fragment = decode1(*codechar++); + fragment = decode1(*codechar++, plus, slash); } while (fragment < 0); *plainchar++ |= (fragment & 0x03f); } diff --git a/src/base64.h b/src/base64.h index adc0dae..4526309 100644 --- a/src/base64.h +++ b/src/base64.h @@ -16,10 +16,18 @@ class encoder encode_step step; int stepcount; char result; + char plus; + char slash; + char equals; + bool wrap;

public: - encoder() - : step(step_A), stepcount(0), result(0) + // The optional arguments to the constructor allow you to disable + // line-wrapping and/or replace the characters used to encode digits + // 62 and 63 and padding (normally '+', '/', and '=' respectively). + encoder(bool wr = true, char pl = '+', char sl = '/', char eq = '=') + : step(step_A), stepcount(0), result(0), + plus(pl), slash(sl), equals(eq), wrap(wr) {}

ptrdiff_t encode(const char* plaintext_in, size_t length_in, char* code_out); @@ -31,10 +39,15 @@ class decoder enum decode_step { step_A, step_B, step_C, step_D }; decode_step step; char plainchar; + char plus; + char slash; + char equals; + bool wrap;

public: - decoder() - : step(step_A), plainchar(0) + decoder(char pl = '+', char sl = '/', char eq = '=') + : step(step_A), plainchar(0), + plus(pl), slash(sl), equals(eq) {}

ptrdiff_t decode(const char* code_in, size_t length_in, char* plaintext_out); diff --git a/src/steg/b64cookies.cc b/src/steg/b64cookies.cc index 4d85a8b..6f95004 100644 --- a/src/steg/b64cookies.cc +++ b/src/steg/b64cookies.cc @@ -5,230 +5,80 @@ #include "util.h" #include "b64cookies.h"

-int unwrap_b64_cookie(char* inbuf, char* outbuf, int buflen) { - int i,j; - j = 0; - - for (i=0; i < buflen; i++) { - char c = inbuf[i]; +size_t +unwrap_b64_cookies(char *outbuf, const char *inbuf, size_t inlen) +{ + size_t i, j;

+ for (i = 0, j = 0; i < inlen; i++) { + char c = inbuf[i]; if (c != ' ' && c != ';' && c != '=') - outbuf[j++] = c; + outbuf[j++] = c; }

return j; - }

- - - - -int gen_one_b64cookie(char* outbuf, int& cookielen, char* data, int datalen) { - int sofar = 0; - int namelen; - int data_consumed = 0; - - cookielen = 4 + rand() % (datalen - 3); - - if (cookielen > 13) - namelen = rand() % 10 + 1; - else - namelen = rand() % (cookielen - 3) + 1; - - - while (sofar < namelen) { - outbuf[sofar++] = data[data_consumed++]; - } - - - outbuf[sofar++] = '='; - - while (sofar < cookielen) { - outbuf[sofar++] = data[data_consumed++]; +static size_t +gen_one_cookie(char *&outbuf, const char *&inbuf, size_t inlen) +{ + size_t adv_in = 0; + size_t adv_out = 0; + size_t namelen, cookielen; + + if (inlen < 5) { + memcpy(outbuf, inbuf, inlen); + outbuf += inlen; + inbuf += inlen; + return inlen; } - - return data_consumed; - -} - - - - -/* returns length of cookie */ -int gen_b64_cookie_field(char* outbuf, char* data, int datalen) { - int onecookielen; - int consumed = 0; - int cookielen = 0; - - -

- while (datalen - consumed > 0) { - int cnt = gen_one_b64cookie(outbuf, onecookielen, data + consumed, datalen - consumed); - - if (cnt < 0) { - log_warn("couldn't create cookie: %d\n", cnt); - return cnt; - } - - consumed += cnt; - outbuf += onecookielen; - cookielen += onecookielen; - - if (datalen - consumed < 5) { - memcpy(outbuf, data+consumed, datalen-consumed); - return cookielen + datalen - consumed; - } - - - if (datalen - consumed > 0) { - outbuf[0] = ';'; - outbuf++; - cookielen++; - } - } - - - return cookielen; -} - - - -void sanitize_b64(char* input, int len) { - char* i = strchr(input, '/'); - int eqcnt = 0; - - printf("len = %d\n", len); - - while (i != NULL) { - *i = '_'; - i = strchr(i+1, '/'); - } - - i = strchr(input, '+'); - - while (i != NULL) { - *i = '.'; - i = strchr(i+1, '+'); + if (inlen < 10) { + namelen = rand() % 5 + 1; + } else { + namelen = rand() % 10 + 1; }

- if (input[len-2] == '=') - eqcnt = 2; - else if (input[len-1] == '=') - eqcnt = 1; + cookielen = rand() % (inlen * 2 / 3); + if (cookielen > inlen - namelen) + cookielen = inlen - namelen;

+ memcpy(outbuf, inbuf, namelen); + adv_in += namelen; + adv_out += namelen;

- while (eqcnt > 0) { - int pos = rand() % (len - 1) + 1; - if (pos >= len - eqcnt) { - input[pos] = '-'; - eqcnt--; - continue; - } - - //shift characters up and insert '-' in the middle - for (int j=len-eqcnt; j > pos; j--) - input[j] = input[j-1]; + outbuf[adv_out++] = '=';

- input[pos] = '-'; - eqcnt--; + memcpy(outbuf + adv_out, inbuf + adv_in, cookielen); + adv_in += cookielen; + adv_out += cookielen;

- } - + outbuf += adv_out; + inbuf += adv_in; + return adv_in; }

- -void desanitize_b64(char* input, int len) { - char* i = strchr(input, '_'); - - - printf("len = %d\n", len); - while (i != NULL) { - *i = '/'; - i = strchr(i+1, '_'); - } - - i = strchr(input, '.'); - - while (i != NULL) { - *i = '+'; - i = strchr(i+1, '.'); - } - - - i = strchr(input, '-'); - if (i != NULL) { - int j; - for (j=i-input; j < len-1; j++) - input[j] = input[j+1]; - input[len-1] = '='; - - - i = strchr(input, '-'); - - if (i != NULL) { - for (j=i-input; j < len-2; j++) - input[j] = input[j+1]; - input[len-2] = '='; +/* returns length of cookie */ +size_t +gen_b64_cookies(char *outbuf, const char *inbuf, size_t inlen) +{ + char *outp = outbuf; + const char *inp = inbuf; + size_t processed = 0; + + while (processed < inlen) { + processed += gen_one_cookie(outp, inp, inlen - processed); + + size_t remain = inlen - processed; + if (remain < 5) { + memcpy(outp, inp, remain); + outp += remain; + inp += remain; + break; } - + if (remain > 0) + *outp++ = ';'; }

+ return outp - outbuf; } - - - - - -// int main () { -// char outbuf[200]; - -// char data[56] = "ba239023820389023802380389abc2322132321932847203aedfasd"; -// char data2[200]; -// int cookielen; - -// srand(time(NULL)); - -// memset(data2, 0, sizeof(data2)); -// memset(outbuf, 0, sizeof(outbuf)); - -// base64::encoder E; -// E.encode(data, strlen(data), data2); -// E.encode_end(data2+strlen(data2)); -// printf("%s", data2); -// // remove trailing newline -// data2[strlen(data2) - 1] = 0; - -// // /* substitute / with _, + with ., = with - that maybe inserted anywhere in the middle */ - -// sanitize_b64(data2, strlen(data2)); -// printf("%s\n", data2); - -// cookielen = gen_b64_cookie_field((char*) outbuf, (char*) data2, strlen(data2)); -// printf("cookie=%s\n", outbuf); - -// memset(data2, 0, sizeof(data2)); -// cookielen = unwrap_b64_cookie((char*) outbuf, (char*) data2, strlen(outbuf)); - - -// desanitize_b64(data2, cookielen); -// printf("%s\n", data2); -// printf("%d\n", cookielen); - -// data2[strlen(data2)] = '\n'; - - -// memset(outbuf, 0, sizeof(outbuf)); - -// base64::decoder D; -// D.decode(data2, strlen(data2), outbuf); -// printf("%s\n", outbuf); - - - -// } - - - - diff --git a/src/steg/b64cookies.h b/src/steg/b64cookies.h index 1556cdd..6723f57 100644 --- a/src/steg/b64cookies.h +++ b/src/steg/b64cookies.h @@ -5,10 +5,7 @@ #ifndef _B64_COOKIES_H #define _B64_COOKIES_H

-int unwrap_b64_cookie(char* inbuf, char* outbuf, int buflen); -int gen_b64_cookie_field(char* outbuf, char* data, int datalen); -int gen_one_b64cookie(char* outbuf, int& cookielen, char* data, int datalen); -void sanitize_b64(char* input, int len); -void desanitize_b64(char* input, int len); +size_t unwrap_b64_cookies(char *outbuf, const char *inbuf, size_t inlen); +size_t gen_b64_cookies(char *outbuf, const char *inbuf, size_t inlen);

#endif diff --git a/src/steg/http.cc b/src/steg/http.cc index 171bdcb..d8dbf5e 100644 --- a/src/steg/http.cc +++ b/src/steg/http.cc @@ -262,12 +262,6 @@ int http_client_cookie_transmit (http_steg_t *s, struct evbuffer *source, conn_t *conn) { - - /* On the client side, we have to embed the data in a GET query somehow; - the only plausible places to put it are the URL and cookies. This - presently uses the URL. And it can't be binary. */ - - struct evbuffer *dest = conn->outbound(); size_t sbuflen = evbuffer_get_length(source); int bufsize = 10000; @@ -276,24 +270,24 @@ http_client_cookie_transmit (http_steg_t *s, struct evbuffer *source, char* data; char* data2 = (char*) xmalloc (sbuflen*4); char* cookiebuf = (char*) xmalloc (sbuflen*8); - int payload_len = 0; - int cnt = 0; - int cookie_len = 0; - int rval; - int len = 0; - base64::encoder E; - - + size_t payload_len = 0; + size_t cnt = 0; + size_t cookie_len = 0; + size_t rval; + size_t len = 0; + // '+' -> '-', '/' -> '_', '=' -> '.' per + // RFC4648 "Base 64 encoding with URL and filename safe alphabet" + // (which does not replace '=', but dot is an obvious choice; for + // this use case, the fact that some file systems don't allow more + // than one dot in a filename is irrelevant). + base64::encoder E(false, '-', '_', '.');

data = (char*) evbuffer_pullup(source, sbuflen); - - if (data == NULL) { + if (!data) { log_debug("evbuffer_pullup failed"); goto err; }

- - // retry up to 10 times while (!payload_len) { payload_len = find_client_payload(s->config->pl, buf, bufsize, @@ -308,28 +302,15 @@ http_client_cookie_transmit (http_steg_t *s, struct evbuffer *source, lookup_peer_name_from_ip(conn->peername, s->peer_dnsname);

memset(data2, 0, sbuflen*4); - E.encode((char*) data, sbuflen, (char*) data2); - E.encode_end(data2+strlen((char*) data2)); - - len = (int) strlen(data2) - 1; - // remove trailing newline - data2[len] = 0; - - // substitute / with _, + with ., = with - that maybe inserted anywhere in the middle - sanitize_b64(data2, len); + len = E.encode(data, sbuflen, data2); + len += E.encode_end(data2+len);

- - cookie_len = gen_b64_cookie_field(cookiebuf, data2, len); + cookie_len = gen_b64_cookies(cookiebuf, data2, len); cookiebuf[cookie_len] = 0;

- - - if (cookie_len < 0) { - log_debug("cookie generation failed\n"); - return -1; - } - log_debug(conn, "cookie input %ld encoded %d final %d", - (long)sbuflen, len, cookie_len); + log_debug(conn, "cookie input %lu encoded %lu final %lu/%lu", + (unsigned long)sbuflen, (unsigned long)len, + (unsigned long)cookie_len, strlen(cookiebuf)); log_debug(conn, "cookie encoded: %s", data2); log_debug(conn, "cookie final: %s", cookiebuf);

@@ -373,14 +354,12 @@ http_client_cookie_transmit (http_steg_t *s, struct evbuffer *source,

rval = evbuffer_add(dest, "\r\n\r\n", 4); - + if (rval) { log_warn("error adding terminators \n"); goto err; }

- - evbuffer_drain(source, sbuflen); log_debug("CLIENT TRANSMITTED payload %d\n", (int) sbuflen); conn->cease_transmission(); @@ -625,6 +604,8 @@ http_server_receive(http_steg_t *s, conn_t *conn, struct evbuffer *dest, struct char* data; int type;

+ log_debug("Receive dump:"); + do { struct evbuffer_ptr s2 = evbuffer_search(source, "\r\n\r\n", sizeof ("\r\n\r\n") -1 , NULL); char *p; @@ -662,6 +643,7 @@ http_server_receive(http_steg_t *s, conn_t *conn, struct evbuffer *dest, struct else p = data + sizeof "GET /" -1;

+ log_debug("Cookie: %s", p); pend = strstr(p, "\r\n"); log_assert(pend); if (pend - p > MAX_COOKIE_SIZE * 3/2) @@ -669,13 +651,10 @@ http_server_receive(http_steg_t *s, conn_t *conn, struct evbuffer *dest, struct (unsigned long)(pend - p), (unsigned long)MAX_COOKIE_SIZE);

memset(outbuf, 0, sizeof(outbuf)); - int cookielen = unwrap_b64_cookie((char*) p, (char*) outbuf, pend - p); + size_t cookielen = unwrap_b64_cookies(outbuf, p, pend - p);

- desanitize_b64(outbuf, cookielen); - outbuf[cookielen] = '\n'; + base64::decoder D('-', '_', '.'); memset(outbuf2, 0, sizeof(outbuf2)); - - base64::decoder D; sofar = D.decode(outbuf, cookielen+1, outbuf2);

if (sofar <= 0) diff --git a/src/test/unittest_base64.cc b/src/test/unittest_base64.cc new file mode 100644 index 0000000..76f122b --- /dev/null +++ b/src/test/unittest_base64.cc @@ -0,0 +1,194 @@ +/* Copyright 2012 SRI International + * See LICENSE for other credits and copying information + */ + +#include "util.h" +#include "unittest.h" +#include "base64.h" + +struct testvec +{ + const char *dec; + const char *enc; + size_t declen; + size_t enclen; +}; + +#define S_(x) #x +#define S(x) S_(x) + +const struct testvec testvecs[] = { + // padding tests from RFC 4648 + { "", "", 0, 0 }, + { "f", "Zg==", 1, 4 }, + { "fo", "Zm8=", 2, 4 }, + { "foo", "Zm9v", 3, 4 }, + { "foob", "Zm9vYg==", 4, 8 }, + { "fooba", "Zm9vYmE=", 5, 8 }, + { "foobar", "Zm9vYmFy", 6, 8 }, + + // all single bytes +#define B(b,e) { S(\x##b), S(e==), 1, 4 } + B(00,AA), B(01,AQ), B(02,Ag), B(03,Aw), B(04,BA), B(05,BQ), B(06,Bg), + B(07,Bw), B(08,CA), B(09,CQ), B(0a,Cg), B(0b,Cw), B(0c,DA), B(0d,DQ), + B(0e,Dg), B(0f,Dw), B(10,EA), B(11,EQ), B(12,Eg), B(13,Ew), B(14,FA), + B(15,FQ), B(16,Fg), B(17,Fw), B(18,GA), B(19,GQ), B(1a,Gg), B(1b,Gw), + B(1c,HA), B(1d,HQ), B(1e,Hg), B(1f,Hw), B(20,IA), B(21,IQ), B(22,Ig), + B(23,Iw), B(24,JA), B(25,JQ), B(26,Jg), B(27,Jw), B(28,KA), B(29,KQ), + B(2a,Kg), B(2b,Kw), B(2c,LA), B(2d,LQ), B(2e,Lg), B(2f,Lw), B(30,MA), + B(31,MQ), B(32,Mg), B(33,Mw), B(34,NA), B(35,NQ), B(36,Ng), B(37,Nw), + B(38,OA), B(39,OQ), B(3a,Og), B(3b,Ow), B(3c,PA), B(3d,PQ), B(3e,Pg), + B(3f,Pw), B(40,QA), B(41,QQ), B(42,Qg), B(43,Qw), B(44,RA), B(45,RQ), + B(46,Rg), B(47,Rw), B(48,SA), B(49,SQ), B(4a,Sg), B(4b,Sw), B(4c,TA), + B(4d,TQ), B(4e,Tg), B(4f,Tw), B(50,UA), B(51,UQ), B(52,Ug), B(53,Uw), + B(54,VA), B(55,VQ), B(56,Vg), B(57,Vw), B(58,WA), B(59,WQ), B(5a,Wg), + B(5b,Ww), B(5c,XA), B(5d,XQ), B(5e,Xg), B(5f,Xw), B(60,YA), B(61,YQ), + B(62,Yg), B(63,Yw), B(64,ZA), B(65,ZQ), B(66,Zg), B(67,Zw), B(68,aA), + B(69,aQ), B(6a,ag), B(6b,aw), B(6c,bA), B(6d,bQ), B(6e,bg), B(6f,bw), + B(70,cA), B(71,cQ), B(72,cg), B(73,cw), B(74,dA), B(75,dQ), B(76,dg), + B(77,dw), B(78,eA), B(79,eQ), B(7a,eg), B(7b,ew), B(7c,fA), B(7d,fQ), + B(7e,fg), B(7f,fw), B(80,gA), B(81,gQ), B(82,gg), B(83,gw), B(84,hA), + B(85,hQ), B(86,hg), B(87,hw), B(88,iA), B(89,iQ), B(8a,ig), B(8b,iw), + B(8c,jA), B(8d,jQ), B(8e,jg), B(8f,jw), B(90,kA), B(91,kQ), B(92,kg), + B(93,kw), B(94,lA), B(95,lQ), B(96,lg), B(97,lw), B(98,mA), B(99,mQ), + B(9a,mg), B(9b,mw), B(9c,nA), B(9d,nQ), B(9e,ng), B(9f,nw), B(a0,oA), + B(a1,oQ), B(a2,og), B(a3,ow), B(a4,pA), B(a5,pQ), B(a6,pg), B(a7,pw), + B(a8,qA), B(a9,qQ), B(aa,qg), B(ab,qw), B(ac,rA), B(ad,rQ), B(ae,rg), + B(af,rw), B(b0,sA), B(b1,sQ), B(b2,sg), B(b3,sw), B(b4,tA), B(b5,tQ), + B(b6,tg), B(b7,tw), B(b8,uA), B(b9,uQ), B(ba,ug), B(bb,uw), B(bc,vA), + B(bd,vQ), B(be,vg), B(bf,vw), B(c0,wA), B(c1,wQ), B(c2,wg), B(c3,ww), + B(c4,xA), B(c5,xQ), B(c6,xg), B(c7,xw), B(c8,yA), B(c9,yQ), B(ca,yg), + B(cb,yw), B(cc,zA), B(cd,zQ), B(ce,zg), B(cf,zw), B(d0,0A), B(d1,0Q), + B(d2,0g), B(d3,0w), B(d4,1A), B(d5,1Q), B(d6,1g), B(d7,1w), B(d8,2A), + B(d9,2Q), B(da,2g), B(db,2w), B(dc,3A), B(dd,3Q), B(de,3g), B(df,3w), + B(e0,4A), B(e1,4Q), B(e2,4g), B(e3,4w), B(e4,5A), B(e5,5Q), B(e6,5g), + B(e7,5w), B(e8,6A), B(e9,6Q), B(ea,6g), B(eb,6w), B(ec,7A), B(ed,7Q), + B(ee,7g), B(ef,7w), B(f0,8A), B(f1,8Q), B(f2,8g), B(f3,8w), B(f4,9A), + B(f5,9Q), B(f6,9g), B(f7,9w), B(f8,+A), B(f9,+Q), B(fa,+g), B(fb,+w), + B(fc,/A), B(fd,/Q), B(fe,/g), B(ff,/w), +#undef B + + // all single base64 digits, padded on the left and the right with an A +#define D(d1,d2,e) { S(\x##d1\x##d2), "A" S(e) "A=", 2, 4 } + D(00,00,A), D(00,10,B), D(00,20,C), D(00,30,D), D(00,40,E), + D(00,50,F), D(00,60,G), D(00,70,H), D(00,80,I), D(00,90,J), + D(00,a0,K), D(00,b0,L), D(00,c0,M), D(00,d0,N), D(00,e0,O), + D(00,f0,P), D(01,00,Q), D(01,10,R), D(01,20,S), D(01,30,T), + D(01,40,U), D(01,50,V), D(01,60,W), D(01,70,X), D(01,80,Y), + D(01,90,Z), D(01,a0,a), D(01,b0,b), D(01,c0,c), D(01,d0,d), + D(01,e0,e), D(01,f0,f), D(02,00,g), D(02,10,h), D(02,20,i), + D(02,30,j), D(02,40,k), D(02,50,l), D(02,60,m), D(02,70,n), + D(02,80,o), D(02,90,p), D(02,a0,q), D(02,b0,r), D(02,c0,s), + D(02,d0,t), D(02,e0,u), D(02,f0,v), D(03,00,w), D(03,10,x), + D(03,20,y), D(03,30,z), D(03,40,0), D(03,50,1), D(03,60,2), + D(03,70,3), D(03,80,4), D(03,90,5), D(03,a0,6), D(03,b0,7), + D(03,c0,8), D(03,d0,9), D(03,e0,+), D(03,f0,/), +#undef D + + { 0, 0, 0, 0 } +}; + + +static void +test_base64_standard(void *) +{ + base64::encoder E(false); + base64::decoder D; + + char buf[16]; + + for (const struct testvec *tv = testvecs; tv->dec; tv++) { + size_t len = E.encode(tv->dec, tv->declen, buf); + E.encode_end(buf + len); + tt_str_op(buf, ==, tv->enc); + + len = D.decode(tv->enc, tv->enclen, buf); + D.reset(); + tt_uint_op(len, ==, tv->declen); + tt_mem_op(buf, ==, tv->dec, tv->declen); + } + + end:; +} + +static void +test_base64_altpunct(void *) +{ + base64::encoder E(false, '-', '_', '.'); + base64::decoder D('-', '_', '.'); + + char buf[16]; + char cenc[16]; + + for (const struct testvec *tv = testvecs; tv->dec; tv++) { + memcpy(cenc, tv->enc, tv->enclen); + cenc[tv->enclen] = '\0'; + for (size_t i = 0; i < tv->enclen; i++) + switch (cenc[i]) { + default: break; + case '+': cenc[i] = '-'; break; + case '/': cenc[i] = '_'; break; + case '=': cenc[i] = '.'; break; + } + + size_t len = E.encode(tv->dec, tv->declen, buf); + E.encode_end(buf + len); + tt_str_op(buf, ==, cenc); + + len = D.decode(cenc, tv->enclen, buf); + D.reset(); + tt_uint_op(len, ==, tv->declen); + tt_mem_op(buf, ==, tv->dec, tv->declen); + } + + end:; +} + +static void +test_base64_wrapping(void *) +{ + const char in[] = + "..........................................." + "..........................................." + "..........................................."; + const char out[] = + "Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4" + "uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi" + "4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uL" + "i4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u"; + const char outw[] = + "Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u\n" + "Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u\n" + "Li4uLi4uLi4uLi4uLi4uLi4uLi4u"; + + base64::encoder E(false); + base64::encoder Ew(true); + + char buf[256]; + size_t len; + + for (size_t nc = 0; nc <= 129; nc += 3) { + memset(buf, 0, sizeof buf); + + len = E.encode(in, nc, buf); + len += E.encode_end(buf + len); + tt_stn_op(buf, ==, out, len); + + len = Ew.encode(in, nc, buf); + len += Ew.encode_end(buf + len); + tt_stn_op(buf, ==, outw, len-1); + tt_char_op(buf[len-1], ==, '\n'); + } + + end:; +} + +#define T(name) \ + { #name, test_base64_##name, 0, 0, 0 } + +struct testcase_t base64_tests[] = { + T(standard), + T(altpunct), + T(wrapping), + END_OF_TESTCASES +};