diff --git a/extensions/expression-language/Expression.cpp b/extensions/expression-language/Expression.cpp
index 873e522..a25e1d3 100644
--- a/extensions/expression-language/Expression.cpp
+++ b/extensions/expression-language/Expression.cpp
@@ -48,7 +48,7 @@
 #include <sys/types.h>
 #endif
 
-#include "utils/base64.h"
+#include "utils/StringUtils.h"
 #include "Driver.h"
 
 #ifdef EXPRESSION_LANGUAGE_USE_DATE
@@ -709,30 +709,11 @@
 }
 
 Value expr_base64Encode(const std::vector<Value> &args) {
-  auto arg_0 = args[0].asString();
-  char *b64_out = nullptr;
-  auto b64_len = Curl_base64_encode(arg_0.c_str(), arg_0.length(), &b64_out);
-  if (b64_out) {
-    std::string result(b64_out, b64_len);
-    free(b64_out);
-    return Value(result);
-  } else {
-    throw std::runtime_error("Failed to encode base64");
-  }
+  return Value(utils::StringUtils::to_base64(args[0].asString()));
 }
 
 Value expr_base64Decode(const std::vector<Value> &args) {
-  auto arg_0 = args[0].asString();
-  unsigned char *decode_out = nullptr;
-  // size_t Curl_base64_decode(const char *src, unsigned char **outptr)
-  auto out_len = Curl_base64_decode(arg_0.c_str(), &decode_out);
-  if (decode_out) {
-    std::string result(reinterpret_cast<char *>(decode_out), out_len);
-    free(decode_out);
-    return Value(result);
-  } else {
-    throw std::runtime_error("Failed to encode base64");
-  }
+  return Value(utils::StringUtils::from_base64(args[0].asString()));
 }
 
 #ifdef EXPRESSION_LANGUAGE_USE_REGEX
diff --git a/extensions/sftp/client/SFTPClient.cpp b/extensions/sftp/client/SFTPClient.cpp
index d2a2716..8f66ccc 100644
--- a/extensions/sftp/client/SFTPClient.cpp
+++ b/extensions/sftp/client/SFTPClient.cpp
@@ -26,7 +26,6 @@
 #include "utils/StringUtils.h"
 #include "utils/ScopeGuard.h"
 #include "utils/StringUtils.h"
