GH-49614: [C++] Fix silent truncation in base64_decode on invalid input by Reranko05 · Pull Request #49660 · apache/arrow

Reranko05 · 2026-04-04T14:31:37Z

Rationale for this change

arrow::util::base64_decode silently truncates output when encountering invalid base64 characters, returning partial results without signaling an error. This can lead to unintended data corruption.

What changes are included in this PR?

Add upfront validation of input characters in base64_decode
Return an empty string if invalid base64 characters are detected
Prevent silent truncation of decoded output

Are these changes tested?

Yes. A unit test has been added to verify that invalid input returns an empty string.

Are there any user-facing changes?

Yes. Previously, invalid base64 input could result in partial decoded output. Now, such inputs return an empty string.

This PR contains a "Critical Fix".

This change fixes a correctness issue where invalid base64 input could result in silently truncated output, leading to incorrect data being produced. The fix ensures such inputs are detected and handled safely.

GitHub Issue: [C++] arrow::util::base64_decode silently truncates on invalid characters instead of reporting an error #49614

github-actions · 2026-04-04T14:32:02Z

⚠️ GitHub issue #49614 has been automatically assigned in GitHub to PR creator.

dmitry-chirkov-dremio · 2026-04-04T17:18:25Z

cpp/src/arrow/vendored/base64.cpp


