diff options
Diffstat (limited to 'xpcom/io/Base64.cpp')
| -rw-r--r-- | xpcom/io/Base64.cpp | 645 |
1 files changed, 645 insertions, 0 deletions
diff --git a/xpcom/io/Base64.cpp b/xpcom/io/Base64.cpp new file mode 100644 index 000000000..911c0595a --- /dev/null +++ b/xpcom/io/Base64.cpp @@ -0,0 +1,645 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "Base64.h" + +#include "mozilla/UniquePtrExtensions.h" +#include "nsIInputStream.h" +#include "nsString.h" +#include "nsTArray.h" + +#include "plbase64.h" + +namespace { + +// BEGIN base64 encode code copied and modified from NSPR +const unsigned char* base = + (unsigned char*)"ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789+/"; + +template<typename T> +static void +Encode3to4(const unsigned char* aSrc, T* aDest) +{ + uint32_t b32 = (uint32_t)0; + int i, j = 18; + + for (i = 0; i < 3; ++i) { + b32 <<= 8; + b32 |= (uint32_t)aSrc[i]; + } + + for (i = 0; i < 4; ++i) { + aDest[i] = base[(uint32_t)((b32 >> j) & 0x3F)]; + j -= 6; + } +} + +template<typename T> +static void +Encode2to4(const unsigned char* aSrc, T* aDest) +{ + aDest[0] = base[(uint32_t)((aSrc[0] >> 2) & 0x3F)]; + aDest[1] = base[(uint32_t)(((aSrc[0] & 0x03) << 4) | ((aSrc[1] >> 4) & 0x0F))]; + aDest[2] = base[(uint32_t)((aSrc[1] & 0x0F) << 2)]; + aDest[3] = (unsigned char)'='; +} + +template<typename T> +static void +Encode1to4(const unsigned char* aSrc, T* aDest) +{ + aDest[0] = base[(uint32_t)((aSrc[0] >> 2) & 0x3F)]; + aDest[1] = base[(uint32_t)((aSrc[0] & 0x03) << 4)]; + aDest[2] = (unsigned char)'='; + aDest[3] = (unsigned char)'='; +} + +template<typename T> +static void +Encode(const unsigned char* aSrc, uint32_t aSrcLen, T* aDest) +{ + while (aSrcLen >= 3) { + Encode3to4(aSrc, aDest); + aSrc += 3; + aDest += 4; + aSrcLen -= 3; + } + + switch (aSrcLen) { + case 2: + Encode2to4(aSrc, aDest); + break; + case 1: + Encode1to4(aSrc, aDest); + break; + case 0: + break; + default: + NS_NOTREACHED("coding error"); + } +} + +// END base64 encode code copied and modified from NSPR. + +template<typename T> +struct EncodeInputStream_State +{ + unsigned char c[3]; + uint8_t charsOnStack; + typename T::char_type* buffer; +}; + +template<typename T> +nsresult +EncodeInputStream_Encoder(nsIInputStream* aStream, + void* aClosure, + const char* aFromSegment, + uint32_t aToOffset, + uint32_t aCount, + uint32_t* aWriteCount) +{ + NS_ASSERTION(aCount > 0, "Er, what?"); + + EncodeInputStream_State<T>* state = + static_cast<EncodeInputStream_State<T>*>(aClosure); + + // If we have any data left from last time, encode it now. + uint32_t countRemaining = aCount; + const unsigned char* src = (const unsigned char*)aFromSegment; + if (state->charsOnStack) { + unsigned char firstSet[4]; + if (state->charsOnStack == 1) { + firstSet[0] = state->c[0]; + firstSet[1] = src[0]; + firstSet[2] = (countRemaining > 1) ? src[1] : '\0'; + firstSet[3] = '\0'; + } else /* state->charsOnStack == 2 */ { + firstSet[0] = state->c[0]; + firstSet[1] = state->c[1]; + firstSet[2] = src[0]; + firstSet[3] = '\0'; + } + Encode(firstSet, 3, state->buffer); + state->buffer += 4; + countRemaining -= (3 - state->charsOnStack); + src += (3 - state->charsOnStack); + state->charsOnStack = 0; + } + + // Encode the bulk of the + uint32_t encodeLength = countRemaining - countRemaining % 3; + MOZ_ASSERT(encodeLength % 3 == 0, + "Should have an exact number of triplets!"); + Encode(src, encodeLength, state->buffer); + state->buffer += (encodeLength / 3) * 4; + src += encodeLength; + countRemaining -= encodeLength; + + // We must consume all data, so if there's some data left stash it + *aWriteCount = aCount; + + if (countRemaining) { + // We should never have a full triplet left at this point. + MOZ_ASSERT(countRemaining < 3, "We should have encoded more!"); + state->c[0] = src[0]; + state->c[1] = (countRemaining == 2) ? src[1] : '\0'; + state->charsOnStack = countRemaining; + } + + return NS_OK; +} + +template<typename T> +nsresult +EncodeInputStream(nsIInputStream* aInputStream, + T& aDest, + uint32_t aCount, + uint32_t aOffset) +{ + nsresult rv; + uint64_t count64 = aCount; + + if (!aCount) { + rv = aInputStream->Available(&count64); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + // if count64 is over 4GB, it will be failed at the below condition, + // then will return NS_ERROR_OUT_OF_MEMORY + aCount = (uint32_t)count64; + } + + uint64_t countlong = + (count64 + 2) / 3 * 4; // +2 due to integer math. + if (countlong + aOffset > UINT32_MAX) { + return NS_ERROR_OUT_OF_MEMORY; + } + + uint32_t count = uint32_t(countlong); + + if (!aDest.SetLength(count + aOffset, mozilla::fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + EncodeInputStream_State<T> state; + state.charsOnStack = 0; + state.c[2] = '\0'; + state.buffer = aOffset + aDest.BeginWriting(); + + while (1) { + uint32_t read = 0; + + rv = aInputStream->ReadSegments(&EncodeInputStream_Encoder<T>, + (void*)&state, + aCount, + &read); + if (NS_FAILED(rv)) { + if (rv == NS_BASE_STREAM_WOULD_BLOCK) { + NS_RUNTIMEABORT("Not implemented for async streams!"); + } + if (rv == NS_ERROR_NOT_IMPLEMENTED) { + NS_RUNTIMEABORT("Requires a stream that implements ReadSegments!"); + } + return rv; + } + + if (!read) { + break; + } + } + + // Finish encoding if anything is left + if (state.charsOnStack) { + Encode(state.c, state.charsOnStack, state.buffer); + } + + if (aDest.Length()) { + // May belong to an nsCString with an unallocated buffer, so only null + // terminate if there is a need to. + *aDest.EndWriting() = '\0'; + } + + return NS_OK; +} + +static const char kBase64URLAlphabet[] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; + +// Maps an encoded character to a value in the Base64 URL alphabet, per +// RFC 4648, Table 2. Invalid input characters map to UINT8_MAX. +static const uint8_t kBase64URLDecodeTable[] = { + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, + 62 /* - */, + 255, 255, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, /* 0 - 9 */ + 255, 255, 255, 255, 255, 255, 255, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, /* A - Z */ + 255, 255, 255, 255, + 63 /* _ */, + 255, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, /* a - z */ + 255, 255, 255, 255, +}; + +bool +Base64URLCharToValue(char aChar, uint8_t* aValue) { + uint8_t index = static_cast<uint8_t>(aChar); + *aValue = kBase64URLDecodeTable[index & 0x7f]; + return (*aValue != 255) && !(index & ~0x7f); +} + +} // namespace + +namespace mozilla { + +nsresult +Base64EncodeInputStream(nsIInputStream* aInputStream, + nsACString& aDest, + uint32_t aCount, + uint32_t aOffset) +{ + return EncodeInputStream<nsACString>(aInputStream, aDest, aCount, aOffset); +} + +nsresult +Base64EncodeInputStream(nsIInputStream* aInputStream, + nsAString& aDest, + uint32_t aCount, + uint32_t aOffset) +{ + return EncodeInputStream<nsAString>(aInputStream, aDest, aCount, aOffset); +} + +nsresult +Base64Encode(const char* aBinary, uint32_t aBinaryLen, char** aBase64) +{ + // Check for overflow. + if (aBinaryLen > (UINT32_MAX / 4) * 3) { + return NS_ERROR_FAILURE; + } + + // Don't ask PR_Base64Encode to encode empty strings. + if (aBinaryLen == 0) { + *aBase64 = (char*)moz_xmalloc(1); + (*aBase64)[0] = '\0'; + return NS_OK; + } + + *aBase64 = nullptr; + uint32_t base64Len = ((aBinaryLen + 2) / 3) * 4; + + // Add one byte for null termination. + UniqueFreePtr<char[]> base64((char*)malloc(base64Len + 1)); + if (!base64) { + return NS_ERROR_OUT_OF_MEMORY; + } + + if (!PL_Base64Encode(aBinary, aBinaryLen, base64.get())) { + return NS_ERROR_INVALID_ARG; + } + + // PL_Base64Encode doesn't null terminate the buffer for us when we pass + // the buffer in. Do that manually. + base64[base64Len] = '\0'; + + *aBase64 = base64.release(); + return NS_OK; +} + +nsresult +Base64Encode(const nsACString& aBinary, nsACString& aBase64) +{ + // Check for overflow. + if (aBinary.Length() > (UINT32_MAX / 4) * 3) { + return NS_ERROR_FAILURE; + } + + // Don't ask PR_Base64Encode to encode empty strings. + if (aBinary.IsEmpty()) { + aBase64.Truncate(); + return NS_OK; + } + + uint32_t base64Len = ((aBinary.Length() + 2) / 3) * 4; + + // Add one byte for null termination. + if (!aBase64.SetCapacity(base64Len + 1, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + char* base64 = aBase64.BeginWriting(); + if (!PL_Base64Encode(aBinary.BeginReading(), aBinary.Length(), base64)) { + aBase64.Truncate(); + return NS_ERROR_INVALID_ARG; + } + + // PL_Base64Encode doesn't null terminate the buffer for us when we pass + // the buffer in. Do that manually. + base64[base64Len] = '\0'; + + aBase64.SetLength(base64Len); + return NS_OK; +} + +nsresult +Base64Encode(const nsAString& aBinary, nsAString& aBase64) +{ + NS_LossyConvertUTF16toASCII binary(aBinary); + nsAutoCString base64; + + nsresult rv = Base64Encode(binary, base64); + if (NS_SUCCEEDED(rv)) { + CopyASCIItoUTF16(base64, aBase64); + } else { + aBase64.Truncate(); + } + + return rv; +} + +static nsresult +Base64DecodeHelper(const char* aBase64, uint32_t aBase64Len, char* aBinary, + uint32_t* aBinaryLen) +{ + MOZ_ASSERT(aBinary); + if (!PL_Base64Decode(aBase64, aBase64Len, aBinary)) { + return NS_ERROR_INVALID_ARG; + } + + // PL_Base64Decode doesn't null terminate the buffer for us when we pass + // the buffer in. Do that manually, taking into account the number of '=' + // characters we were passed. + if (aBase64Len != 0 && aBase64[aBase64Len - 1] == '=') { + if (aBase64Len > 1 && aBase64[aBase64Len - 2] == '=') { + *aBinaryLen -= 2; + } else { + *aBinaryLen -= 1; + } + } + aBinary[*aBinaryLen] = '\0'; + return NS_OK; +} + +nsresult +Base64Decode(const char* aBase64, uint32_t aBase64Len, char** aBinary, + uint32_t* aBinaryLen) +{ + // Check for overflow. + if (aBase64Len > UINT32_MAX / 3) { + return NS_ERROR_FAILURE; + } + + // Don't ask PR_Base64Decode to decode the empty string. + if (aBase64Len == 0) { + *aBinary = (char*)moz_xmalloc(1); + (*aBinary)[0] = '\0'; + *aBinaryLen = 0; + return NS_OK; + } + + *aBinary = nullptr; + *aBinaryLen = (aBase64Len * 3) / 4; + + // Add one byte for null termination. + UniqueFreePtr<char[]> binary((char*)malloc(*aBinaryLen + 1)); + if (!binary) { + return NS_ERROR_OUT_OF_MEMORY; + } + + nsresult rv = + Base64DecodeHelper(aBase64, aBase64Len, binary.get(), aBinaryLen); + if (NS_FAILED(rv)) { + return rv; + } + + *aBinary = binary.release(); + return NS_OK; +} + +nsresult +Base64Decode(const nsACString& aBase64, nsACString& aBinary) +{ + // Check for overflow. + if (aBase64.Length() > UINT32_MAX / 3) { + return NS_ERROR_FAILURE; + } + + // Don't ask PR_Base64Decode to decode the empty string + if (aBase64.IsEmpty()) { + aBinary.Truncate(); + return NS_OK; + } + + uint32_t binaryLen = ((aBase64.Length() * 3) / 4); + + // Add one byte for null termination. + if (!aBinary.SetCapacity(binaryLen + 1, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + char* binary = aBinary.BeginWriting(); + nsresult rv = Base64DecodeHelper(aBase64.BeginReading(), aBase64.Length(), + binary, &binaryLen); + if (NS_FAILED(rv)) { + aBinary.Truncate(); + return rv; + } + + aBinary.SetLength(binaryLen); + return NS_OK; +} + +nsresult +Base64Decode(const nsAString& aBase64, nsAString& aBinary) +{ + NS_LossyConvertUTF16toASCII base64(aBase64); + nsAutoCString binary; + + nsresult rv = Base64Decode(base64, binary); + if (NS_SUCCEEDED(rv)) { + CopyASCIItoUTF16(binary, aBinary); + } else { + aBinary.Truncate(); + } + + return rv; +} + +nsresult +Base64URLDecode(const nsACString& aBase64, + Base64URLDecodePaddingPolicy aPaddingPolicy, + FallibleTArray<uint8_t>& aBinary) +{ + // Don't decode empty strings. + if (aBase64.IsEmpty()) { + aBinary.Clear(); + return NS_OK; + } + + // Check for overflow. + uint32_t base64Len = aBase64.Length(); + if (base64Len > UINT32_MAX / 3) { + return NS_ERROR_FAILURE; + } + const char* base64 = aBase64.BeginReading(); + + // The decoded length may be 1-2 bytes over, depending on the final quantum. + uint32_t binaryLen = (base64Len * 3) / 4; + + // Determine whether to check for and ignore trailing padding. + bool maybePadded = false; + switch (aPaddingPolicy) { + case Base64URLDecodePaddingPolicy::Require: + if (base64Len % 4) { + // Padded input length must be a multiple of 4. + return NS_ERROR_INVALID_ARG; + } + maybePadded = true; + break; + + case Base64URLDecodePaddingPolicy::Ignore: + // Check for padding only if the length is a multiple of 4. + maybePadded = !(base64Len % 4); + break; + + // If we're expecting unpadded input, no need for additional checks. + // `=` isn't in the decode table, so padded strings will fail to decode. + default: + MOZ_FALLTHROUGH_ASSERT("Invalid decode padding policy"); + case Base64URLDecodePaddingPolicy::Reject: + break; + } + if (maybePadded && base64[base64Len - 1] == '=') { + if (base64[base64Len - 2] == '=') { + base64Len -= 2; + } else { + base64Len -= 1; + } + } + + if (NS_WARN_IF(!aBinary.SetCapacity(binaryLen, mozilla::fallible))) { + return NS_ERROR_OUT_OF_MEMORY; + } + aBinary.SetLengthAndRetainStorage(binaryLen); + uint8_t* binary = aBinary.Elements(); + + for (; base64Len >= 4; base64Len -= 4) { + uint8_t w, x, y, z; + if (!Base64URLCharToValue(*base64++, &w) || + !Base64URLCharToValue(*base64++, &x) || + !Base64URLCharToValue(*base64++, &y) || + !Base64URLCharToValue(*base64++, &z)) { + return NS_ERROR_INVALID_ARG; + } + *binary++ = w << 2 | x >> 4; + *binary++ = x << 4 | y >> 2; + *binary++ = y << 6 | z; + } + + if (base64Len == 3) { + uint8_t w, x, y; + if (!Base64URLCharToValue(*base64++, &w) || + !Base64URLCharToValue(*base64++, &x) || + !Base64URLCharToValue(*base64++, &y)) { + return NS_ERROR_INVALID_ARG; + } + *binary++ = w << 2 | x >> 4; + *binary++ = x << 4 | y >> 2; + } else if (base64Len == 2) { + uint8_t w, x; + if (!Base64URLCharToValue(*base64++, &w) || + !Base64URLCharToValue(*base64++, &x)) { + return NS_ERROR_INVALID_ARG; + } + *binary++ = w << 2 | x >> 4; + } else if (base64Len) { + return NS_ERROR_INVALID_ARG; + } + + // Set the length to the actual number of decoded bytes. + aBinary.TruncateLength(binary - aBinary.Elements()); + return NS_OK; +} + +nsresult +Base64URLEncode(uint32_t aBinaryLen, const uint8_t* aBinary, + Base64URLEncodePaddingPolicy aPaddingPolicy, + nsACString& aBase64) +{ + // Don't encode empty strings. + if (aBinaryLen == 0) { + aBase64.Truncate(); + return NS_OK; + } + + // Check for overflow. + if (aBinaryLen > (UINT32_MAX / 4) * 3) { + return NS_ERROR_FAILURE; + } + + // Allocate a buffer large enough to hold the encoded string with padding. + // Add one byte for null termination. + uint32_t base64Len = ((aBinaryLen + 2) / 3) * 4; + if (NS_WARN_IF(!aBase64.SetCapacity(base64Len + 1, fallible))) { + aBase64.Truncate(); + return NS_ERROR_FAILURE; + } + + char* base64 = aBase64.BeginWriting(); + + uint32_t index = 0; + for (; index + 3 <= aBinaryLen; index += 3) { + *base64++ = kBase64URLAlphabet[aBinary[index] >> 2]; + *base64++ = kBase64URLAlphabet[((aBinary[index] & 0x3) << 4) | + (aBinary[index + 1] >> 4)]; + *base64++ = kBase64URLAlphabet[((aBinary[index + 1] & 0xf) << 2) | + (aBinary[index + 2] >> 6)]; + *base64++ = kBase64URLAlphabet[aBinary[index + 2] & 0x3f]; + } + + uint32_t remaining = aBinaryLen - index; + if (remaining == 1) { + *base64++ = kBase64URLAlphabet[aBinary[index] >> 2]; + *base64++ = kBase64URLAlphabet[((aBinary[index] & 0x3) << 4)]; + } else if (remaining == 2) { + *base64++ = kBase64URLAlphabet[aBinary[index] >> 2]; + *base64++ = kBase64URLAlphabet[((aBinary[index] & 0x3) << 4) | + (aBinary[index + 1] >> 4)]; + *base64++ = kBase64URLAlphabet[((aBinary[index + 1] & 0xf) << 2)]; + } + + uint32_t length = base64 - aBase64.BeginWriting(); + if (aPaddingPolicy == Base64URLEncodePaddingPolicy::Include) { + if (length % 4 == 2) { + *base64++ = '='; + *base64++ = '='; + length += 2; + } else if (length % 4 == 3) { + *base64++ = '='; + length += 1; + } + } else { + MOZ_ASSERT(aPaddingPolicy == Base64URLEncodePaddingPolicy::Omit, + "Invalid encode padding policy"); + } + + // Null terminate and truncate to the actual number of characters. + *base64 = '\0'; + aBase64.SetLength(length); + + return NS_OK; +} + +} // namespace mozilla |