-#include "utils/base64.h"
 
 namespace org {
 namespace apache {
@@ -358,11 +357,9 @@
         logger_->log_warn("Host %s not found in the host key file", hostname_.c_str());
         break;
       case LIBSSH2_KNOWNHOST_CHECK_MISMATCH: {
-        char* b64_out = nullptr;
-        auto b64_len = Curl_base64_encode(hostkey, hostkey_len, &b64_out);
+        auto hostkey_b64 = utils::StringUtils::to_base64(reinterpret_cast<const uint8_t*>(hostkey), hostkey_len);
         logger_->log_warn("Host key mismatch for %s, expected: %s, actual: %s", hostname_.c_str(),
-                          known_host == nullptr ? "" : known_host->key,
-                          b64_out == nullptr ? "" : std::string(b64_out, b64_len).c_str());
+                          known_host == nullptr ? "" : known_host->key, hostkey_b64.c_str());
         break;
       }
       case LIBSSH2_KNOWNHOST_CHECK_MATCH:
diff --git a/libminifi/include/utils/StringUtils.h b/libminifi/include/utils/StringUtils.h
index b45f73d..fc44d93 100644
--- a/libminifi/include/utils/StringUtils.h
+++ b/libminifi/include/utils/StringUtils.h
@@ -17,6 +17,7 @@
 #ifndef LIBMINIFI_INCLUDE_IO_STRINGUTILS_H_
 #define LIBMINIFI_INCLUDE_IO_STRINGUTILS_H_
 #include <iostream>
+#include <cstring>
 #include <functional>
 #ifdef WIN32
 	#include <cwctype>
@@ -235,34 +236,7 @@
    * @param hex_length the length of hex
    * @return true on success
    */
-  inline static bool from_hex(uint8_t* data, size_t* data_length, const char* hex, size_t hex_length) {
-    if (*data_length < hex_length / 2) {
-      return false;
-    }
-    uint8_t n1;
-    bool found_first_nibble = false;
-    *data_length = 0;
-    for (size_t i = 0; i < hex_length; i++) {
-      const uint8_t byte = static_cast<uint8_t>(hex[i]);
-      if (byte > 127) {
-        continue;
-      }
-      uint8_t n = hex_lut[byte];
-      if (n != SKIP) {
-        if (found_first_nibble) {
-          data[(*data_length)++] = n1 << 4 | n;
-          found_first_nibble = false;
-        } else {
-          n1 = n;
-          found_first_nibble = true;
-        }
-      }
-    }
-    if (found_first_nibble) {
-      return false;
-    }
-    return true;
-  }
+  static bool from_hex(uint8_t* data, size_t* data_length, const char* hex, size_t hex_length);
 
   /**
    * Hexdecodes a string
@@ -270,15 +244,7 @@
    * @param hex_length the length of hex
    * @return the vector containing the hexdecoded bytes
    */
-  inline static std::vector<uint8_t> from_hex(const char* hex, size_t hex_length) {
-    std::vector<uint8_t> decoded(hex_length / 2);
-    size_t data_length = decoded.size();
-    if (!from_hex(decoded.data(), &data_length, hex, hex_length)) {
-      throw std::runtime_error("Hexencoded string is malformatted");
-    }
-    decoded.resize(data_length);
-    return decoded;
-  }
+  static std::vector<uint8_t> from_hex(const char* hex, size_t hex_length);
 
   /**
    * Hexdecodes a string
@@ -292,33 +258,22 @@
 
   /**
    * Hexencodes bytes and writes the result to hex
-   * @param hex the output buffer where the hexencoded string will be written. Must be at least length * 2 bytes long.
+   * @param hex the output buffer where the hexencoded bytes will be written. Must be at least length * 2 bytes long.
    * @param data the bytes to be hexencoded
-   * @param length the length of data. Must not be larger than std::numeric_limits<size_t>::max()
+   * @param length the length of data. Must not be larger than std::numeric_limits<size_t>::max() / 2
    * @param uppercase whether the hexencoded string should be upper case
+   * @return the size of hexencoded bytes
    */
-  inline static void to_hex(char* hex, const uint8_t* data, size_t length, bool uppercase) {
-    for (size_t i = 0; i < length; i++) {
-      hex[i * 2] = nibble_to_hex(data[i] >> 4, uppercase);
-      hex[i * 2 + 1] = nibble_to_hex(data[i] & 0xf, uppercase);
-    }
-  }
+  static size_t to_hex(char* hex, const uint8_t* data, size_t length, bool uppercase);
 
   /**
    * Creates a hexencoded string from data
    * @param data the bytes to be hexencoded
-   * @param length the length of the data
+   * @param length the length of data. Must not be larger than std::numeric_limits<size_t>::max() / 2 - 1
    * @param uppercase whether the hexencoded string should be upper case
    * @return the hexencoded string
    */
-  inline static std::string to_hex(const uint8_t* data, size_t length, bool uppercase = false) {
-    if (length > (std::numeric_limits<size_t>::max)() / 2) {
-      throw std::length_error("Data is too large to be hexencoded");
-    }
-    std::vector<char> buf(length * 2);
-    to_hex(buf.data(), data, length, uppercase);
-    return std::string(buf.data(), buf.size());
-  }
+  static std::string to_hex(const uint8_t* data, size_t length, bool uppercase = false);
 
   /**
    * Hexencodes a string
@@ -330,6 +285,87 @@
     return to_hex(reinterpret_cast<const uint8_t*>(str.data()), str.length(), uppercase);
   }
 
+  /**
+   * Hexencodes a vector of bytes
+   * @param data the vector of bytes to be hexencoded
+   * @param uppercase whether the hexencoded string should be upper case
+   * @return the hexencoded string
+   */
+  inline static std::string to_hex(const std::vector<uint8_t>& data, bool uppercase = false) {
+    return to_hex(data.data(), data.size(), uppercase);
+  }
+
+  /**
+   * Decodes the Base64 encoded string into data
+   * @param data the output buffer where the decoded bytes will be written. Must be at least (base64_length / 4 + 1) * 3 bytes long.
+   * @param data_length pointer to the length of data the data buffer. It will be filled with the length of the decoded bytes.
+   * @param base64 the Base64 encoded string
+   * @param base64_length the length of base64
+   * @return true on success
+   */
+  static bool from_base64(uint8_t* data, size_t* data_length, const char* base64, size_t base64_length);
+
+  /**
+   * Base64 decodes a string
+   * @param base64 the Base64 encoded string
+   * @param base64_length the length of base64
+   * @return the vector containing the decoded bytes
+   */
+  static std::vector<uint8_t> from_base64(const char* base64, size_t base64_length);
+
+  /**
+   * Base64 decodes a string
+   * @param base64 the Base64 encoded string
+   * @return the decoded string
+   */
+  inline static std::string from_base64(const std::string& base64) {
+    auto data = from_base64(base64.data(), base64.length());
+    return std::string(reinterpret_cast<char*>(data.data()), data.size());
+  }
+
+  /**
+   * Base64 encodes bytes and writes the result to base64
+   * @param base64 the output buffer where the Base64 encoded bytes will be written. Must be at least (base64_length / 3 + 1) * 4 bytes long.
+   * @param data the bytes to be Base64 encoded
+   * @param length the length of data. Must not be larger than std::numeric_limits<size_t>::max() * 3 / 4 - 3
+   * @param url if true, the URL-safe Base64 encoding will be used
+   * @param padded if true, padding is added to the Base64 encoded string
+   * @return the size of Base64 encoded bytes
+   */
+  static size_t to_base64(char* base64, const uint8_t* data, size_t length, bool url, bool padded);
+
+  /**
+   * Creates a Base64 encoded string from data
+   * @param data the bytes to be Base64 encoded
+   * @param length the length of the data
+   * @param url if true, the URL-safe Base64 encoding will be used
+   * @param padded if true, padding is added to the Base64 encoded string
+   * @return the Base64 encoded string
+   */
+  static std::string to_base64(const uint8_t* data, size_t length, bool url = false, bool padded = true);
+
+  /**
+   * Base64 encodes a string
+   * @param str the string to be Base64 encoded
+   * @param url if true, the URL-safe Base64 encoding will be used
+   * @param padded if true, padding is added to the Base64 encoded string
+   * @return the Base64 encoded string
+   */
+  inline static std::string to_base64(const std::string& str, bool url = false, bool padded = true) {
+    return to_base64(reinterpret_cast<const uint8_t*>(str.data()), str.length(), url, padded);
+  }
+
+  /**
+   * Base64 encodes a string
+   * @param str the string to be Base64 encoded
+   * @param url if true, the URL-safe Base64 encoding will be used
+   * @param padded if true, padding is added to the Base64 encoded string
+   * @return the Base64 encoded string
+   */
+  inline static std::string to_base64(const std::vector<uint8_t>& str, bool url = false, bool padded = true) {
+    return to_base64(str.data(), str.size(), url, padded);
+  }
+
   static std::string replaceMap(std::string source_string, const std::map<std::string, std::string> &replace_map);
 
  private:
@@ -341,7 +377,15 @@
     }
   }
 
