Base64 Encoding in Rust

Rust uses the base64 crate for encoding and decoding. Add it to your Cargo.toml:

[dependencies]
base64 = "0.21"

Basic Usage

Encode to Base64

use base64::{Engine as _, engine::general_purpose};

fn main() {
    let text = "Hello, World!";
    let encoded = general_purpose::STANDARD.encode(text);
    println!("{}", encoded); // "SGVsbG8sIFdvcmxkIQ=="
}

Decode from Base64

use base64::{Engine as _, engine::general_purpose};

fn main() {
    let encoded = "SGVsbG8sIFdvcmxkIQ==";
    let decoded = general_purpose::STANDARD.decode(encoded).unwrap();
    let text = String::from_utf8(decoded).unwrap();
    println!("{}", text); // "Hello, World!"
}

Available Engines

The crate provides several pre-configured engines:

use base64::engine::general_purpose;

// Standard Base64 (RFC 4648)
general_purpose::STANDARD          // With padding
general_purpose::STANDARD_NO_PAD   // Without padding

// URL-safe Base64
general_purpose::URL_SAFE          // With padding
general_purpose::URL_SAFE_NO_PAD   // Without padding

URL-Safe Base64

use base64::{Engine as _, engine::general_purpose};

fn main() {
    let text = "Hello, World!";

    // With padding
    let encoded = general_purpose::URL_SAFE.encode(text);
    println!("{}", encoded);

    // Without padding
    let encoded_no_pad = general_purpose::URL_SAFE_NO_PAD.encode(text);
    println!("{}", encoded_no_pad);

    // Decode
    let decoded = general_purpose::URL_SAFE.decode(&encoded).unwrap();
    println!("{}", String::from_utf8(decoded).unwrap());
}

File to Base64

Encode a File

use base64::{Engine as _, engine::general_purpose};
use std::fs;

fn main() {
    let bytes = fs::read("image.png").unwrap();
    let encoded = general_purpose::STANDARD.encode(&bytes);
    println!("{}", encoded);
}

Decode to File

use base64::{Engine as _, engine::general_purpose};
use std::fs;

fn main() {
    let encoded = "iVBORw0KGgo..."; // Base64 string
    let decoded = general_purpose::STANDARD.decode(encoded).unwrap();
    fs::write("output.png", decoded).unwrap();
}

Error Handling

use base64::{Engine as _, engine::general_purpose, DecodeError};

fn decode_safe(input: &str) -> Result<String, DecodeError> {
    let bytes = general_purpose::STANDARD.decode(input)?;
    Ok(String::from_utf8_lossy(&bytes).to_string())
}

fn main() {
    match decode_safe("SGVsbG8=") {
        Ok(text) => println!("Decoded: {}", text),
        Err(e) => println!("Error: {}", e),
    }
}

Custom Configuration

use base64::{Engine, alphabet, engine::{self, GeneralPurposeConfig}};

fn main() {
    // Custom engine with specific configuration
    let custom_engine = engine::GeneralPurpose::new(
        &alphabet::STANDARD,
        GeneralPurposeConfig::new()
            .with_encode_padding(false)
            .with_decode_allow_trailing_bits(true)
    );

    let encoded = custom_engine.encode("Hello");
    println!("{}", encoded);
}

Streaming (Large Files)

use base64::{Engine as _, engine::general_purpose};
use std::io::{Read, Write};
use std::fs::File;

fn main() {
    let mut input = File::open("input.bin").unwrap();
    let mut output = File::create("output.txt").unwrap();

    let mut buffer = [0u8; 3 * 1024]; // Read in multiples of 3
    loop {
        let bytes_read = input.read(&mut buffer).unwrap();
        if bytes_read == 0 { break; }

        let encoded = general_purpose::STANDARD.encode(&buffer[..bytes_read]);
        output.write_all(encoded.as_bytes()).unwrap();
    }
}

Validation

use base64::{Engine as _, engine::general_purpose};

fn is_valid_base64(input: &str) -> bool {
    general_purpose::STANDARD.decode(input).is_ok()
}

fn main() {
    println!("{}", is_valid_base64("SGVsbG8=")); // true
    println!("{}", is_valid_base64("Invalid!!!")); // false
}