+  for (char c : encoded_string) {
+    if (!(is_base64(c) || c == '=')) {
+      return "";


I’m not comfortable with "" as the error path here. It’s indistinguishable from a valid decode of empty input, so malformed input still fails silently. I’d prefer this API to fail explicitly (Result<std::string> / checked variant) and have Gandiva propagate that as an error.

Returning null would be slightly better than returning "", because at least it doesn’t collide with a valid decoded empty string. But I still don’t think it’s the right default behavior here as null still turns malformed input into a regular value rather than an explicit failure.

dmitry-chirkov-dremio · 2026-04-04T17:19:31Z

cpp/src/arrow/vendored/base64.cpp

  std::string ret;

+  for (char c : encoded_string) {
+    if (!(is_base64(c) || c == '=')) {


This is absolutely insufficient and will not trip on input like abcd=AAA. Please do some research on best practices for sufficient and efficient base64 input validation.

dmitry-chirkov-dremio · 2026-04-04T17:21:39Z

cpp/src/arrow/util/string_test.cc

+  std::string input = "hello world!";  // invalid base64
+  std::string output = arrow::util::base64_decode(input);
+
+  EXPECT_EQ(output, "");


More tests! In our day and age with tools that we have this is not even bare minimum. Null input? Valid input? Non-ascii input?

Did you locate other tests? I'm not seeing any other tests for base64_decode in this file so where are they?

Reranko05 · 2026-04-04T20:42:38Z

Thanks for the feedback. I’ve updated the implementation and tests.

Added stricter validation (length, padding placement/count, allowed characters)
Removed early termination in the decode loop to avoid silent truncation
Expanded test coverage to include invalid inputs and edge cases

All tests pass locally. Please let me know if any further adjustments are needed.

kou

Could you use arrow::Result<std::string> return type instead of using ARROW_LOG()?

kou · 2026-04-05T04:25:34Z

FYI: You can run CI on your fork by enabling GitHub Actions on your fork.

Reranko05 · 2026-04-05T05:07:00Z

Could you use arrow::Result<std::string> return type instead of using ARROW_LOG()?

Thanks for the suggestion @kou !

Just to clarify, would you prefer changing the existing base64_decode API to return arrow::Resultstd::string, or introducing a separate checked variant while keeping the current API unchanged?

I want to make sure the approach aligns with existing usage and expectations.

kou · 2026-04-05T05:19:59Z

"changing the existing base64_decode API to return arrow::Resultstd::string".
But I want to know how many changes are required for existing code that use base64_decode().

Reranko05 · 2026-04-05T05:34:26Z

@kou I checked the current usages of base64_decode(), and it appears to be used in a very limited number of places (primarily in tests and one internal call site in flight_test.cc).

Updating to arrow::Result<std::string> would require adjusting those call sites to use ARROW_ASSIGN_OR_RAISE, but the impact seems quite localized and manageable.

I can proceed with the API change and update the affected call sites accordingly.

Reranko05 · 2026-04-07T22:48:17Z

Hi @kou, just following up on this.

I can proceed with updating base64_decode() to return arrow::Result<std::string> and adjust the affected call sites accordingly. Please let me know if this approach looks good, or if you'd prefer any alternative.

Happy to proceed based on your guidance.

kou · 2026-04-08T00:57:42Z

Oh, sorry. I forgot to reply this...

Yes. Let's proceed with arrow::Result<std::string>.

Reranko05 · 2026-04-08T10:00:33Z

Hi @kou, thanks for confirming!

I’ve updated base64_decode() to return arrow::Result<std::string> and added validation for invalid inputs (length, padding, and non-base64 characters). I also updated the tests accordingly.

All tests are passing locally. Please let me know if you’d like any changes or adjustments.

dmitry-chirkov-dremio · 2026-04-08T13:13:59Z

cpp/src/arrow/vendored/base64.cpp

+               "0123456789+/";
+
+  auto is_base64 = [](unsigned char c) -> bool {
+    return (std::isalnum(c) || (c == '+') || (c == '/'));


Seeing this logic right below base64_chars definition is a bit strange

dmitry-chirkov-dremio · 2026-04-08T13:24:38Z

cpp/src/arrow/vendored/base64.cpp

+    return arrow::Status::Invalid("Invalid base64 input: length is not a multiple of 4");
+  }
+
+  size_t padding_start = encoded_string.find('=');


I am not a fan of separate validation loop as it is a performance overhead.
Please validate and decode in a single pass.

Thanks for pointing it out. I’ll integrate the validation into the decoding loop to avoid the extra pass.

It seems that the current implementation still uses 2 passes.

dmitry-chirkov-dremio · 2026-04-08T13:26:01Z

cpp/src/arrow/util/base64.h


 ARROW_EXPORT
-std::string base64_decode(std::string_view s);
+arrow::Result<std::string> base64_decode(std::string_view s);


No need to change the callers?
Perhaps a single integration test that would call a caller function with an invalid input to validate.

Based on @kou's earlier suggestion, I proceeded with updating base64_decode() to return arrow::Result<std::string> and adjusted the existing usages accordingly.

kou · 2026-04-08T13:14:51Z

cpp/src/arrow/util/base64.h


 #include "arrow/util/visibility.h"
+#include "arrow/result.h"
+#include "arrow/status.h"


Can we remove this? I think that arrow/result.h includes arrow/status.h.

kou · 2026-04-08T13:17:26Z

cpp/src/arrow/util/string_test.cc

-    ASSERT_TRUE(result.starts_with("0")) << result;
+    ASSERT_TRUE(result.rfind("0", 0) == 0) << result;
    result = ToChars(0.25);
-    ASSERT_TRUE(result.starts_with("0.25")) << result;
+    ASSERT_TRUE(result.rfind("0.25", 0) == 0) << result;


Why do we need these changes?

You're right, this change is not directly related to the base64 fix. I updated it earlier due to compatibility issues with starts_with, but I’ll revert it to keep the scope of this PR focused.

kou · 2026-04-08T13:19:28Z

cpp/src/arrow/util/string_test.cc

+  auto r1 = arrow::util::base64_decode("Zg==");
+  ASSERT_TRUE(r1.ok());


Could you use ASSERT_OK_AND_ASSIGN()?

Suggested change

auto r1 = arrow::util::base64_decode("Zg==");

ASSERT_TRUE(r1.ok());

ASSERT_OK_AND_ASSIGN(auto string, arrow::util::base64_decode("Zg=="));

Good suggestion, thanks! I’ll update the tests to use ASSERT_OK_AND_ASSIGN.

kou · 2026-04-08T13:20:06Z

cpp/src/arrow/util/string_test.cc

+  auto r1 = arrow::util::base64_decode("Zg==");
+  ASSERT_TRUE(r1.ok());
+  EXPECT_EQ(r1.ValueOrDie(), "f");
+  auto r2 = arrow::util::base64_decode("Zm8=");


Can we reuse one variable instead of declaring multiple variables (r1, r2, ...)?

Or could you use more meaningful variable name for each case such as two_paddings, one_padding and no_padding?

I’ll update the tests to use more meaningful variable names while also aligning with ASSERT_OK_AND_ASSIGN.

kou · 2026-04-08T13:24:52Z

cpp/src/arrow/util/string_test.cc

+  auto r4 = arrow::util::base64_decode("aGVsbG8gd29ybGQ=");
+  ASSERT_TRUE(r4.ok());
+  EXPECT_EQ(r4.ValueOrDie(), "hello world");


Why do we need this case? What is the difference with other cases?

Good point, this case doesn’t add new coverage beyond the existing ones. I’ll remove it to keep the tests focused.

kou · 2026-04-08T13:31:31Z

cpp/src/arrow/util/string_test.cc

+  auto r1 = arrow::util::base64_decode("====");
+  ASSERT_FALSE(r1.ok());


It seems that this is an invalid padding case.

You are right.. this case should fall under invalid padding I’ll move it accordingly.

kou · 2026-04-08T13:44:34Z

cpp/src/arrow/vendored/base64.cpp

 }

-std::string base64_decode(std::string_view encoded_string) {
+arrow::Result<std::string> base64_decode(std::string_view encoded_string) {


We can use Result here because this is in arrow::util namespace:

Suggested change

arrow::Result<std::string> base64_decode(std::string_view encoded_string) {

Result<std::string> base64_decode(std::string_view encoded_string) {

Good point, I’ll update this to use Result directly within the namespace.

kou · 2026-04-08T13:44:55Z

cpp/src/arrow/vendored/base64.cpp

+  if (padding_start != std::string::npos) {
+    for (size_t k = padding_start; k < encoded_string.size(); ++k) {
+      if (encoded_string[k] != '=') {
+        return arrow::Status::Invalid("Invalid base64 input: padding character '=' found at invalid position");


Suggested change

return arrow::Status::Invalid("Invalid base64 input: padding character '=' found at invalid position");

return Status::Invalid("Invalid base64 input: padding character '=' found at invalid position");

kou · 2026-04-08T13:45:58Z

cpp/src/arrow/vendored/base64.cpp

+  auto is_base64 = [](unsigned char c) -> bool {
+    return (std::isalnum(c) || (c == '+') || (c == '/'));
+  };


Why do we need to redefine this?

The redefinition isn’t necessary. I’ll remove this and reuse the existing base64_chars for validation instead.

kou · 2026-04-08T13:48:38Z

cpp/src/arrow/vendored/base64.cpp

+  size_t padding_start = encoded_string.find('=');
+  if (padding_start != std::string::npos) {
+    for (size_t k = padding_start; k < encoded_string.size(); ++k) {
+      if (encoded_string[k] != '=') {
+        return arrow::Status::Invalid("Invalid base64 input: padding character '=' found at invalid position");
+      }
+    }
+
+    size_t padding_count = encoded_string.size() - padding_start;
+    if (padding_count > 2) {
+      return arrow::Status::Invalid("Invalid base64 input: too many padding characters");
+    }
+  }
+
+    for (char c : encoded_string) {
+      if (c != '=' && !is_base64(c)) {
+        return arrow::Status::Invalid("Invalid base64 input: contains non-base64 character '" + std::string(1, c) + "'");
+      }
+    }


These validations traverses the encoded_string multiple times, right? Does this have performance penalty for large input?
Can we optimize them?

Copilot

Pull request overview

This PR addresses a correctness issue in Arrow’s C++ base64 decoder by ensuring malformed base64 input is detected instead of producing silently truncated/partial output.

Changes:

Adds pre-validation for base64 input (length, padding placement, invalid characters) in base64_decode.
Changes base64_decode API to return arrow::Result<std::string> with Status::Invalid on malformed input.
Adds unit tests covering valid/invalid decoding cases (and adjusts a couple of ToChars assertions).

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 7 comments.

File	Description
cpp/src/arrow/vendored/base64.cpp	Adds base64 input validation and switches decode to return errors instead of partial output.
cpp/src/arrow/util/base64.h	Updates public API signature of `base64_decode` to return `Result<std::string>`.
cpp/src/arrow/util/string_test.cc	Adds tests for base64 decode validity/error cases and tweaks `ToChars` expectations.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-04-08T13:53:51Z

cpp/src/arrow/util/base64.h


 ARROW_EXPORT
-std::string base64_decode(std::string_view s);
+arrow::Result<std::string> base64_decode(std::string_view s);


base64_decode was changed from returning std::string to arrow::Result<std::string>, but there are existing call sites in the repo that still treat it as a std::string (e.g., constructing streams, assigning to std::string). As-is, this is an API/ABI breaking change and will not compile unless all callers are updated or a backwards-compatible overload/wrapper is kept.

Suggested change

arrow::Result<std::string> base64_decode(std::string_view s);

std::string base64_decode(std::string_view s);

Copilot · 2026-04-08T13:53:52Z

cpp/src/arrow/util/base64.h

 std::string base64_encode(std::string_view s);

 ARROW_EXPORT
-std::string base64_decode(std::string_view s);
+arrow::Result<std::string> base64_decode(std::string_view s);



This change conflicts with the PR description/user-facing behavior: the description says invalid input should return an empty string, but the new signature returns Result<std::string> and the implementation returns Status::Invalid(...) on malformed inputs. Please align the implementation/API and the stated behavior (either update the description and downstream expectations, or preserve the old std::string API that returns "" on invalid input).

Copilot · 2026-04-08T13:53:52Z

cpp/src/arrow/vendored/base64.cpp

 #include "arrow/util/base64.h"
+#include "arrow/util/logging.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
 #include <iostream>
+#include <cctype>


arrow/util/logging.h is newly included here but isn't used anywhere in this file. Please remove the unused include to avoid unnecessary dependencies and potential lint/Werror failures.

Copilot · 2026-04-08T13:53:52Z

cpp/src/arrow/vendored/base64.cpp

+  static const std::string base64_chars =
+               "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+               "abcdefghijklmnopqrstuvwxyz"
+               "0123456789+/";
+
+  auto is_base64 = [](unsigned char c) -> bool {
+    return (std::isalnum(c) || (c == '+') || (c == '/'));
+  };
+


Inside base64_decode, base64_chars and is_base64 are redefined even though the same base64_chars and is_base64 already exist at file scope above. This introduces name shadowing (potentially tripping -Wshadow) and also leaves the file-scope is_base64 unused. Prefer reusing the existing helpers (or refactor to a single definition) to avoid warnings and duplication.

Suggested change

static const std::string base64_chars =

"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

"abcdefghijklmnopqrstuvwxyz"

"0123456789+/";

auto is_base64 = [](unsigned char c) -> bool {

return (std::isalnum(c) || (c == '+') || (c == '/'));

};

Copilot · 2026-04-08T13:53:53Z

cpp/src/arrow/vendored/base64.cpp

+  }
+
+  size_t padding_start = encoded_string.find('=');
+  if (padding_start != std::string::npos) {


padding_start is computed via encoded_string.find('=') on a std::string_view, but compared against std::string::npos. This works but is inconsistent and easy to misread; prefer comparing against std::string_view::npos when operating on a string_view.

Suggested change

if (padding_start != std::string::npos) {

if (padding_start != std::string_view::npos) {

Copilot · 2026-04-08T13:53:53Z

cpp/src/arrow/vendored/base64.cpp

+    for (char c : encoded_string) {
+      if (c != '=' && !is_base64(c)) {
+        return arrow::Status::Invalid("Invalid base64 input: contains non-base64 character '" + std::string(1, c) + "'");
+      }
+    }


The invalid-character error message embeds the raw byte into the Status string (std::string(1, c)). For non-printable / non-UTF8 bytes (your tests include 0xFF), this can produce unreadable or problematic error messages/logging. Consider reporting the offending byte as an escaped/hex value (and/or the index) instead of inserting it verbatim.

Suggested change

for (char c : encoded_string) {

if (c != '=' && !is_base64(c)) {

return arrow::Status::Invalid("Invalid base64 input: contains non-base64 character '" + std::string(1, c) + "'");

}

}

auto format_hex_byte = [](unsigned char c) -> std::string {

static const char hex_digits[] = "0123456789ABCDEF";

std::string hex = "0x00";

hex[2] = hex_digits[(c >> 4) & 0x0F];

hex[3] = hex_digits[c & 0x0F];

return hex;

};

for (size_t k = 0; k < encoded_string.size(); ++k) {

unsigned char c = static_cast<unsigned char>(encoded_string[k]);

if (c != '=' && !is_base64(c)) {

return arrow::Status::Invalid(

"Invalid base64 input: contains non-base64 byte " + format_hex_byte(c) +

" at position " + std::to_string(k));

}

}

Copilot · 2026-04-08T13:53:53Z

cpp/src/arrow/util/string_test.cc

+}
+
+TEST(Base64DecodeTest, NonAsciiInput) {
+  std::string input = std::string("abcd") + char(0xFF) + "==";


NonAsciiInput is currently guaranteed to fail the new size % 4 == 0 validation (the constructed string length is 7), so it doesn't actually exercise the non-ASCII character validation path. Adjust the test input to a length that is a multiple of 4 so it fails specifically due to the non-base64 byte (e.g., keep padding rules valid and include the 0xFF byte).

Suggested change

std::string input = std::string("abcd") + char(0xFF) + "==";

std::string input = std::string("abc") + static_cast<char>(0xFF);

…id input

Reranko05 · 2026-04-08T17:11:04Z

Hi @kou, I have addressed all review comments:

Removed redundant helpers and reused existing base64_chars
Merged validation into decoding loop (single-pass)
Fixed padding validation to ensure '=' only appears at the end
Cleaned up includes and namespace usage
Updated tests to improve coverage and follow Arrow conventions

All tests pass locally.

kou · 2026-04-08T21:14:33Z

Could you enable GitHub Actions on your fork to run CI on your fork too?

Copilot

Pull request overview

Copilot reviewed 3 out of 3 changed files in this pull request and generated 3 comments.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-04-08T21:18:44Z

cpp/src/arrow/vendored/base64.cpp

+  while (in_len-- && encoded_string[in_] != '=') {
+    unsigned char c = encoded_string[in_];
+
+    if (base64_chars.find(c) == std::string::npos) {
+      return Status::Invalid("Invalid base64 input: contains non-base64 byte at position " + std::to_string(in_));
+    }


The validation loop can exit with i == 2 for inputs with == padding (e.g. "Zg=="). In the trailing partial-quantum handling later in this function, char_array_3[1] is computed using char_array_4[2] even when i == 2, which reads an uninitialized stack value (undefined behavior). Consider zero-initializing the remaining char_array_4 slots before computing char_array_3, or only computing the bytes that will actually be appended based on i.

Copilot · 2026-04-08T21:18:44Z

cpp/src/arrow/vendored/base64.cpp

+  if (encoded_string.size() % 4 != 0) {
+    return Status::Invalid("Invalid base64 input: length is not a multiple of 4");
+  }


PR description says invalid input should "return an empty string", but the implementation now returns Status::Invalid(...) (and the header signature is Result<std::string>). Either update the PR description/user-facing notes to reflect the new error-reporting API, or adjust the implementation to match the documented behavior (e.g. preserve the std::string API and return "" on invalid input).

Copilot · 2026-04-08T21:18:45Z

cpp/src/arrow/util/string_test.cc

+TEST(Base64DecodeTest, InvalidLength) {
+  ASSERT_RAISES(Invalid, arrow::util::base64_decode("abc"));
+  ASSERT_RAISES(Invalid, arrow::util::base64_decode("abcde"));
+}
+
+TEST(Base64DecodeTest, InvalidCharacters) {
+  ASSERT_RAISES(Invalid, arrow::util::base64_decode("ab$="));
+}


These tests assert that invalid input raises Invalid, but the PR description/user-facing notes say invalid base64 should return an empty string. Please align the tests with the intended public behavior (either update the implementation/headers to return "" on invalid input, or update the PR description to reflect the new error-returning API).

kou · 2026-04-08T21:26:19Z

cpp/src/arrow/util/string_test.cc

+  ASSERT_OK_AND_ASSIGN(auto two_paddings, arrow::util::base64_decode("Zg=="));
+  EXPECT_EQ(two_paddings, "f");
+
+  ASSERT_OK_AND_ASSIGN(auto one_padding, arrow::util::base64_decode("Zm8="));
+  EXPECT_EQ(one_padding, "fo");
+
+  ASSERT_OK_AND_ASSIGN(auto no_padding, arrow::util::base64_decode("Zm9v"));
+  EXPECT_EQ(no_padding, "foo");
+
+  ASSERT_OK_AND_ASSIGN(auto single_char, arrow::util::base64_decode("TQ=="));
+  EXPECT_EQ(single_char, "M");


It seems that f and M cases check the same pattern.

kou · 2026-04-08T21:27:24Z

cpp/src/arrow/util/string_test.cc

+  ASSERT_RAISES(Invalid, arrow::util::base64_decode("abc"));
+  ASSERT_RAISES(Invalid, arrow::util::base64_decode("abcde"));


Ah, sorry. Could you use ASSERT_RAISES_WITH_MESSAGE() to check message too?

kou · 2026-04-08T21:29:59Z

cpp/src/arrow/util/string_test.cc

Could you create base64_test.cc instead of reusing existing string_test.cc?
In general, we create XXX_test.cc for XXX.{cc,h}.

We can build base64_test.cc with the following CMakeLists.txt change:

diff --git a/cpp/src/arrow/util/CMakeLists.txt b/cpp/src/arrow/util/CMakeLists.txt index 4352716ebd..deb3e9e3fb 100644 --- a/cpp/src/arrow/util/CMakeLists.txt +++ b/cpp/src/arrow/util/CMakeLists.txt @@ -49,6 +49,7 @@ add_arrow_test(utility-test SOURCES align_util_test.cc atfork_test.cc + base64_test.cc byte_size_test.cc byte_stream_split_test.cc cache_test.cc

kou · 2026-04-08T21:35:58Z

cpp/src/arrow/vendored/base64.cpp

+    return arrow::Status::Invalid("Invalid base64 input: length is not a multiple of 4");
+  }
+
+  size_t padding_start = encoded_string.find('=');


It seems that the current implementation still uses 2 passes.

Reranko05 · 2026-04-09T06:40:54Z

Could you enable GitHub Actions on your fork to run CI on your fork too?

Sure, I'll do that.

github-actions bot added Component: C++ awaiting review Awaiting review labels Apr 4, 2026

Reranko05 mentioned this pull request Apr 4, 2026

[C++] arrow::util::base64_decode silently truncates on invalid characters instead of reporting an error #49614

Open

dmitry-chirkov-dremio suggested changes Apr 4, 2026

View reviewed changes

Reranko05 force-pushed the fix-base64-invalid-input branch from 4670ec5 to 5c7db64 Compare April 4, 2026 20:38

Reranko05 requested a review from dmitry-chirkov-dremio April 4, 2026 20:42

Reranko05 force-pushed the fix-base64-invalid-input branch from 5c7db64 to 8f053b7 Compare April 4, 2026 21:07

kou reviewed Apr 5, 2026

View reviewed changes

Reranko05 force-pushed the fix-base64-invalid-input branch from 8f053b7 to 34a388c Compare April 8, 2026 09:53

dmitry-chirkov-dremio suggested changes Apr 8, 2026

View reviewed changes

kou reviewed Apr 8, 2026

View reviewed changes

kou requested a review from Copilot April 8, 2026 13:49

Copilot started reviewing on behalf of kou April 8, 2026 13:50 View session

Copilot AI reviewed Apr 8, 2026

View reviewed changes

apacheGH-49614: [C++] Fix silent truncation in base64_decode on inval…

ed84348

…id input

Reranko05 force-pushed the fix-base64-invalid-input branch from 34a388c to ed84348 Compare April 8, 2026 17:09

kou requested a review from Copilot April 8, 2026 21:14

Copilot started reviewing on behalf of kou April 8, 2026 21:15 View session

Copilot AI reviewed Apr 8, 2026

View reviewed changes

kou reviewed Apr 8, 2026

View reviewed changes

		auto r1 = arrow::util::base64_decode("Zg==");
		ASSERT_TRUE(r1.ok());

	auto r1 = arrow::util::base64_decode("Zg==");
	ASSERT_TRUE(r1.ok());
	ASSERT_OK_AND_ASSIGN(auto string, arrow::util::base64_decode("Zg=="));

		auto r1 = arrow::util::base64_decode("====");
		ASSERT_FALSE(r1.ok());

	arrow::Result<std::string> base64_decode(std::string_view encoded_string) {
	Result<std::string> base64_decode(std::string_view encoded_string) {

	return arrow::Status::Invalid("Invalid base64 input: padding character '=' found at invalid position");
	return Status::Invalid("Invalid base64 input: padding character '=' found at invalid position");

	arrow::Result<std::string> base64_decode(std::string_view s);
	std::string base64_decode(std::string_view s);

	if (padding_start != std::string::npos) {
	if (padding_start != std::string_view::npos) {

-    for (char c : encoded_string) {
-      if (c != '=' && !is_base64(c)) {
-        return arrow::Status::Invalid("Invalid base64 input: contains non-base64 character '" + std::string(1, c) + "'");
-      }
-    }
+  auto format_hex_byte = [](unsigned char c) -> std::string {
+    static const char hex_digits[] = "0123456789ABCDEF";
+    std::string hex = "0x00";
+    hex[2] = hex_digits[(c >> 4) & 0x0F];
+    hex[3] = hex_digits[c & 0x0F];
+    return hex;
+  };
+  for (size_t k = 0; k < encoded_string.size(); ++k) {
+    unsigned char c = static_cast<unsigned char>(encoded_string[k]);
+    if (c != '=' && !is_base64(c)) {
+      return arrow::Status::Invalid(
+          "Invalid base64 input: contains non-base64 byte " + format_hex_byte(c) +
+          " at position " + std::to_string(k));
+    }
+  }

	std::string input = std::string("abcd") + char(0xFF) + "==";
	std::string input = std::string("abc") + static_cast<char>(0xFF);

		ASSERT_RAISES(Invalid, arrow::util::base64_decode("abc"));
		ASSERT_RAISES(Invalid, arrow::util::base64_decode("abcde"));

Conversation

Reranko05 commented Apr 4, 2026 • edited by github-actions bot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Rationale for this change

What changes are included in this PR?

Are these changes tested?

Are there any user-facing changes?

Uh oh!

github-actions bot commented Apr 4, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reranko05 commented Apr 4, 2026

Uh oh!

kou left a comment

Choose a reason for hiding this comment

Uh oh!

kou commented Apr 5, 2026

Uh oh!

Reranko05 commented Apr 5, 2026

Uh oh!

kou commented Apr 5, 2026

Uh oh!

Reranko05 commented Apr 5, 2026

Uh oh!

Reranko05 commented Apr 7, 2026

Uh oh!

kou commented Apr 8, 2026

Uh oh!

Reranko05 commented Apr 8, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reranko05 Apr 8, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Reranko05 commented Apr 4, 2026 •

edited by github-actions bot

Loading

Reranko05 Apr 8, 2026 •

edited

Loading

Reranko05 commented Apr 8, 2026 •

edited

Loading