LLVM 19.0.0git
Base64.cpp
Go to the documentation of this file.
1//===- Base64.cpp ---------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#define INVALID_BASE64_BYTE 64
10#include "llvm/Support/Base64.h"
11
12static char decodeBase64Byte(uint8_t Ch) {
13 constexpr char Inv = INVALID_BASE64_BYTE;
14 static const char DecodeTable[] = {
15 Inv, Inv, Inv, Inv, Inv, Inv, Inv, Inv, // ........
16 Inv, Inv, Inv, Inv, Inv, Inv, Inv, Inv, // ........
17 Inv, Inv, Inv, Inv, Inv, Inv, Inv, Inv, // ........
18 Inv, Inv, Inv, Inv, Inv, Inv, Inv, Inv, // ........
19 Inv, Inv, Inv, Inv, Inv, Inv, Inv, Inv, // ........
20 Inv, Inv, Inv, 62, Inv, Inv, Inv, 63, // ...+.../
21 52, 53, 54, 55, 56, 57, 58, 59, // 01234567
22 60, 61, Inv, Inv, Inv, 0, Inv, Inv, // 89...=..
23 Inv, 0, 1, 2, 3, 4, 5, 6, // .ABCDEFG
24 7, 8, 9, 10, 11, 12, 13, 14, // HIJKLMNO
25 15, 16, 17, 18, 19, 20, 21, 22, // PQRSTUVW
26 23, 24, 25, Inv, Inv, Inv, Inv, Inv, // XYZ.....
27 Inv, 26, 27, 28, 29, 30, 31, 32, // .abcdefg
28 33, 34, 35, 36, 37, 38, 39, 40, // hijklmno
29 41, 42, 43, 44, 45, 46, 47, 48, // pqrstuvw
30 49, 50, 51 // xyz.....
31 };
32 if (Ch >= sizeof(DecodeTable))
33 return Inv;
34 return DecodeTable[Ch];
35}
36
38 std::vector<char> &Output) {
39 constexpr char Base64InvalidByte = INVALID_BASE64_BYTE;
40 // Invalid table value with short name to fit in the table init below. The
41 // invalid value is 64 since valid base64 values are 0 - 63.
42 Output.clear();
43 const uint64_t InputLength = Input.size();
44 if (InputLength == 0)
45 return Error::success();
46 // Make sure we have a valid input string length which must be a multiple
47 // of 4.
48 if ((InputLength % 4) != 0)
49 return createStringError(std::errc::illegal_byte_sequence,
50 "Base64 encoded strings must be a multiple of 4 "
51 "bytes in length");
52 const uint64_t FirstValidEqualIdx = InputLength - 2;
53 char Hex64Bytes[4];
54 for (uint64_t Idx = 0; Idx < InputLength; Idx += 4) {
55 for (uint64_t ByteOffset = 0; ByteOffset < 4; ++ByteOffset) {
56 const uint64_t ByteIdx = Idx + ByteOffset;
57 const char Byte = Input[ByteIdx];
58 const char DecodedByte = decodeBase64Byte(Byte);
59 bool Illegal = DecodedByte == Base64InvalidByte;
60 if (!Illegal && Byte == '=') {
61 if (ByteIdx < FirstValidEqualIdx) {
62 // We have an '=' in the middle of the string which is invalid, only
63 // the last two characters can be '=' characters.
64 Illegal = true;
65 } else if (ByteIdx == FirstValidEqualIdx && Input[ByteIdx + 1] != '=') {
66 // We have an equal second to last from the end and the last character
67 // is not also an equal, so the '=' character is invalid
68 Illegal = true;
69 }
70 }
71 if (Illegal)
72 return createStringError(
73 std::errc::illegal_byte_sequence,
74 "Invalid Base64 character %#2.2x at index %" PRIu64, Byte, ByteIdx);
75 Hex64Bytes[ByteOffset] = DecodedByte;
76 }
77 // Now we have 6 bits of 3 bytes in value in each of the Hex64Bytes bytes.
78 // Extract the right bytes into the Output buffer.
79 Output.push_back((Hex64Bytes[0] << 2) + ((Hex64Bytes[1] >> 4) & 0x03));
80 Output.push_back((Hex64Bytes[1] << 4) + ((Hex64Bytes[2] >> 2) & 0x0f));
81 Output.push_back((Hex64Bytes[2] << 6) + (Hex64Bytes[3] & 0x3f));
82 }
83 // If we had valid trailing '=' characters strip the right number of bytes
84 // from the end of the output buffer. We already know that the Input length
85 // it a multiple of 4 and is not zero, so direct character access is safe.
86 if (Input.back() == '=') {
87 Output.pop_back();
88 if (Input[InputLength - 2] == '=')
89 Output.pop_back();
90 }
91 return Error::success();
92}
static char decodeBase64Byte(uint8_t Ch)
Definition: Base64.cpp:12
#define INVALID_BASE64_BYTE
Definition: Base64.cpp:9
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
char back() const
back - Get the last character in the string.
Definition: StringRef.h:146
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1244
llvm::Error decodeBase64(llvm::StringRef Input, std::vector< char > &Output)
Definition: Base64.cpp:37