Base32 and Base58 Encoding: Complete Guide with Examples

Common Base32 Applications:

1. TOTP/2FA Secrets
   - Google Authenticator shared secrets
   - RFC 6238 Time-based One-Time Password

2. File Systems
   - Git object names
   - Tahoe-LAFS distributed storage

3. DNS and Networking
   - DNS labels (extended hex format)
   - mDNS service discovery

4. Data Encoding
   - Geohashing (location encoding)
   - Human-readable identifiers

Base32 Encoding Process:

1. Convert input bytes to binary
2. Group binary into 5-bit chunks (instead of 6-bit for Base64)
3. Pad with zeros if needed to complete 5-bit groups
4. Convert each 5-bit value to decimal (0-31)
5. Map to Base32 alphabet (A-Z, 2-7)
6. Add padding '=' to make length multiple of 8

Input: "Hello"
ASCII: H=72, e=101, l=108, l=108, o=111

Binary: 01001000 01100101 01101100 01101100 01101111

Group into 5-bit chunks:
01001 | 00001 | 10010 | 10110 | 11000 | 11011 | 00011 | 01111

Convert to decimal:
9 | 1 | 18 | 22 | 24 | 27 | 3 | 15

Map to Base32 (A=0, B=1, ..., Z=25, 2=26, 3=27, ..., 7=31):
J | B | S | W | Y | 3 | D | P

Result: "JBSWY3DP" (no padding needed for 40 bits)

Input: "Hi" (2 bytes = 16 bits)
Binary: 01001000 01101001

Grouped (5-bit): 01001 | 00001 | 10100 | 1 (need padding)
Padded to 5 bits:  01001 | 00001 | 10100 | 10000

Decimal: 9 | 1 | 20 | 16
Base32:  J | B | U | Q

Need to pad to 8 characters:
Result: "JBUQ===="

Padding rules:
- 2 bytes (16 bits) → 4 chars + 4 padding = 8 chars
- 3 bytes (24 bits) → 5 chars + 3 padding = 8 chars
- 4 bytes (32 bits) → 7 chars + 1 padding = 8 chars
- 5 bytes (40 bits) → 8 chars (no padding)

Base58 Alphabet (Bitcoin):
123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz

Breakdown:
- Numbers: 1-9 (excludes 0)
- Uppercase: A-Z (excludes I and O)
- Lowercase: a-z (excludes l)

Total: 9 + 24 + 23 = 58 characters

Note: Different Base58 variants exist:
- Bitcoin: Uses the alphabet shown above
- Flickr: Different alphabet ordering
- Ripple: Custom alphabet for XRP

Bitcoin Address Example:

Raw public key hash (hex):
00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31

With checksum:
00f54a5851e9372b87810a8e60cdd2e7cfd80b6e31c7f18fe8

Base58 encoded:
1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs

Why Base58?
- No confusion: 0/O, I/l/1 excluded
- Shorter than Base32 or hex
- Double-click selects entire address
- No special characters (+, /)

Feature              | Base32        | Base58        | Base64
---------------------|---------------|---------------|---------------
Character count      | 32            | 58            | 64
Case sensitive       | No            | Yes           | Yes
Ambiguous chars      | None          | None          | 0/O, I/l
Size overhead        | ~60%          | ~37%          | ~33%
Human readable       | High          | Medium        | Low
URL safe             | Yes*          | Yes           | No**
Use case             | TOTP, DNS     | Crypto        | General

* Base32 padding '=' may need URL encoding
** Base64 has +/ which need URL encoding

// Using hi-base32 library
const base32 = require('hi-base32');

// Encoding
const text = "Hello, World!";
const encoded = base32.encode(text);
console.log(encoded); // JBSWY3DPEBLW64TMMQQQ====

// Decoding
const decoded = base32.decode(encoded);
console.log(decoded); // Hello, World!

// Without padding
const encodedNoPad = base32.encode(text).replace(/=/g, '');
console.log(encodedNoPad); // JBSWY3DPEBLW64TMMQQQ

// Case insensitive decoding
const lowercase = encoded.toLowerCase();
const decodedLower = base32.decode(lowercase);
console.log(decodedLower); // Hello, World!

