base/base64_unittest.cc

   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
  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
  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
  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
 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
 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