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')); }