1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/base64.h"
6
7 #include "base/numerics/checked_math.h"
8 #include "base/strings/escape.h"
9 #include "base/test/gtest_util.h"
10 #include "testing/gmock/include/gmock/gmock.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12 #include "third_party/modp_b64/modp_b64.h"
13
14 namespace base {
15
TEST(Base64Test,Basic)16 TEST(Base64Test, Basic) {
17 const std::string kText = "hello world";
18 const std::string kBase64Text = "aGVsbG8gd29ybGQ=";
19
20 std::string decoded;
21 bool ok;
22
23 std::string encoded = Base64Encode(kText);
24 EXPECT_EQ(kBase64Text, encoded);
25
26 ok = Base64Decode(encoded, &decoded);
27 EXPECT_TRUE(ok);
28 EXPECT_EQ(kText, decoded);
29 }
30
TEST(Base64Test,Forgiving)31 TEST(Base64Test, Forgiving) {
32 struct {
33 const char* in;
34
35 // nullptr indicates a decode failure.
36 const char* expected_out;
37 } kTestCases[] = {
38 // Failures that should apply in all decoding modes:
39 //
40 // - Characters not in the base64 alphabet
41 {"abc&", nullptr},
42 {"ab-d", nullptr},
43 // - input len % 4 == 1
44 {"abcde", nullptr},
45 {"a", nullptr},
46
47 // Invalid padding causes failure if kForgiving is set.
48 {"abcd=", nullptr},
49 {"abcd==", nullptr},
50 {"abcd===", nullptr},
51 {"abcd====", nullptr},
52 {"abcd==============", nullptr},
53 {"=", nullptr},
54 {"====", nullptr},
55
56 // Otherwise, inputs that are multiples of 4 always succeed, this matches
57 // kStrict mode.
58 {"abcd", "i\xB7\x1D"},
59 {"abc=", "i\xB7"},
60 {"abcdefgh", "i\xB7\x1Dy\xF8!"},
61
62 // kForgiving mode allows for omitting padding (to a multiple of 4) if
63 // len % 4 != 1.
64 {"abcdef", "i\xB7\x1Dy"},
65 {"abc", "i\xB7"},
66 {"ab", "i"},
67
68 // Whitespace should be allowed if kForgiving is set, matching
69 // https://infra.spec.whatwg.org/#ascii-whitespace:
70 // ASCII whitespace is U+0009 TAB '\t', U+000A LF '\n', U+000C FF '\f',
71 // U+000D CR '\r', or U+0020 SPACE ' '.
72 {" a bcd", "i\xB7\x1D"},
73 {"ab\t\tc=", "i\xB7"},
74 {"ab c\ndefgh", "i\xB7\x1Dy\xF8!"},
75 {"a\tb\nc\f d\r", "i\xB7\x1D"},
76
77 // U+000B VT '\v' is _not_ valid whitespace to be stripped.
78 {"ab\vcd", nullptr},
79
80 // Empty string should yield an empty result.
81 {"", ""},
82 };
83 for (const auto& test_case : kTestCases) {
84 SCOPED_TRACE(::testing::Message()
85 << EscapeAllExceptUnreserved(test_case.in));
86 std::string output;
87 bool success =
88 Base64Decode(test_case.in, &output, Base64DecodePolicy::kForgiving);
89 bool expected_success = test_case.expected_out != nullptr;
90 EXPECT_EQ(success, expected_success);
91 if (expected_success) {
92 EXPECT_EQ(output, test_case.expected_out);
93 }
94 }
95 }
96
TEST(Base64Test,Binary)97 TEST(Base64Test, Binary) {
98 const uint8_t kData[] = {0x00, 0x01, 0xFE, 0xFF};
99
100 std::string binary_encoded = Base64Encode(kData);
101
102 // Check that encoding the same data through the StringPiece interface gives
103 // the same results.
104 std::string string_piece_encoded;
105 Base64Encode(StringPiece(reinterpret_cast<const char*>(kData), sizeof(kData)),
106 &string_piece_encoded);
107
108 EXPECT_EQ(binary_encoded, string_piece_encoded);
109
110 EXPECT_THAT(Base64Decode(binary_encoded),
111 testing::Optional(testing::ElementsAreArray(kData)));
112 EXPECT_FALSE(Base64Decode("invalid base64!"));
113
114 std::string encoded_with_prefix = "PREFIX";
115 Base64EncodeAppend(kData, &encoded_with_prefix);
116 EXPECT_EQ(encoded_with_prefix, "PREFIX" + binary_encoded);
117 }
118
TEST(Base64Test,InPlace)119 TEST(Base64Test, InPlace) {
120 const std::string kText = "hello world";
121 const std::string kBase64Text = "aGVsbG8gd29ybGQ=";
122
123 std::string text = Base64Encode(kText);
124 EXPECT_EQ(kBase64Text, text);
125
126 bool ok = Base64Decode(text, &text);
127 EXPECT_TRUE(ok);
128 EXPECT_EQ(text, kText);
129 }
130
TEST(Base64Test,Overflow)131 TEST(Base64Test, Overflow) {
132 // `Base64Encode` makes the input larger, which means inputs whose base64
133 // output overflows `size_t`. Actually allocating a span of this size will
134 // likely fail, but we test it with a fake span and assume a correct
135 // implementation will check for overflow before touching the input.
136 //
137 // Note that, with or without an overflow check, the function will still
138 // crash. This test is only meaningful because `EXPECT_CHECK_DEATH` looks for
139 // a `CHECK`-based failure.
140 uint8_t b;
141 auto large_span = base::make_span(&b, MODP_B64_MAX_INPUT_LEN + 1);
142 EXPECT_CHECK_DEATH(Base64Encode(large_span));
143
144 std::string output = "PREFIX";
145 EXPECT_CHECK_DEATH(Base64EncodeAppend(large_span, &output));
146
147 // `modp_b64_encode_data_len` is a macro, so check `MODP_B64_MAX_INPUT_LEN` is
148 // correct be verifying the computation doesn't overflow.
149 base::CheckedNumeric<size_t> max_len = MODP_B64_MAX_INPUT_LEN;
150 EXPECT_TRUE(modp_b64_encode_data_len(max_len).IsValid());
151 }
152
153 } // namespace base
154