diff --git a/modp_b64.cc b/modp_b64.cc
index fdb8a40..2901a8f 100644
--- a/modp_b64.cc
+++ b/modp_b64.cc
@@ -45,39 +45,11 @@
 /* public header */
 #include "modp_b64.h"
 
-/*
- * If you are ripping this out of the library, comment out the next
- * line and uncomment the next lines as approrpiate
- */
-//#include "config.h"
-
-/* if on motoral, sun, ibm; uncomment this */
-/* #define WORDS_BIGENDIAN 1 */
-/* else for Intel, Amd; uncomment this */
-/* #undef WORDS_BIGENDIAN */
-
 #include "modp_b64_data.h"
 
 #define BADCHAR 0x01FFFFFF
 
-/**
- * you can control if we use padding by commenting out this
- * next line.  However, I highly recommend you use padding and not
- * using it should only be for compatability with a 3rd party.
- * Also, 'no padding' is not tested!
- */
-#define DOPAD 1
-
-/*
- * if we aren't doing padding
- * set the pad character to NULL
- */
-#ifndef DOPAD
-#undef CHARPAD
-#define CHARPAD '\0'
-#endif
-
-size_t modp_b64_encode(char* dest, const char* str, size_t len)
+size_t modp_b64_encode_data(char* dest, const char* str, size_t len)
 {
     size_t i = 0;
     uint8_t* p = (uint8_t*) dest;
@@ -113,97 +85,42 @@
         *p++ = CHARPAD;
     }
 
-    *p = '\0';
     return p - (uint8_t*)dest;
 }
 