-  static constexpr uint8_t SKIP = 255;
+  inline static void base64_digits_to_bytes(const uint8_t digits[4], uint8_t* bytes) {
+    bytes[0] = digits[0] << 2 | digits[1] >> 4;
+    bytes[1] = (digits[1] & 0x0f) << 4 | digits[2] >> 2;
+    bytes[2] = (digits[2] & 0x03) << 6 | digits[3];
+  }
+
+  static constexpr uint8_t SKIP = 0xff;
+  static constexpr uint8_t ILGL = 0xfe;
+  static constexpr uint8_t PDNG = 0xfd;
   static constexpr uint8_t hex_lut[128] =
       {SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
        SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
@@ -360,6 +404,26 @@
        SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
        SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP};
 
+  static constexpr const char base64_enc_lut[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  static constexpr const char base64_url_enc_lut[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  static constexpr uint8_t base64_dec_lut[128] =
+      {ILGL, ILGL, ILGL, ILGL, ILGL, ILGL, ILGL, ILGL,
+       ILGL, ILGL, SKIP, ILGL, ILGL, SKIP, ILGL, ILGL,
+       ILGL, ILGL, ILGL, ILGL, ILGL, ILGL, ILGL, ILGL,
+       ILGL, ILGL, ILGL, ILGL, ILGL, ILGL, ILGL, ILGL,
+       ILGL, ILGL, ILGL, ILGL, ILGL, ILGL, ILGL, ILGL,
+       ILGL, ILGL, ILGL, 0x3e, ILGL, 0x3e, ILGL, 0x3f,
+       0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
+       0x3c, 0x3d, ILGL, ILGL, ILGL, PDNG, ILGL, ILGL,
+       ILGL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+       0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+       0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
+       0x17, 0x18, 0x19, ILGL, ILGL, ILGL, ILGL, 0x3f,
+       ILGL, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+       0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+       0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
+       0x31, 0x32, 0x33, ILGL, ILGL, ILGL, ILGL, ILGL};
+
 };
 
 } /* namespace utils */
