static void
test_fuzz(void)
{
/* Fuzz a round-trip through both encoder and decoder */
struct base64_encode_ctx encode;
struct base64_decode_ctx decode;
unsigned i;
size_t length;
uint8_t input[1024];
struct knuth_lfib_ctx rand_ctx;
knuth_lfib_init(&rand_ctx, 39854);
for (i = 0; i < 10000; i++)
{
length = i % sizeof(input);
/* length could be 0, which is fine we need to test that case too */
knuth_lfib_random(&rand_ctx, length, input);
base64_encode_init(&encode);
base64_decode_init(&decode);
test_fuzz_once(&encode, &decode, length, input);
base64url_encode_init(&encode);
base64url_decode_init(&decode);
test_fuzz_once(&encode, &decode, length, input);
}
}
std::string base64(const std::string& src)
{
base64_encode_ctx ctx;
base64_encode_init(&ctx);
int dstlen = BASE64_ENCODE_RAW_LENGTH(src.size());
uint8_t *dst = new uint8_t[dstlen];
base64_encode_raw(dst, src.size(),
reinterpret_cast<const uint8_t*>(src.c_str()));
std::string res(&dst[0], &dst[dstlen]);
delete [] dst;
return res;
}
// Convert uint8 array to string; return outsize
size_t uint8_to_str(uint8_t *in, unsigned char *out, size_t insize) {
size_t outsize; //number of outgoing encoded bytes
struct base64_encode_ctx encoder; //nettle encoder
base64_encode_init(&encoder); //init encoder
outsize = base64_encode_update(&encoder, out, insize, in); //encode first chunk
out += outsize; //increment pointer
outsize += base64_encode_final(&encoder, out); //encode final chunk, add padding
return outsize; //return number of bytes written to out
}
stl_string base64_encode (const char *buff, int bufflen) {
stl_string ret;
unsigned len = strlen (buff);
char *res = (char *) malloc (BASE64_ENCODE_LENGTH (bufflen));
struct base64_encode_ctx str;
base64_encode_init (&str);
len = base64_encode_update (&str, (uint8_t *) res, len, (uint8_t*) buff); // TODO: args?
base64_encode_final (&str, (uint8_t*) res);
ret.append (res, len);
free (res);
return ret;
}
/*
* Base64-encode *src* and stores it in *dst*.
* The size of *src* is *src_length*.
* *dst* must be at least BASE64_ENCODE_RAW_LENGTH(src_length).
*/
void base64(uint8_t *dst, const uint8_t *src, size_t src_length)
{
struct base64_encode_ctx ctx;
base64_encode_init(&ctx);
base64_encode_raw((char *)dst, src_length, src);
}
int
pgp_armor(struct nettle_buffer *buffer,
const char *tag,
unsigned length,
const uint8_t *data)
{
struct base64_encode_ctx ctx;
unsigned crc = pgp_crc24(length, data);
base64_encode_init(&ctx);
if (! (write_string(buffer, "BEGIN PGP ")
&& write_string(buffer, tag)
&& write_string(buffer, "\nComment: Nettle\n\n")))
return 0;
for (;
length >= BINARY_PER_LINE;
length -= BINARY_PER_LINE, data += BINARY_PER_LINE)
{
unsigned done;
uint8_t *p
= nettle_buffer_space(buffer, TEXT_PER_LINE);
if (!p)
return 0;
done = base64_encode_update(&ctx, p, BINARY_PER_LINE, data);
assert(done <= TEXT_PER_LINE);
/* FIXME: Create some official way to do this */
buffer->size -= (TEXT_PER_LINE - done);
if (!NETTLE_BUFFER_PUTC(buffer, '\n'))
return 0;
}
if (length)
{
unsigned text_size = BASE64_ENCODE_LENGTH(length)
+ BASE64_ENCODE_FINAL_LENGTH;
unsigned done;
uint8_t *p
= nettle_buffer_space(buffer, text_size);
if (!p)
return 0;
done = base64_encode_update(&ctx, p, length, data);
done += base64_encode_final(&ctx, p + done);
/* FIXME: Create some official way to do this */
buffer->size -= (text_size - done);
if (!NETTLE_BUFFER_PUTC(buffer, '\n'))
return 0;
}
/* Checksum */
if (!NETTLE_BUFFER_PUTC(buffer, '='))
return 0;
{
uint8_t *p = nettle_buffer_space(buffer, 4);
if (!p)
return 0;
base64_encode_group(p, crc);
}
return (write_string(buffer, "\nBEGIN PGP ")
&& write_string(buffer, tag)
&& NETTLE_BUFFER_PUTC(buffer, '\n'));
}