-#ifdef WORDS_BIGENDIAN   /* BIG ENDIAN -- SUN / IBM / MOTOROLA */
-int modp_b64_decode(char* dest, const char* src, int len)
-{
-    if (len == 0) return 0;
-
-#ifdef DOPAD
-    /* if padding is used, then the message must be at least
-       4 chars and be a multiple of 4.
-       there can be at most 2 pad chars at the end */
-    if (len < 4 || (len % 4 != 0)) return MODP_B64_ERROR;
-    if (src[len-1] == CHARPAD) {
-        len--;
-        if (src[len -1] == CHARPAD) {
-            len--;
-        }
-    }
-#endif  /* DOPAD */
-
-    size_t i;
-    int leftover = len % 4;
-    size_t chunks = (leftover == 0) ? len / 4 - 1 : len /4;
-
-    uint8_t* p = (uint8_t*) dest;
-    uint32_t x = 0;
-    uint32_t* destInt = (uint32_t*) p;
-    uint32_t* srcInt = (uint32_t*) src;
-    uint32_t y = *srcInt++;
-    for (i = 0; i < chunks; ++i) {
-        x = d0[y >> 24 & 0xff] | d1[y >> 16 & 0xff] |
-            d2[y >> 8 & 0xff] | d3[y & 0xff];
-
-        if (x >= BADCHAR)  return MODP_B64_ERROR;
-        *destInt = x << 8;
-        p += 3;
-        destInt = (uint32_t*)p;
-        y = *srcInt++;
-    }
-
-    switch (leftover) {
-    case 0:
-        x = d0[y >> 24 & 0xff] | d1[y >> 16 & 0xff] |
-            d2[y >>  8 & 0xff] | d3[y & 0xff];
-        if (x >= BADCHAR)  return MODP_B64_ERROR;
-        *p++ = ((uint8_t*)&x)[1];
-        *p++ = ((uint8_t*)&x)[2];
-        *p = ((uint8_t*)&x)[3];
-        return (chunks+1)*3;
-    case 1:
-        x = d3[y >> 24];
-        *p =  (uint8_t)x;
-        break;
-    case 2:
-        x = d3[y >> 24] *64 + d3[(y >> 16) & 0xff];
-        *p =  (uint8_t)(x >> 4);
-        break;
-    default:  /* case 3 */
-        x = (d3[y >> 24] *64 + d3[(y >> 16) & 0xff])*64 +
-            d3[(y >> 8) & 0xff];
-        *p++ = (uint8_t) (x >> 10);
-        *p = (uint8_t) (x >> 2);
-        break;
-    }
-
-    if (x >= BADCHAR) return MODP_B64_ERROR;
-    return 3*chunks + (6*leftover)/8;
+size_t modp_b64_encode(char* dest, const char* str, size_t len) {
+  size_t output_size = modp_b64_encode_data(dest, str, len);
+  dest[output_size] = '\0';
+  return output_size;
 }
 
-#else /* LITTLE  ENDIAN -- INTEL AND FRIENDS */
-
-size_t modp_b64_decode(char* dest, const char* src, size_t len)
-{
-    if (len == 0) return 0;
-
-#ifdef DOPAD
-    /*
-     * if padding is used, then the message must be at least
-     * 4 chars and be a multiple of 4
-     */
-    if (len < 4 || (len % 4 != 0)) return MODP_B64_ERROR; /* error */
-    /* there can be at most 2 pad chars at the end */
-    if (src[len-1] == CHARPAD) {
+size_t do_decode_padding(const char* src, size_t len, ModpDecodePolicy policy) {
+  if (policy == ModpDecodePolicy::kNoPaddingValidation) {
+    while (len > 0 && src[len - 1] == CHARPAD) {
         len--;
-        if (src[len -1] == CHARPAD) {
-            len--;
-        }
     }
-#endif
+  } else {
+    const size_t remainder = len % 4;
+    if (policy == ModpDecodePolicy::kStrict && (remainder != 0 || len < 4))
+      return MODP_B64_ERROR;
+    if (remainder == 0) {
+      if (src[len - 1] == CHARPAD) {
+        len--;
+        if (src[len - 1] == CHARPAD) {
+          len--;
+        }
+      }
+    }
+  }
+  return len % 4 == 1 ? MODP_B64_ERROR : len;
+}
+
+size_t modp_b64_decode(char* dest, const char* src, size_t len, ModpDecodePolicy policy)
+{
+    if (len == 0 ||
+        (len = do_decode_padding(src, len, policy)) == MODP_B64_ERROR) {
+      return len;
+    }
 
     size_t i;
     int leftover = len % 4;
@@ -229,7 +146,6 @@
         *p++ =  ((uint8_t*)(&x))[1];
         *p =    ((uint8_t*)(&x))[2];
         return (chunks+1)*3;
-        break;
     case 1:  /* with padding this is an impossible case */
         x = d0[y[0]];
         *p = *((uint8_t*)(&x)); // i.e. first char/byte in int
@@ -249,5 +165,3 @@
 
     return 3*chunks + (6*leftover)/8;
 }
-
-#endif  /* if bigendian / else / endif */
diff --git a/modp_b64/modp_b64.h b/modp_b64/modp_b64.h
index 0a2669d..9d11f81 100644
--- a/modp_b64/modp_b64.h
+++ b/modp_b64/modp_b64.h
@@ -37,17 +37,16 @@
  * len contains the number of bytes in the src
  * dest should be allocated by the caller to contain
  *   at least modp_b64_encode_len(len) bytes (see below)
- *   This will contain the null-terminated b64 encoded result
- * returns length of the destination string plus the ending null byte
- *    i.e.  the result will be equal to strlen(dest) + 1
+ *   This will contain the (non-null terminated) b64 bytes.
+ * returns length of the destination string.
  *
  * Example
- * 
+ *
  * \code
  * char* src = ...;
  * int srclen = ...; //the length of number of bytes in src
  * char* dest = (char*) malloc(modp_b64_encode_len);
- * int len = modp_b64_encode(dest, src, sourcelen);
+ * int len = modp_b64_encode_data(dest, src, sourcelen);
  * if (len == -1) {
  *   printf("Error\n");
  * } else {
@@ -56,6 +55,17 @@
  * \endcode
  *
  */
+size_t modp_b64_encode_data(char* dest, const char* str, size_t len);
+
+/**
+ * Same as modp_b64_encode_data, but additionally sets a null terminator at the
+ * end of `dest` (i.e. at dest[output_size]).
+ * Like modp_b64_encode_data, returns the length of the destination string (i.e.
+ * not counting the null terminator).
+ *
+ * TODO(csharrison): Consider removing this once all callers migrate to
+ * modp_b64_encode_data.
+ */
 size_t modp_b64_encode(char* dest, const char* str, size_t len);
 
 /**
@@ -79,11 +89,27 @@
  * if (len == -1) { error }
  * \endcode
  */
-size_t modp_b64_decode(char* dest, const char* src, size_t len);
+enum class ModpDecodePolicy {
+  // src length must be divisible by 4, with a max of 2 pad chars.
+  kStrict,
+
+  // Matches the infra spec: https://infra.spec.whatwg.org/#forgiving-base64
+  // _except_ for ignoring whitespace (Step 1).
+  kForgiving,
+
+  // src length % 4 must not equal 1, after stripping all pad chars.
+  // Accepts any number of pad chars.
+  kNoPaddingValidation,
+};
+size_t modp_b64_decode(
+    char* dest,
+    const char* src,
+    size_t len,
+    ModpDecodePolicy policy = ModpDecodePolicy::kStrict);
 
 /**
- * The maximum input that can be passed into modp_b64_encode. Lengths beyond
- * this will overflow modp_b64_encode_len.
+ * The maximum input that can be passed into modp_b64_encode{_data}.
+ * Lengths beyond this will overflow modp_b64_encode_len.
  *
  * This works because modp_b64_encode_len(A) computes:
  *     ceiling[max_len / 3] * 4 + 1
@@ -91,23 +117,27 @@
  *   = floor[(SIZE_MAX-1)/4] * 4 + 1
  *  <= SIZE_MAX-1 + 1
  *   = SIZE_MAX
+ *
+ * Note: technically modp_b64_encode_data can take one extra byte, but for
+ * simplicity the bound is shared between the two functions.
  */
 #define MODP_B64_MAX_INPUT_LEN ((SIZE_MAX - 1) / 4 * 3)
 
 /**
  * Given a source string of length len, this returns the amount of
- * memory the destination string should have.
+ * memory the destination string should have, for modp_b64_encode_data and
+ * modp_b64_encode, respectively.
  *
  * remember, this is integer math
  * 3 bytes turn into 4 chars
- * ceiling[len / 3] * 4 + 1
+ * ceiling[len / 3] * 4
  *
- * +1 is for any extra null.
  *
- * WARNING: This expression will overflow if the A is above
+ * WARNING: These expressions will overflow if the A is above
  * MODP_B64_MAX_INPUT_LEN. The caller must check this bound first.
  */
-#define modp_b64_encode_len(A) ((A+2)/3 * 4 + 1)
+#define modp_b64_encode_data_len(A) ((A + 2) / 3 * 4)
+#define modp_b64_encode_len(A) (modp_b64_encode_data_len(A) + 1)
 
 /**
  * Given a base64 string of length len,
@@ -120,69 +150,10 @@
  */
 #define modp_b64_decode_len(A) (A / 4 * 3 + 2)
 
-/**
- * Will return the strlen of the output from encoding.
- * This may be less than the required number of bytes allocated.
- *
- * This allows you to 'deserialized' a struct
- * \code
- * char* b64encoded = "...";
- * int len = strlen(b64encoded);
- *
- * struct datastuff foo;
- * if (modp_b64_encode_strlen(sizeof(struct datastuff)) != len) {
- *    // wrong size
- *    return false;
- * } else {
- *    // safe to do;
- *    if (modp_b64_decode((char*) &foo, b64encoded, len) == -1) {
- *      // bad characters
- *      return false;
- *    }
- * }
- * // foo is filled out now
- * \endcode
- */
-#define modp_b64_encode_strlen(A) ((A + 2)/ 3 * 4)
-
 #define MODP_B64_ERROR ((size_t)-1)
 
 #ifdef __cplusplus
 }
-
-#include <string>
-
-inline std::string& modp_b64_encode(std::string& s)
-{
-    std::string x(modp_b64_encode_len(s.size()), '\0');
-    size_t d = modp_b64_encode(const_cast<char*>(x.data()), s.data(), (int)s.size());
-    x.erase(d, std::string::npos);
-    s.swap(x);
-    return s;
-}
-
-/**
- * base 64 decode a string (self-modifing)
- * On failure, the string is empty.
- *
- * This function is for C++ only (duh)
- *
- * \param[in,out] s the string to be decoded
- * \return a reference to the input string
- */
-inline std::string& modp_b64_decode(std::string& s)
-{
-    std::string x(modp_b64_decode_len(s.size()), '\0');
-    size_t d = modp_b64_decode(const_cast<char*>(x.data()), s.data(), (int)s.size());
-    if (d == MODP_B64_ERROR) {
-        x.clear();
-    } else {
-        x.erase(d, std::string::npos);
-    }
-    s.swap(x);
-    return s;
-}
-
 #endif /* __cplusplus */
 
 #endif /* MODP_B64 */