diff --git a/libminifi/include/utils/base64.h b/libminifi/include/utils/base64.h
deleted file mode 100644
index d99a3fe..0000000
--- a/libminifi/include/utils/base64.h
+++ /dev/null
@@ -1,188 +0,0 @@
-/***************************************************************************
- *                                  _   _ ____  _
- *  Project                     ___| | | |  _ \| |
- *                             / __| | | | |_) | |
- *                            | (__| |_| |  _ <| |___
- *                             \___|\___/|_| \_\_____|
- *
- * Copyright (C) 1998 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al.
- *
- * This software is licensed as described in the file COPYING, which
- * you should have received as part of this distribution. The terms
- * are also available at http://curl.haxx.se/docs/copyright.html.
- *
- * You may opt to use, copy, modify, merge, publish, distribute and/or sell
- * copies of the Software, and permit persons to whom the Software is
- * furnished to do so, under the terms of the COPYING file.
- *
- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
- * KIND, either express or implied.
- *
- * $Id$
- ***************************************************************************/
-
-#ifndef NIFI_MINIFI_CPP_BASE64_H
-#define NIFI_MINIFI_CPP_BASE64_H
-
-/* ---- Base64 Encoding/Decoding Table --- */
-static const char table64[]=
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-static void decodeQuantum(unsigned char *dest, const char *src)
-{
-  unsigned int x = 0;
-  int i;
-  char *found;
-
-  for(i = 0; i < 4; i++) {
-    if((found = strchr((char *)table64, src[i])))
-      x = (x << 6) + (unsigned int)(found - table64);
-    else if(src[i] == '=')
-      x = (x << 6);
-  }
-
-  dest[2] = (unsigned char)(x & 255);
-  x >>= 8;
-  dest[1] = (unsigned char)(x & 255);
-  x >>= 8;
-  dest[0] = (unsigned char)(x & 255);
-}
-
-
-/*
- * Curl_base64_decode()
- *
- * Given a base64 string at src, decode it and return an allocated memory in
- * the *outptr. Returns the length of the decoded data.
- */
-static size_t Curl_base64_decode(const char *src, unsigned char **outptr)
-{
-  int length = 0;
-  int equalsTerm = 0;
-  int i;
-  int numQuantums;
-  unsigned char lastQuantum[3];
-  size_t rawlen=0;
-  unsigned char *newstr;
-
-  *outptr = NULL;
-
-  while((src[length] != '=') && src[length])
-    length++;
-  /* A maximum of two = padding characters is allowed */
-  if(src[length] == '=') {
-    equalsTerm++;
-    if(src[length+equalsTerm] == '=')
-      equalsTerm++;
-  }
-  numQuantums = (length + equalsTerm) / 4;
-
-  /* Don't allocate a buffer if the decoded length is 0 */
-  if (numQuantums <= 0)
-    return 0;
-
-  rawlen = (numQuantums * 3) - equalsTerm;
-
-  /* The buffer must be large enough to make room for the last quantum
-  (which may be partially thrown out) and the zero terminator. */
-  newstr = static_cast<unsigned char *>(malloc(rawlen+4));
-  if(!newstr)
-    return 0;
-
-  *outptr = newstr;
-
-  /* Decode all but the last quantum (which may not decode to a
-  multiple of 3 bytes) */
-  for(i = 0; i < numQuantums - 1; i++) {
-    decodeQuantum((unsigned char *)newstr, src);
-    newstr += 3; src += 4;
-  }
-
-  /* This final decode may actually read slightly past the end of the buffer
-  if the input string is missing pad bytes.  This will almost always be
-  harmless. */
-  decodeQuantum(lastQuantum, src);
-  for(i = 0; i < 3 - equalsTerm; i++)
-    newstr[i] = lastQuantum[i];
-
-  newstr[i] = 0; /* zero terminate */
-  return rawlen;
-}
-
-/*
- * Curl_base64_encode()
- *
- * Returns the length of the newly created base64 string. The third argument
- * is a pointer to an allocated area holding the base64 data. If something
- * went wrong, -1 is returned.
- *
- */
-static size_t Curl_base64_encode(const char *inp, size_t insize, char **outptr)
-{
-  unsigned char ibuf[3];
-  unsigned char obuf[4];
-  int i;
-  int inputparts;
-  char *output;
-  char *base64data;
-
-  char *indata = (char *)inp;
-
-  *outptr = NULL; /* set to NULL in case of failure before we reach the end */
-
-  if(0 == insize)
-    insize = strlen(indata);
-
-  base64data = output = (char*)malloc(insize*4/3+4);
-  if(NULL == output)
-    return 0;
-
-  while(insize > 0) {
-    for (i = inputparts = 0; i < 3; i++) {
-      if(insize > 0) {
-        inputparts++;
-        ibuf[i] = *indata;
-        indata++;
-        insize--;
-      }
-      else
-        ibuf[i] = 0;
-    }
-
-    obuf[0] = (unsigned char)  ((ibuf[0] & 0xFC) >> 2);
-    obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) | \
-                               ((ibuf[1] & 0xF0) >> 4));
-    obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) | \
-                               ((ibuf[2] & 0xC0) >> 6));
-    obuf[3] = (unsigned char)   (ibuf[2] & 0x3F);
-
-    switch(inputparts) {
-      case 1: /* only one byte read */
-        snprintf(output, 5, "%c%c==",
-                 table64[obuf[0]],
-                 table64[obuf[1]]);
-        break;
-      case 2: /* two bytes read */
-        snprintf(output, 5, "%c%c%c=",
-                 table64[obuf[0]],
-                 table64[obuf[1]],
-                 table64[obuf[2]]);
-        break;
-      default:
-        snprintf(output, 5, "%c%c%c%c",
-                 table64[obuf[0]],
-                 table64[obuf[1]],
-                 table64[obuf[2]],
-                 table64[obuf[3]] );
-        break;
-    }
-    output += 4;
-  }
-  *output=0;
-  *outptr = base64data; /* make it return the actual data memory */
-
-  return strlen(base64data); /* return the length of the new data */
-}
-/* ---- End of Base64 Encoding ---- */
-
-#endif //NIFI_MINIFI_CPP_BASE64_H
diff --git a/libminifi/src/utils/StringUtils.cpp b/libminifi/src/utils/StringUtils.cpp
index af33fa0..ce96eec 100644
--- a/libminifi/src/utils/StringUtils.cpp
+++ b/libminifi/src/utils/StringUtils.cpp
@@ -164,8 +164,185 @@
   return result_string;
 }
 