// Encode binary data
const buffer = Buffer.from([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
const encodedBinary = base32.encode(buffer);
console.log(encodedBinary); // JBSWY3DP

import base64

# Encoding
text = "Hello, World!"
encoded = base64.b32encode(text.encode('utf-8'))
print(encoded)  # b'JBSWY3DPEBLW64TMMQQQ===='

# Decoding
decoded = base64.b32decode(encoded).decode('utf-8')
print(decoded)  # Hello, World!

# RFC 4648 Base32 (standard)
encoded_std = base64.b32encode(b'Hello')
print(encoded_std)  # b'JBSWY3DP'

# Extended Hex Base32 (used in some applications)
encoded_hex = base64.b32hexencode(b'Hello')
print(encoded_hex)  # b'91IMOR3F'

# Case insensitive decoding
lowercase = b'jbswy3dpeblw64tmmqqq===='
decoded_lower = base64.b32decode(lowercase, casefold=True)
print(decoded_lower.decode('utf-8'))  # Hello, World!

<?php
// Using Christian Riesen's Base32 library
require 'vendor/autoload.php';
use Base32\Base32;

// Encoding
$text = "Hello, World!";
$encoded = Base32::encode($text);
echo $encoded; // JBSWY3DPEBLW64TMMQQQ====

// Decoding
$decoded = Base32::decode($encoded);
echo $decoded; // Hello, World!

// Without padding
$encodedNoPad = rtrim($encoded, '=');
echo $encodedNoPad; // JBSWY3DPEBLW64TMMQQQ

// Case insensitive
$lowercase = strtolower($encoded);
$decodedLower = Base32::decode($lowercase);
echo $decodedLower; // Hello, World!

// Generate TOTP secret
$secret = Base32::encode(random_bytes(20));
echo $secret; // Random 32-character Base32 string
?>

# Using base32 command (GNU coreutils)
echo -n "Hello, World!" | base32
# Output: JBSWY3DPEBLW64TMMQQQ====

# Decode
echo "JBSWY3DPEBLW64TMMQQQ====" | base32 -d
# Output: Hello, World!

# Encode file
base32 input.txt > output.b32

# Decode file
base32 -d input.b32 > output.txt

# Without line wrapping
echo -n "Hello" | base32 -w 0
# Output: JBSWY3DP

# Using Python from command line
python3 -c "import base64; print(base64.b32encode(b'Hello').decode())"
# Output: JBSWY3DP

// Using bs58 library (Bitcoin Base58)
const bs58 = require('bs58');

// Encoding
const text = "Hello, World!";
const buffer = Buffer.from(text, 'utf8');
const encoded = bs58.encode(buffer);
console.log(encoded); // 2NEpo7TZRhna7vSvL

// Decoding
const decoded = bs58.decode(encoded);
console.log(decoded.toString('utf8')); // Hello, World!

// Encode hex string
const hex = 'deadbeef';
const hexBuffer = Buffer.from(hex, 'hex');
const encodedHex = bs58.encode(hexBuffer);
console.log(encodedHex); // 6h8cQN

// Bitcoin address encoding (with checksum)
const crypto = require('crypto');

function encodeBase58Check(payload) {
  const checksum = crypto
    .createHash('sha256')
    .update(crypto.createHash('sha256').update(payload).digest())
    .digest()
    .slice(0, 4);

  return bs58.encode(Buffer.concat([payload, checksum]));
}

// Example: Encode with version byte
const hash160 = Buffer.from('f54a5851e9372b87810a8e60cdd2e7cfd80b6e31', 'hex');
const version = Buffer.from([0x00]); // Bitcoin mainnet
const address = encodeBase58Check(Buffer.concat([version, hash160]));
console.log(address); // 1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs

import base58
import hashlib

# Simple encoding
text = "Hello, World!"
encoded = base58.b58encode(text.encode('utf-8'))
print(encoded)  # b'2NEpo7TZRhna7vSvL'

# Decoding
decoded = base58.b58decode(encoded)
print(decoded.decode('utf-8'))  # Hello, World!

# Encode bytes
data = bytes([0xde, 0xad, 0xbe, 0xef])
encoded_bytes = base58.b58encode(data)
print(encoded_bytes)  # b'6h8cQN'

# Base58Check (with checksum) - Bitcoin addresses
def base58check_encode(payload):
    """Encode payload with Base58Check (double SHA-256 checksum)"""
    checksum = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:4]
    return base58.b58encode(payload + checksum)

def base58check_decode(encoded):
    """Decode Base58Check and verify checksum"""
    decoded = base58.b58decode(encoded)
    payload, checksum = decoded[:-4], decoded[-4:]
    verify = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:4]
    if checksum != verify:
        raise ValueError("Invalid checksum")
    return payload

