void test_main(void) { ASSERT(BASE64_ENCODE_LENGTH(0) == 0); /* At most 4 bits */ ASSERT(BASE64_ENCODE_LENGTH(1) == 2); /* At most 12 bits */ ASSERT(BASE64_ENCODE_LENGTH(2) == 3); /* At most 20 bits */ ASSERT(BASE64_ENCODE_LENGTH(3) == 4); /* At most 28 bits */ ASSERT(BASE64_ENCODE_LENGTH(4) == 6); /* At most 36 bits */ ASSERT(BASE64_ENCODE_LENGTH(5) == 7); /* At most 44 bits */ ASSERT(BASE64_ENCODE_LENGTH(12) == 16); /* At most 100 bits */ ASSERT(BASE64_ENCODE_LENGTH(13) == 18); /* At most 108 bits */ ASSERT(BASE64_DECODE_LENGTH(0) == 0); /* At most 6 bits */ ASSERT(BASE64_DECODE_LENGTH(1) == 1); /* At most 12 bits */ ASSERT(BASE64_DECODE_LENGTH(2) == 2); /* At most 18 bits */ ASSERT(BASE64_DECODE_LENGTH(3) == 3); /* At most 24 bits */ ASSERT(BASE64_DECODE_LENGTH(4) == 3); /* At most 30 bits */ test_armor(&nettle_base64, LDATA(""), ""); test_armor(&nettle_base64, LDATA("H"), "SA=="); test_armor(&nettle_base64, LDATA("He"), "SGU="); test_armor(&nettle_base64, LDATA("Hel"), "SGVs"); test_armor(&nettle_base64, LDATA("Hell"), "SGVsbA=="); test_armor(&nettle_base64, LDATA("Hello"), "SGVsbG8="); test_armor(&nettle_base64, LDATA("Hello\0"), "SGVsbG8A"); test_armor(&nettle_base64, LDATA("Hello?>>>"), "SGVsbG8/Pj4+"); test_armor(&nettle_base64, LDATA("\xff\xff\xff\xff"), "/////w=="); test_armor(&nettle_base64url, LDATA(""), ""); test_armor(&nettle_base64url, LDATA("H"), "SA=="); test_armor(&nettle_base64url, LDATA("He"), "SGU="); test_armor(&nettle_base64url, LDATA("Hel"), "SGVs"); test_armor(&nettle_base64url, LDATA("Hell"), "SGVsbA=="); test_armor(&nettle_base64url, LDATA("Hello"), "SGVsbG8="); test_armor(&nettle_base64url, LDATA("Hello\0"), "SGVsbG8A"); test_armor(&nettle_base64url, LDATA("Hello?>>>"), "SGVsbG8_Pj4-"); test_armor(&nettle_base64url, LDATA("\xff\xff\xff\xff"), "_____w=="); { /* Test overlapping areas */ uint8_t buffer[] = "Helloxxxx"; struct base64_decode_ctx ctx; size_t dst_length; ASSERT(BASE64_ENCODE_RAW_LENGTH(5) == 8); base64_encode_raw(buffer, 5, buffer); ASSERT(MEMEQ(9, buffer, "SGVsbG8=x")); base64_decode_init(&ctx); dst_length = 0; /* Output parameter only. */ ASSERT(base64_decode_update(&ctx, &dst_length, buffer, 8, buffer)); ASSERT(dst_length == 5); ASSERT(MEMEQ(9, buffer, "HelloG8=x")); } test_fuzz (); }
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; }
static int raw_pubkey_to_base64(const gnutls_datum_t * raw, gnutls_datum_t * b64) { size_t size; size = BASE64_ENCODE_RAW_LENGTH(raw->size); b64->data = gnutls_malloc(size); if (b64->data == NULL) return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR); base64_encode_raw((void*)b64->data, raw->size, raw->data); b64->size = size; return 0; }
_public_ int dnssec_binary_to_base64(const dnssec_binary_t *binary, dnssec_binary_t *base64) { if (!binary || !base64) { return DNSSEC_EINVAL; } size_t base64_size = BASE64_ENCODE_RAW_LENGTH(binary->size); int r = dnssec_binary_resize(base64, base64_size); if (r != DNSSEC_EOK) { return r; } base64_encode_raw(base64->data, binary->size, binary->data); return DNSSEC_EOK; }
unsigned sexp_transport_vformat(struct nettle_buffer *buffer, const char *format, va_list args) { unsigned start = 0; unsigned length; unsigned base64_length; if (buffer) { if (!NETTLE_BUFFER_PUTC(buffer, '{')) return 0; start = buffer->size; } length = sexp_vformat(buffer, format, args); if (!length) return 0; base64_length = BASE64_ENCODE_RAW_LENGTH(length); if (buffer) { if (!nettle_buffer_space(buffer, base64_length - length)) return 0; base64_encode_raw(buffer->contents + start, length, buffer->contents + start); if (!NETTLE_BUFFER_PUTC(buffer, '}')) return 0; } return base64_length + 2; }
/* * 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); }
/* encodes data and puts the result into result (locally allocated) * The result_size (including the null terminator) is the return value. */ int _gnutls_fbase64_encode(const char *msg, const uint8_t * data, size_t data_size, gnutls_datum_t * result) { int tmp; unsigned int i; uint8_t tmpres[66]; uint8_t *ptr; char top[80]; char bottom[80]; size_t size, max, bytes; int pos, top_len = 0, bottom_len = 0; if (msg != NULL) { if (strlen(msg) > 50) { gnutls_assert(); return GNUTLS_E_BASE64_ENCODING_ERROR; } _gnutls_str_cpy(top, sizeof(top), "-----BEGIN "); _gnutls_str_cat(top, sizeof(top), msg); _gnutls_str_cat(top, sizeof(top), "-----\n"); _gnutls_str_cpy(bottom, sizeof(bottom), "-----END "); _gnutls_str_cat(bottom, sizeof(bottom), msg); _gnutls_str_cat(bottom, sizeof(bottom), "-----\n"); top_len = strlen(top); bottom_len = strlen(bottom); } max = B64FSIZE(top_len + bottom_len, data_size); result->data = gnutls_malloc(max + 1); if (result->data == NULL) { gnutls_assert(); return GNUTLS_E_MEMORY_ERROR; } bytes = pos = 0; INCR(bytes, top_len, max); pos = top_len; memcpy(result->data, top, top_len); for (i = 0; i < data_size; i += 48) { if (data_size - i < 48) tmp = data_size - i; else tmp = 48; size = BASE64_ENCODE_RAW_LENGTH(tmp); if (sizeof(tmpres) < size) return gnutls_assert_val(GNUTLS_E_BASE64_ENCODING_ERROR); base64_encode_raw(tmpres, tmp, &data[i]); INCR(bytes, size + 1, max); ptr = &result->data[pos]; memcpy(ptr, tmpres, size); ptr += size; pos += size; if (msg != NULL) { *ptr++ = '\n'; pos++; } else { bytes--; } } INCR(bytes, bottom_len, max); memcpy(&result->data[bytes - bottom_len], bottom, bottom_len); result->data[bytes] = 0; result->size = bytes; return max + 1; }