+bool StringUtils::from_hex(uint8_t* data, size_t* data_length, const char* hex, size_t hex_length) {
+  if (*data_length < hex_length / 2) {
+    return false;
+  }
+  uint8_t n1;
+  bool found_first_nibble = false;
+  *data_length = 0;
+  for (size_t i = 0; i < hex_length; i++) {
+    const uint8_t byte = static_cast<uint8_t>(hex[i]);
+    if (byte > 127) {
+      continue;
+    }
+    uint8_t n = hex_lut[byte];
+    if (n != SKIP) {
+      if (found_first_nibble) {
+        data[(*data_length)++] = n1 << 4 | n;
+        found_first_nibble = false;
+      } else {
+        n1 = n;
+        found_first_nibble = true;
+      }
+    }
+  }
+  if (found_first_nibble) {
+    return false;
+  }
+  return true;
+}
+
+std::vector<uint8_t> StringUtils::from_hex(const char* hex, size_t hex_length) {
+  std::vector<uint8_t> decoded(hex_length / 2);
+  size_t data_length = decoded.size();
+  if (!from_hex(decoded.data(), &data_length, hex, hex_length)) {
+    throw std::invalid_argument("Hexencoded string is malformatted");
+  }
+  decoded.resize(data_length);
+  return decoded;
+}
+
+size_t StringUtils::to_hex(char* hex, const uint8_t* data, size_t length, bool uppercase) {
+  if (length > (std::numeric_limits<size_t>::max)() / 2) {
+    throw std::length_error("Data is too large to be hexencoded");
+  }
+  for (size_t i = 0; i < length; i++) {
+    hex[i * 2] = nibble_to_hex(data[i] >> 4, uppercase);
+    hex[i * 2 + 1] = nibble_to_hex(data[i] & 0xf, uppercase);
+  }
+  return length * 2;
+}
+
+std::string StringUtils::to_hex(const uint8_t* data, size_t length, bool uppercase /*= false*/) {
+  if (length > ((std::numeric_limits<size_t>::max)() / 2 - 1)) {
+    throw std::length_error("Data is too large to be hexencoded");
+  }
+  std::vector<char> buf(length * 2);
+  const size_t hex_length = to_hex(buf.data(), data, length, uppercase);
+  return std::string(buf.data(), hex_length);
+}
+
+bool StringUtils::from_base64(uint8_t* data, size_t* data_length, const char* base64, size_t base64_length) {
+  if (*data_length < (base64_length / 4 + 1) * 3) {
+    return false;
+  }
+
+  uint8_t digits[4];
+  size_t digit_counter = 0U;
+  size_t decoded_size = 0U;
+  size_t padding_counter = 0U;
+  size_t i;
+  for (i = 0U; i < base64_length; i++) {
+    const uint8_t byte = static_cast<uint8_t>(base64[i]);
+    if (byte > 127) {
+      return false;
+    }
+
+    const uint8_t decoded = base64_dec_lut[byte];
+    switch (decoded) {
+      case SKIP:
+        continue;
+      case ILGL:
+        return false;
+      case PDNG:
+        padding_counter++;
+        continue;
+      default:
+        if (padding_counter > 0U) {
+          return false;
+        }
+        digits[digit_counter++] = decoded;
+        if (digit_counter == 4U) {
+          base64_digits_to_bytes(digits, data + decoded_size);
+          decoded_size += 3U;
+          digit_counter = 0U;
+        }
+    }
+  }
+
+  if (padding_counter > 0U && padding_counter != 4U - digit_counter) {
+    return false;
+  }
+
+  switch (digit_counter) {
+    case 0:
+      break;
+    case 1:
+      return false;
+    case 2:
+      digits[2] = 0x00;
+    case 3: {
+      digits[3] = 0x00;
+
+      uint8_t bytes_temp[3];
+      base64_digits_to_bytes(digits, bytes_temp);
+      const size_t num_bytes = digit_counter - 1;
+      memcpy(data + decoded_size, bytes_temp, num_bytes);
+      decoded_size += num_bytes;
+      break;
+    }
+    default:
+      return false;
+  }
+
+  *data_length = decoded_size;
+  return true;
+}
+
+std::vector<uint8_t> StringUtils::from_base64(const char* base64, size_t base64_length) {
+  std::vector<uint8_t> decoded((base64_length / 4 + 1) * 3);
+  size_t data_length = decoded.size();
+  if (!from_base64(decoded.data(), &data_length, base64, base64_length)) {
+    throw std::invalid_argument("Base64 encoded string is malformatted");
+  }
+  decoded.resize(data_length);
+  return decoded;
+}
+
+size_t StringUtils::to_base64(char* base64, const uint8_t* data, size_t length, bool url, bool padded) {
+  if (length > (std::numeric_limits<size_t>::max)() * 3 / 4 - 3) {
+    throw std::length_error("Data is too large to be base64 encoded");
+  }
+
+  const char* enc_lut = url ? base64_url_enc_lut : base64_enc_lut;
+  size_t base64_length = 0U;
+  uint8_t bytes[3];
+  for (size_t i = 0U; i < length; i += 3U) {
+    const bool b1_present = i + 1 < length;
+    const bool b2_present = i + 2 < length;
+    bytes[0] = data[i];
+    bytes[1] = b1_present ? data[i + 1] : 0x00;
+    bytes[2] = b2_present ? data[i + 2] : 0x00;
+
+    base64[base64_length++] = enc_lut[(bytes[0] & 0xfc) >> 2];
+    base64[base64_length++] = enc_lut[(bytes[0] & 0x03) << 4 | (bytes[1] & 0xf0) >> 4];
+    if (b1_present) {
+      base64[base64_length++] = enc_lut[(bytes[1] & 0x0f) << 2 | (bytes[2] & 0xc0) >> 6];
+    } else if (padded) {
+      base64[base64_length++] = '=';
+    }
+    if (b2_present) {
+      base64[base64_length++] = enc_lut[bytes[2] & 0x3f];
+    } else if (padded) {
+      base64[base64_length++] = '=';
+    }
+  }
+
+  return base64_length;
+}
+
+std::string StringUtils::to_base64(const uint8_t* data, size_t length, bool url /*= false*/, bool padded /*= true*/) {
+  std::vector<char> buf((length / 3 + 1) * 4);
+  size_t base64_length = to_base64(buf.data(), data, length, url, padded);
+  return std::string(buf.data(), base64_length);
+}
+
 constexpr uint8_t StringUtils::SKIP;
 constexpr uint8_t StringUtils::hex_lut[128];
