How to fix Error: Invalid base64 padding in Node.js

Input bytes → Output chars → Padding
1 byte (8 bits) → 2 chars → 2 equals (==)
2 bytes (16 bits) → 3 chars → 1 equals (=)  [Note: 1 padding is valid for output]
3 bytes (24 bits) → 4 chars → 0 equals

const valid1 = "dGVzdA==";    // 6 chars with 2 padding - valid
const valid2 = "dGVzd===";    // 8 chars with 3 padding - valid
const valid3 = "dGVzd";       // 5 chars with 0 padding - valid (lenient decoders)
const invalid = "dGVzd=";     // 6 chars with 1 padding - INVALID

function validateBase64(str) {
  // Check if string has invalid padding (1 equals sign)
  const paddingMatch = str.match(/=+$/);
  const paddingCount = paddingMatch ? paddingMatch[0].length : 0;

  if (paddingCount === 1) {
    console.error("Invalid base64 padding: has 1 equals sign");
    return false;
  }

  // Check if length is multiple of 4 (after padding)
  if ((str.length + paddingCount) % 4 !== 0) {
    console.error("Invalid base64 length: not a multiple of 4");
    return false;
  }

  return true;
}

const base64String = "dGVzd=";  // Invalid
if (validateBase64(base64String)) {
  const buffer = Buffer.from(base64String, "base64");
  console.log(buffer);
} else {
  console.error("Base64 string has invalid padding");
}

function fixBase64Padding(str) {
  // Remove all trailing equals signs
  let cleaned = str.replace(/=+$/, "");

  // Add correct padding based on string length
  const padding = (4 - (cleaned.length % 4)) % 4;
  return cleaned + "=".repeat(padding);
}

// Examples
console.log(fixBase64Padding("dGVzd="));      // "dGVzd===" -> may be over-padded
console.log(fixBase64Padding("dGVz"));        // "dGVz=" (adds 1) or "dGVz==" depending on content

// Better approach: don't add padding if it's optional
const str = "dGVzd=";
const cleaned = str.replace(/=+$/, "");
const buffer = Buffer.from(cleaned, "base64");
console.log(buffer.toString("utf-8")); // Works with modern Node.js

function decodeBase64Url(str) {
  // Replace base64url characters with standard base64
  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");

  // Add padding if needed
  const padding = (4 - (base64.length % 4)) % 4;
  base64 += "=".repeat(padding);

  return Buffer.from(base64, "base64").toString("utf-8");
}

// JWT header example (typically base64url)
const jwtHeader = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9";
console.log(decodeBase64Url(jwtHeader));
// Output: {"alg":"HS256","typ":"JWT"}

function safeBase64Decode(str) {
  // Trim whitespace
  str = str.trim();

  // Check for invalid characters
  if (!/^[A-Za-z0-9+/]*={0,3}$/.test(str)) {
    throw new Error("Base64 string contains invalid characters");
  }

  // Check padding
  const paddingCount = (str.match(/=/g) || []).length;
  if (paddingCount === 1) {
    throw new Error("Base64 has invalid padding (1 equals sign)");
  }

  // Validate total length
  if ((str.length) % 4 !== 0) {
    throw new Error("Base64 length must be multiple of 4");
  }

  try {
    return Buffer.from(str, "base64");
  } catch (e) {
    throw new Error("Failed to decode base64: " + e.message);
  }
}

// Usage
try {
  const buffer = safeBase64Decode("dGVzdA==");
  console.log("Decoded:", buffer.toString("utf-8"));
} catch (err) {
  console.error("Invalid base64:", err.message);
}

// For lenient decoding, you can remove padding entirely
function lenientBase64Decode(str) {
  // Remove all padding
  const cleaned = str.replace(/=+$/, "");

  // Modern Node.js handles this fine
  try {
    return Buffer.from(cleaned, "base64").toString("utf-8");
  } catch (e) {
    // Fallback: add proper padding
    const padded = cleaned + "=".repeat((4 - cleaned.length % 4) % 4);
    return Buffer.from(padded, "base64").toString("utf-8");
  }
}

// For JSON Web Tokens, use libraries
const jwt = require("jsonwebtoken");
const decoded = jwt.decode(token); // Handles base64url automatically

// For general base64 with various padding, handle both styles
function flexBase64Decode(str) {
  try {
    return Buffer.from(str, "base64");
  } catch (e) {
    // Try with padding fixed
    const padded = str + "=".repeat((4 - str.length % 4) % 4);
    return Buffer.from(padded, "base64");
  }
}