[go: nahoru, domu]

blob: 92d2781554c3a8f88a8f0105893ec9e32204dd49 [file] [log] [blame]
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/base64url.h"
#include "base/ranges/algorithm.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using testing::ElementsAreArray;
using testing::Optional;
namespace base {
namespace {
TEST(Base64UrlTest, BinaryIncludePaddingPolicy) {
const uint8_t kData[] = {0x00, 0x01, 0xFE, 0xFF};
std::string binary_encoded_with_padding;
Base64UrlEncode(kData, Base64UrlEncodePolicy::INCLUDE_PADDING,
&binary_encoded_with_padding);
// Check that encoding the same binary data through the StringPiece interface
// gives the same result.
std::string string_encoded_with_padding;
Base64UrlEncode(
StringPiece(reinterpret_cast<const char*>(kData), sizeof(kData)),
Base64UrlEncodePolicy::INCLUDE_PADDING, &string_encoded_with_padding);
EXPECT_EQ(binary_encoded_with_padding, string_encoded_with_padding);
// Check that decoding the result gives the same binary data.
EXPECT_THAT(Base64UrlDecode(string_encoded_with_padding,
Base64UrlDecodePolicy::REQUIRE_PADDING),
Optional(ElementsAreArray(kData)));
EXPECT_THAT(Base64UrlDecode(string_encoded_with_padding,
Base64UrlDecodePolicy::IGNORE_PADDING),
Optional(ElementsAreArray(kData)));
EXPECT_THAT(Base64UrlDecode(string_encoded_with_padding,
Base64UrlDecodePolicy::DISALLOW_PADDING),
absl::nullopt);
}
TEST(Base64UrlTest, BinaryOmitPaddingPolicy) {
const uint8_t kData[] = {0x00, 0x01, 0xFE, 0xFF};
std::string binary_encoded_without_padding;
Base64UrlEncode(kData, Base64UrlEncodePolicy::OMIT_PADDING,
&binary_encoded_without_padding);
// Check that encoding the same binary data through the StringPiece interface
// gives the same result.
std::string string_encoded_without_padding;
Base64UrlEncode(
StringPiece(reinterpret_cast<const char*>(kData), sizeof(kData)),
Base64UrlEncodePolicy::OMIT_PADDING, &string_encoded_without_padding);
EXPECT_EQ(binary_encoded_without_padding, string_encoded_without_padding);
// Check that decoding the result gives the same binary data.
EXPECT_THAT(Base64UrlDecode(string_encoded_without_padding,
Base64UrlDecodePolicy::DISALLOW_PADDING),
Optional(ElementsAreArray(kData)));
EXPECT_THAT(Base64UrlDecode(string_encoded_without_padding,
Base64UrlDecodePolicy::IGNORE_PADDING),
Optional(ElementsAreArray(kData)));
EXPECT_THAT(Base64UrlDecode(string_encoded_without_padding,
Base64UrlDecodePolicy::REQUIRE_PADDING),
absl::nullopt);
}
TEST(Base64UrlTest, EncodeIncludePaddingPolicy) {
std::string output;
Base64UrlEncode("hello?world", Base64UrlEncodePolicy::INCLUDE_PADDING,
&output);
// Base64 version: aGVsbG8/d29ybGQ=
EXPECT_EQ("aGVsbG8_d29ybGQ=", output);
// Test for behavior for very short and empty strings.
Base64UrlEncode("??", Base64UrlEncodePolicy::INCLUDE_PADDING, &output);
EXPECT_EQ("Pz8=", output);
Base64UrlEncode("", Base64UrlEncodePolicy::INCLUDE_PADDING, &output);
EXPECT_EQ("", output);
}
TEST(Base64UrlTest, EncodeOmitPaddingPolicy) {
std::string output;
Base64UrlEncode("hello?world", Base64UrlEncodePolicy::OMIT_PADDING, &output);
// base64 version: aGVsbG8/d29ybGQ=
EXPECT_EQ("aGVsbG8_d29ybGQ", output);
// Test for behavior for very short and empty strings.
Base64UrlEncode("??", Base64UrlEncodePolicy::OMIT_PADDING, &output);
EXPECT_EQ("Pz8", output);
Base64UrlEncode("", Base64UrlEncodePolicy::OMIT_PADDING, &output);
EXPECT_EQ("", output);
}
TEST(Base64UrlTest, DecodeRequirePaddingPolicy) {
std::string output;
ASSERT_TRUE(Base64UrlDecode("aGVsbG8_d29ybGQ=",
Base64UrlDecodePolicy::REQUIRE_PADDING, &output));
EXPECT_EQ("hello?world", output);
ASSERT_FALSE(Base64UrlDecode(
"aGVsbG8_d29ybGQ", Base64UrlDecodePolicy::REQUIRE_PADDING, &output));
// Test for behavior for very short and empty strings.
ASSERT_TRUE(
Base64UrlDecode("Pz8=", Base64UrlDecodePolicy::REQUIRE_PADDING, &output));
EXPECT_EQ("??", output);
ASSERT_TRUE(
Base64UrlDecode("", Base64UrlDecodePolicy::REQUIRE_PADDING, &output));
EXPECT_EQ("", output);
}
TEST(Base64UrlTest, DecodeIgnorePaddingPolicy) {
std::string output;
ASSERT_TRUE(Base64UrlDecode("aGVsbG8_d29ybGQ",
Base64UrlDecodePolicy::IGNORE_PADDING, &output));
EXPECT_EQ("hello?world", output);
// Including the padding is accepted as well.
ASSERT_TRUE(Base64UrlDecode("aGVsbG8_d29ybGQ=",
Base64UrlDecodePolicy::IGNORE_PADDING, &output));
EXPECT_EQ("hello?world", output);
}
TEST(Base64UrlTest, DecodeIntoVector) {
ASSERT_FALSE(
Base64UrlDecode("invalid=", Base64UrlDecodePolicy::DISALLOW_PADDING));
static constexpr uint8_t kExpected[] = {'1', '2', '3', '4'};
absl::optional<std::vector<uint8_t>> result =
Base64UrlDecode("MTIzNA", Base64UrlDecodePolicy::DISALLOW_PADDING);
ASSERT_TRUE(ranges::equal(*result, kExpected));
}
TEST(Base64UrlTest, DecodeDisallowPaddingPolicy) {
std::string output;
ASSERT_FALSE(Base64UrlDecode(
"aGVsbG8_d29ybGQ=", Base64UrlDecodePolicy::DISALLOW_PADDING, &output));
// The policy will allow the input when padding has been omitted.
ASSERT_TRUE(Base64UrlDecode(
"aGVsbG8_d29ybGQ", Base64UrlDecodePolicy::DISALLOW_PADDING, &output));
EXPECT_EQ("hello?world", output);
}
TEST(Base64UrlTest, DecodeDisallowsBase64Alphabet) {
std::string output;
// The "/" character is part of the conventional base64 alphabet, but has been
// substituted with "_" in the base64url alphabet.
ASSERT_FALSE(Base64UrlDecode(
"aGVsbG8/d29ybGQ=", Base64UrlDecodePolicy::REQUIRE_PADDING, &output));
}
TEST(Base64UrlTest, DecodeDisallowsPaddingOnly) {
std::string output;
ASSERT_FALSE(Base64UrlDecode(
"=", Base64UrlDecodePolicy::IGNORE_PADDING, &output));
ASSERT_FALSE(Base64UrlDecode(
"==", Base64UrlDecodePolicy::IGNORE_PADDING, &output));
ASSERT_FALSE(Base64UrlDecode(
"===", Base64UrlDecodePolicy::IGNORE_PADDING, &output));
ASSERT_FALSE(Base64UrlDecode(
"====", Base64UrlDecodePolicy::IGNORE_PADDING, &output));
}
} // namespace
} // namespace base