+constexpr const char StringUtils::base64_enc_lut[];
+constexpr const char StringUtils::base64_url_enc_lut[];
+constexpr uint8_t StringUtils::base64_dec_lut[128];
 
 } /* namespace utils */
 } /* namespace minifi */
diff --git a/libminifi/test/unit/StringUtilsTests.cpp b/libminifi/test/unit/StringUtilsTests.cpp
index d5149c3..30fac99 100644
--- a/libminifi/test/unit/StringUtilsTests.cpp
+++ b/libminifi/test/unit/StringUtilsTests.cpp
@@ -127,16 +127,16 @@
   REQUIRE("" == StringUtils::to_hex(""));
   REQUIRE("6f" == StringUtils::to_hex("o"));
   REQUIRE("666f6f626172" == StringUtils::to_hex("foobar"));
-  REQUIRE("000102030405060708090a0b0c0d0e0f" == StringUtils::to_hex({0x00, 0x01, 0x02, 0x03,
-                                                                     0x04, 0x05, 0x06, 0x07,
-                                                                     0x08, 0x09, 0x0a, 0x0b,
-                                                                     0x0c, 0x0d, 0x0e, 0x0f}));
+  REQUIRE("000102030405060708090a0b0c0d0e0f" == StringUtils::to_hex(std::vector<uint8_t>{0x00, 0x01, 0x02, 0x03,
+                                                                                         0x04, 0x05, 0x06, 0x07,
+                                                                                         0x08, 0x09, 0x0a, 0x0b,
+                                                                                         0x0c, 0x0d, 0x0e, 0x0f}));
   REQUIRE("6F" == StringUtils::to_hex("o", true /*uppercase*/));
   REQUIRE("666F6F626172" == StringUtils::to_hex("foobar", true /*uppercase*/));
-  REQUIRE("000102030405060708090A0B0C0D0E0F" == StringUtils::to_hex({0x00, 0x01, 0x02, 0x03,
-                                                                     0x04, 0x05, 0x06, 0x07,
-                                                                     0x08, 0x09, 0x0a, 0x0b,
-                                                                     0x0c, 0x0d, 0x0e, 0x0f}, true /*uppercase*/));
+  REQUIRE("000102030405060708090A0B0C0D0E0F" == StringUtils::to_hex(std::vector<uint8_t>{0x00, 0x01, 0x02, 0x03,
+                                                                                         0x04, 0x05, 0x06, 0x07,
+                                                                                         0x08, 0x09, 0x0a, 0x0b,
+                                                                                         0x0c, 0x0d, 0x0e, 0x0f}, true /*uppercase*/));
 }
 
 TEST_CASE("TestStringUtils::testHexDecode", "[test hex decode]") {
@@ -155,28 +155,133 @@
                        0x04, 0x05, 0x06, 0x07,
                        0x08, 0x09, 0x0a, 0x0b,
                        0x0c, 0x0d, 0x0e, 0x0f}) == StringUtils::from_hex("000102030405060708090A0B0C0D0E0F"));