# Bitcoin address example
version = b'\x00'  # Mainnet P2PKH
hash160 = bytes.fromhex('f54a5851e9372b87810a8e60cdd2e7cfd80b6e31')
address = base58check_encode(version + hash160)
print(address.decode())  # 1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs

package main

import (
    "fmt"
    "github.com/btcsuite/btcutil/base58"
)

func main() {
    // Encoding
    text := "Hello, World!"
    encoded := base58.Encode([]byte(text))
    fmt.Println(encoded) // 2NEpo7TZRhna7vSvL

    // Decoding
    decoded := base58.Decode(encoded)
    fmt.Println(string(decoded)) // Hello, World!

    // Base58Check encoding
    data := []byte{0xf5, 0x4a, 0x58, 0x51, 0xe9, 0x37, 0x2b, 0x87}
    checkEncoded := base58.CheckEncode(data, 0x00)
    fmt.Println(checkEncoded)

    // Base58Check decoding
    decodedData, version, err := base58.CheckDecode(checkEncoded)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Version: %d, Data: %x\n", version, decodedData)
}

use bs58;

fn main() {
    // Encoding
    let text = "Hello, World!";
    let encoded = bs58::encode(text).into_string();
    println!("{}", encoded); // 2NEpo7TZRhna7vSvL

    // Decoding
    let decoded = bs58::decode(&encoded).into_vec().unwrap();
    let text = String::from_utf8(decoded).unwrap();
    println!("{}", text); // Hello, World!

    // Encode bytes
    let bytes = vec![0xde, 0xad, 0xbe, 0xef];
    let encoded_bytes = bs58::encode(&bytes).into_string();
    println!("{}", encoded_bytes); // 6h8cQN

    // Decode with error handling
    match bs58::decode("invalid!@#").into_vec() {
        Ok(data) => println!("Decoded: {:?}", data),
        Err(e) => println!("Decode error: {}", e),
    }

    // With custom alphabet (Bitcoin)
    let custom_encoded = bs58::encode(text)
        .with_alphabet(bs58::Alphabet::BITCOIN)
        .into_string();
    println!("{}", custom_encoded);
}

const base32 = require('hi-base32');
const crypto = require('crypto');

// Generate random secret for TOTP
function generateTOTPSecret() {
  const randomBytes = crypto.randomBytes(20); // 160 bits
  const secret = base32.encode(randomBytes).replace(/=/g, '');
  return secret;
}

const secret = generateTOTPSecret();
console.log('Secret:', secret);
// Output: JBSWY3DPEHPK3PXP

// Create otpauth URL for QR code
function createOTPAuthURL(secret, issuer, accountName) {
  return `otpauth://totp/${issuer}:${accountName}?secret=${secret}&issuer=${issuer}`;
}

const url = createOTPAuthURL(secret, 'MyApp', '[email protected]');
console.log('QR URL:', url);
// otpauth://totp/MyApp:[email protected]?secret=JBSWY3DPEHPK3PXP&issuer=MyApp

// Verify TOTP code
function verifyTOTP(secret, token) {
  const time = Math.floor(Date.now() / 1000 / 30);
  const key = base32.decode(secret);
  const hmac = crypto.createHmac('sha1', key);
  hmac.update(Buffer.alloc(8));
  // ... TOTP algorithm implementation
}

const bs58 = require('bs58');
const crypto = require('crypto');

// Bitcoin address generation with Base58Check
function generateBitcoinAddress(publicKeyHash) {
  // 1. Add version byte (0x00 for mainnet P2PKH)
  const version = Buffer.from([0x00]);
  const payload = Buffer.concat([version, publicKeyHash]);

  // 2. Calculate checksum (double SHA-256)
  const hash1 = crypto.createHash('sha256').update(payload).digest();
  const hash2 = crypto.createHash('sha256').update(hash1).digest();
  const checksum = hash2.slice(0, 4);

  // 3. Concatenate payload + checksum
  const addressBytes = Buffer.concat([payload, checksum]);

  // 4. Encode with Base58
  const address = bs58.encode(addressBytes);

  return address;
}

// Example
const pubKeyHash = Buffer.from(
  'f54a5851e9372b87810a8e60cdd2e7cfd80b6e31',
  'hex'
);

const address = generateBitcoinAddress(pubKeyHash);
console.log('Bitcoin Address:', address);
// 1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs

// Validate Bitcoin address
function validateBitcoinAddress(address) {
  try {
    const decoded = bs58.decode(address);
    const payload = decoded.slice(0, -4);
    const checksum = decoded.slice(-4);

    const hash1 = crypto.createHash('sha256').update(payload).digest();
    const hash2 = crypto.createHash('sha256').update(hash1).digest();
    const expectedChecksum = hash2.slice(0, 4);

    return checksum.equals(expectedChecksum);
  } catch (e) {
    return false;
  }
}

console.log('Valid:', validateBitcoinAddress(address)); // true

const bs58 = require('bs58');
const { CID } = require('multiformats/cid');

// IPFS uses Base58 for Content IDs (v0)
// Example IPFS hash
const ipfsHash = 'QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o';

// Decode IPFS CID
const decoded = bs58.decode(ipfsHash);
console.log('Decoded bytes:', decoded.length); // 34 bytes

// Structure of CID v0:
// [0x12, 0x20, ...SHA-256 hash...]
// 0x12 = SHA-256 hash function
// 0x20 = 32 bytes length

// Extract hash
const hashFunction = decoded[0]; // 0x12
const hashLength = decoded[1];   // 0x20 (32 bytes)
const hash = decoded.slice(2);

console.log('Hash function:', hashFunction.toString(16));
console.log('Hash length:', hashLength);
console.log('Hash:', hash.toString('hex'));

// Create IPFS CID from hash
function createIPFSCID(sha256Hash) {
  const multihash = Buffer.concat([
    Buffer.from([0x12, 0x20]), // SHA-256, 32 bytes
    sha256Hash
  ]);
  return bs58.encode(multihash);
}

// Example: Hash of "Hello, IPFS!"
const crypto = require('crypto');
const content = "Hello, IPFS!";
const contentHash = crypto.createHash('sha256').update(content).digest();
const cid = createIPFSCID(contentHash);
console.log('IPFS CID:', cid);

// Geohashing uses Base32 to encode latitude/longitude
const base32Chars = '0123456789bcdefghjkmnpqrstuvwxyz';

function encodeGeohash(latitude, longitude, precision = 9) {
  let idx = 0;
  let bit = 0;
  let evenBit = true;
  let geohash = '';

  let latMin = -90, latMax = 90;
  let lonMin = -180, lonMax = 180;

  while (geohash.length < precision) {
    if (evenBit) {
      // Longitude
      const lonMid = (lonMin + lonMax) / 2;
      if (longitude > lonMid) {
        idx = (idx << 1) + 1;
        lonMin = lonMid;
      } else {
        idx = idx << 1;
        lonMax = lonMid;
      }
    } else {
      // Latitude
      const latMid = (latMin + latMax) / 2;
      if (latitude > latMid) {
        idx = (idx << 1) + 1;
        latMin = latMid;
      } else {
        idx = idx << 1;
        latMax = latMid;
      }
    }
    evenBit = !evenBit;

    if (++bit === 5) {
      geohash += base32Chars[idx];
      bit = 0;
      idx = 0;
    }
  }

  return geohash;
}

// Example: Statue of Liberty coordinates
const lat = 40.6892;
const lon = -74.0445;
const geohash = encodeGeohash(lat, lon, 9);
console.log('Geohash:', geohash); // dr5regw3p

// Nearby locations share prefixes
console.log('Precision 5:', encodeGeohash(lat, lon, 5)); // dr5re
console.log('Precision 3:', encodeGeohash(lat, lon, 3)); // dr5

// Decision tree for choosing encoding scheme

function chooseEncoding(requirements) {
  const {
    humanReadable,
    caseSensitive,
    urlSafe,
    compact,
    cryptocurrency,
    authentication
  } = requirements;

  // Cryptocurrency and blockchain
  if (cryptocurrency) {
    return 'Base58'; // Bitcoin, IPFS standard
  }

  // Two-factor authentication
  if (authentication) {
    return 'Base32'; // TOTP standard (RFC 6238)
  }

  // Need maximum compactness
  if (compact && !humanReadable) {
    return 'Base64'; // Most compact encoding
  }

  // Case-insensitive requirement
  if (!caseSensitive && humanReadable) {
    return 'Base32'; // Case-insensitive, no ambiguous chars
  }

  // Visual clarity and manual entry
  if (humanReadable && !caseSensitive) {
    return 'Base32'; // Easy to read and type
  }

  // Compact and unambiguous
  if (compact && humanReadable) {
    return 'Base58'; // More compact than Base32, no ambiguous chars
  }

  // Default to Base64 for general use
  return 'Base64';
}

// Examples
console.log(chooseEncoding({
  cryptocurrency: true
})); // Base58