-  try {
-    StringUtils::from_hex("666f6f62617");
-    abort();
-  } catch (std::exception& e) {
-    REQUIRE(std::string("Hexencoded string is malformatted") == e.what());
-  }
-  try {
-    StringUtils::from_hex("666f6f6261 7");
-    abort();
-  } catch (std::exception& e) {
-    REQUIRE(std::string("Hexencoded string is malformatted") == e.what());
-  }
+
+  REQUIRE_THROWS_WITH(StringUtils::from_hex("666f6f62617"), "Hexencoded string is malformatted");
+  REQUIRE_THROWS_WITH(StringUtils::from_hex("666f6f6261 7"), "Hexencoded string is malformatted");
 }
 
 TEST_CASE("TestStringUtils::testHexEncodeDecode", "[test hex encode decode]") {
   std::mt19937 gen(std::random_device { }());
-  const bool uppercase = gen() % 2;
-  const size_t length = gen() % 1024;
-  std::vector<uint8_t> data(length);
-  std::generate_n(data.begin(), data.size(), [&]() -> uint8_t {
-    return gen() % 256;
-  });
-  auto hex = utils::StringUtils::to_hex(data.data(), data.size(), uppercase);
-  REQUIRE(data == utils::StringUtils::from_hex(hex.data(), hex.size()));
+  for (size_t i = 0U; i < 1024U; i++) {
+    const bool uppercase = gen() % 2;
+    const size_t length = gen() % 1024;
+    std::vector<uint8_t> data(length);
+    std::generate_n(data.begin(), data.size(), [&]() -> uint8_t {
+      return gen() % 256;
+    });
+    auto hex = utils::StringUtils::to_hex(data.data(), data.size(), uppercase);
+    REQUIRE(data == utils::StringUtils::from_hex(hex.data(), hex.size()));
+  }
+}
+
+TEST_CASE("TestStringUtils::testBase64Encode", "[test base64 encode]") {
+  REQUIRE("" == StringUtils::to_base64(""));
+
+  REQUIRE("bw==" == StringUtils::to_base64("o"));
+  REQUIRE("b28=" == StringUtils::to_base64("oo"));
+  REQUIRE("b29v" == StringUtils::to_base64("ooo"));
+  REQUIRE("b29vbw==" == StringUtils::to_base64("oooo"));
+  REQUIRE("b29vb28=" == StringUtils::to_base64("ooooo"));
+  REQUIRE("b29vb29v" == StringUtils::to_base64("oooooo"));
+
+  REQUIRE("bw" == StringUtils::to_base64("o", false /*url*/, false /*padded*/));
+  REQUIRE("b28" == StringUtils::to_base64("oo", false /*url*/, false /*padded*/));
+  REQUIRE("b29v" == StringUtils::to_base64("ooo", false /*url*/, false /*padded*/));
+  REQUIRE("b29vbw" == StringUtils::to_base64("oooo", false /*url*/, false /*padded*/));
+  REQUIRE("b29vb28" == StringUtils::to_base64("ooooo", false /*url*/, false /*padded*/));
+  REQUIRE("b29vb29v" == StringUtils::to_base64("oooooo", false /*url*/, false /*padded*/));
+
+  REQUIRE("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ==
+    StringUtils::to_base64(std::vector<uint8_t>{0x00, 0x10, 0x83, 0x10,
+                                                0x51, 0x87, 0x20, 0x92,
+                                                0x8b, 0x30, 0xd3, 0x8f,
+                                                0x41, 0x14, 0x93, 0x51,
+                                                0x55, 0x97, 0x61, 0x96,
+                                                0x9b, 0x71, 0xd7, 0x9f,
+                                                0x82, 0x18, 0xa3, 0x92,
+                                                0x59, 0xa7, 0xa2, 0x9a,
+                                                0xab, 0xb2, 0xdb, 0xaf,
+                                                0xc3, 0x1c, 0xb3, 0xd3,
+                                                0x5d, 0xb7, 0xe3, 0x9e,
+                                                0xbb, 0xf3, 0xdf, 0xbf}));
+  REQUIRE("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" ==
+    StringUtils::to_base64(std::vector<uint8_t>{0x00, 0x10, 0x83, 0x10,
+                                                0x51, 0x87, 0x20, 0x92,
+                                                0x8b, 0x30, 0xd3, 0x8f,
+                                                0x41, 0x14, 0x93, 0x51,
+                                                0x55, 0x97, 0x61, 0x96,
+                                                0x9b, 0x71, 0xd7, 0x9f,
+                                                0x82, 0x18, 0xa3, 0x92,
+                                                0x59, 0xa7, 0xa2, 0x9a,
+                                                0xab, 0xb2, 0xdb, 0xaf,
+                                                0xc3, 0x1c, 0xb3, 0xd3,
+                                                0x5d, 0xb7, 0xe3, 0x9e,
+                                                0xbb, 0xf3, 0xdf, 0xbf}, true /*url*/));
+}
+
+TEST_CASE("TestStringUtils::testBase64Decode", "[test base64 decode]") {
+  REQUIRE("" == StringUtils::from_base64(""));
+  REQUIRE("o" == StringUtils::from_base64("bw=="));
+  REQUIRE("oo" == StringUtils::from_base64("b28="));
+  REQUIRE("ooo" == StringUtils::from_base64("b29v"));
+  REQUIRE("oooo" == StringUtils::from_base64("b29vbw=="));
+  REQUIRE("ooooo" == StringUtils::from_base64("b29vb28="));
+  REQUIRE("oooooo" == StringUtils::from_base64("b29vb29v"));
+  REQUIRE("\xfb\xff\xbf" == StringUtils::from_base64("-_-_"));
+  REQUIRE("\xfb\xff\xbf" == StringUtils::from_base64("+/+/"));
+  REQUIRE(std::string({   0,   16, -125,   16,
+                         81, -121,   32, -110,
+                       -117,   48,  -45, -113,
+                         65,   20, -109,   81,
+                         85, -105,   97, -106,
+                       -101,  113,  -41,  -97,
+                       -126,   24,  -93, -110,
+                         89,  -89,  -94, -102,
+                        -85,  -78,  -37,  -81,
+                        -61,   28,  -77,  -45,
+                         93,  -73,  -29,  -98,
+                        -69,  -13,  -33,  -65}) == StringUtils::from_base64("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"));
+  REQUIRE(std::string({   0,   16, -125,   16,
+                         81, -121,   32, -110,
+                       -117,   48,  -45, -113,
+                         65,   20, -109,   81,
+                         85, -105,   97, -106,
+                       -101,  113,  -41,  -97,
+                       -126,   24,  -93, -110,
+                         89,  -89,  -94, -102,
+                        -85,  -78,  -37,  -81,
+                        -61,   28,  -77,  -45,
+                         93,  -73,  -29,  -98,
+                        -69,  -13,  -33,  -65}) == StringUtils::from_base64("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"));
+
+  REQUIRE("foobarbuzz" == StringUtils::from_base64("Zm9vYmFyYnV6eg=="));
+  REQUIRE("foobarbuzz"== StringUtils::from_base64("\r\nZm9vYmFyYnV6eg=="));
+  REQUIRE("foobarbuzz" == StringUtils::from_base64("Zm9\r\nvYmFyYnV6eg=="));
+  REQUIRE("foobarbuzz" == StringUtils::from_base64("Zm\r9vYmFy\n\n\n\n\n\n\n\nYnV6eg=="));
+  REQUIRE("foobarbuzz" == StringUtils::from_base64("\nZ\nm\n9\nv\nY\nm\nF\ny\nY\nn\nV\n6\ne\ng\n=\n=\n"));
+
+  REQUIRE_THROWS_WITH(StringUtils::from_base64("a"), "Base64 encoded string is malformatted");
+  REQUIRE_THROWS_WITH(StringUtils::from_base64("aaaaa"), "Base64 encoded string is malformatted");
+  REQUIRE_THROWS_WITH(StringUtils::from_base64("aa="), "Base64 encoded string is malformatted");
+  REQUIRE_THROWS_WITH(StringUtils::from_base64("aaaaaa="), "Base64 encoded string is malformatted");
+  REQUIRE_THROWS_WITH(StringUtils::from_base64("aa==?"), "Base64 encoded string is malformatted");
+  REQUIRE_THROWS_WITH(StringUtils::from_base64("aa==a"), "Base64 encoded string is malformatted");
+  REQUIRE_THROWS_WITH(StringUtils::from_base64("aa==="), "Base64 encoded string is malformatted");
+  REQUIRE_THROWS_WITH(StringUtils::from_base64("?"), "Base64 encoded string is malformatted");
+  REQUIRE_THROWS_WITH(StringUtils::from_base64("aaaa?"), "Base64 encoded string is malformatted");
+}
+
+TEST_CASE("TestStringUtils::testBase64EncodeDecode", "[test base64 encode decode]") {
+  std::mt19937 gen(std::random_device { }());
+  for (size_t i = 0U; i < 1024U; i++) {
+    const bool url = gen() % 2;
+    const bool padded = gen() % 2;
+    const size_t length = gen() % 1024;
+    std::vector<uint8_t> data(length);
+    std::generate_n(data.begin(), data.size(), [&]() -> uint8_t {
+      return gen() % 256;
+    });
+    auto base64 = utils::StringUtils::to_base64(data.data(), data.size(), url, padded);
+    REQUIRE(data == utils::StringUtils::from_base64(base64.data(), base64.size()));
+  }
 }