console.log(chooseEncoding({
  authentication: true,
  humanReadable: true
})); // Base32

console.log(chooseEncoding({
  compact: true,
  humanReadable: false
})); // Base64

const base32 = require('hi-base32');

// Some implementations omit padding
function addBase32Padding(str) {
  // Base32 output must be multiple of 8 characters
  while (str.length % 8 !== 0) {
    str += '=';
  }
  return str;
}

function removeBase32Padding(str) {
  return str.replace(/=+$/, '');
}

// Example: TOTP secrets often omit padding
const secretWithPadding = 'JBSWY3DPEHPK3PXP';
const secretNoPadding = removeBase32Padding(secretWithPadding);

console.log('With padding:', addBase32Padding(secretNoPadding));
console.log('Without padding:', secretNoPadding);

// Decode with or without padding
function flexibleBase32Decode(str) {
  try {
    // Try with padding first
    return base32.decode(addBase32Padding(str));
  } catch (e) {
    // Try without padding
    return base32.decode(str);
  }
}

// Both work
console.log(flexibleBase32Decode('JBSWY3DP'));
console.log(flexibleBase32Decode('JBSWY3DP===='));

const bs58 = require('bs58');
const base32 = require('hi-base32');

// Validate Base58 input
function isValidBase58(str) {
  const base58Regex = /^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/;
  return base58Regex.test(str);
}

// Validate Base32 input
function isValidBase32(str) {
  // RFC 4648 Base32: A-Z, 2-7, and padding =
  const base32Regex = /^[A-Z2-7]+=*$/i;
  return base32Regex.test(str) && str.length % 8 === 0;
}

// Safe Base58 decode
function safeBase58Decode(str) {
  if (!isValidBase58(str)) {
    throw new Error('Invalid Base58 string');
  }
  try {
    return bs58.decode(str);
  } catch (e) {
    throw new Error(`Base58 decode failed: ${e.message}`);
  }
}

// Safe Base32 decode
function safeBase32Decode(str) {
  if (!isValidBase32(str)) {
    throw new Error('Invalid Base32 string');
  }
  try {
    return base32.decode(str);
  } catch (e) {
    throw new Error(`Base32 decode failed: ${e.message}`);
  }
}

// Usage
try {
  const result = safeBase58Decode('2NEpo7TZRhna7vSvL');
  console.log('Decoded:', result);
} catch (e) {
  console.error('Error:', e.message);
}

// Invalid input
try {
  safeBase58Decode('invalid0O'); // Contains 0 and O
} catch (e) {
  console.error('Error:', e.message); // Invalid Base58 string
}

const crypto = require('crypto');
const bs58 = require('bs58');

// Generic Base58Check encoding (used in Bitcoin)
class Base58Check {
  static encode(payload, version = 0x00) {
    // Add version byte
    const versionedPayload = Buffer.concat([
      Buffer.from([version]),
      payload
    ]);

    // Calculate checksum (double SHA-256)
    const hash1 = crypto.createHash('sha256')
      .update(versionedPayload)
      .digest();
    const hash2 = crypto.createHash('sha256')
      .update(hash1)
      .digest();
    const checksum = hash2.slice(0, 4);

    // Concatenate and encode
    const fullPayload = Buffer.concat([versionedPayload, checksum]);
    return bs58.encode(fullPayload);
  }

  static decode(encoded) {
    const decoded = bs58.decode(encoded);

    // Extract components
    const payload = decoded.slice(0, -4);
    const checksum = decoded.slice(-4);

    // Verify checksum
    const hash1 = crypto.createHash('sha256').update(payload).digest();
    const hash2 = crypto.createHash('sha256').update(hash1).digest();
    const expectedChecksum = hash2.slice(0, 4);

    if (!checksum.equals(expectedChecksum)) {
      throw new Error('Invalid checksum');
    }

    // Return version and data
    return {
      version: payload[0],
      data: payload.slice(1)
    };
  }
}

// Usage
const data = Buffer.from('f54a5851e9372b87810a8e60cdd2e7cfd80b6e31', 'hex');
const encoded = Base58Check.encode(data, 0x00);
console.log('Encoded:', encoded); // 1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs

const decoded = Base58Check.decode(encoded);
console.log('Version:', decoded.version);
console.log('Data:', decoded.data.toString('hex'));

// Detect corrupted data
try {
  const corrupted = encoded.slice(0, -1) + '1';
  Base58Check.decode(corrupted);
} catch (e) {
  console.error('Checksum verification failed'); // Detected!
}