> For the complete documentation index, see [llms.txt](https://alham-rizvi.gitbook.io/alhamrizvi/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://alham-rizvi.gitbook.io/alhamrizvi/cryptography/hashing/25.-base64.md).

# Base64 Encoding

## What is Base64?

**Base64** is a binary-to-text encoding scheme that represents binary data using 64 printable ASCII characters. It is used to safely transmit binary data over text-based protocols (email, HTTP headers, JSON, XML).

***

## Base64 Alphabet

```
A-Z = 0–25   (26 chars)
a-z = 26–51  (26 chars)
0-9 = 52–61  (10 chars)
+   = 62
/   = 63
=   = padding character
```

### Variants

| Variant    | Special chars | Use case               |
| ---------- | ------------- | ---------------------- |
| Standard   | `+` `/`       | MIME, PEM certificates |
| URL-safe   | `-` `_`       | URLs, JWTs, cookies    |
| No padding | no `=`        | Compact storage        |

***

## How Base64 Works

Base64 converts every **3 bytes** into **4 characters** (each character = 6 bits):

```
Input (3 bytes):   M          a          n
Binary:         01001101   01100001   01101110
                └──────────────────────────┘
                            24 bits
Group into 6:   010011  010110  000101  101110
Decimal:          19      22       5      46
Base64:           T       W       F      u

"Man" → "TWFu"
```

### Padding with `=`

* If input is not divisible by 3:
  * 1 extra byte → pad with `==`
  * 2 extra bytes → pad with `=`

```
"M"   → "TQ=="
"Ma"  → "TWE="
"Man" → "TWFu"
```

***

## Size Expansion

```
Every 3 bytes → 4 Base64 chars
Overhead: 4/3 ≈ 33.3% size increase

Formula: ceil(n / 3) × 4 characters
```

| Input size | Base64 size |
| ---------- | ----------- |
| 3 bytes    | 4 chars     |
| 9 bytes    | 12 chars    |
| 32 bytes   | 44 chars    |
| 1 KB       | \~1.37 KB   |
| 1 MB       | \~1.37 MB   |

***

## Implementation Examples

### Python

```python
import base64

# Encode
data = b"Hello, World!"
encoded = base64.b64encode(data)
print(encoded)  # b'SGVsbG8sIFdvcmxkIQ=='

# Decode
decoded = base64.b64decode(encoded)
print(decoded)  # b'Hello, World!'

# URL-safe variant
url_encoded = base64.urlsafe_b64encode(data)
print(url_encoded)  # b'SGVsbG8sIFdvcmxkIQ=='

# With strings
text = "Hello, World!"
encoded_str = base64.b64encode(text.encode()).decode()
decoded_str = base64.b64decode(encoded_str).decode()

# Encode file
with open("image.png", "rb") as f:
    img_base64 = base64.b64encode(f.read()).decode()
```

### JavaScript

```javascript
// Browser
const encoded = btoa("Hello, World!");        // "SGVsbG8sIFdvcmxkIQ=="
const decoded = atob("SGVsbG8sIFdvcmxkIQ=="); // "Hello, World!"

// Node.js (Buffer)
const encoded = Buffer.from("Hello, World!").toString('base64');
const decoded = Buffer.from(encoded, 'base64').toString('utf-8');

// URL-safe (replace + with - and / with _)
const urlSafe = Buffer.from(data).toString('base64url');

// Encode binary file
const fs = require('fs');
const fileData = fs.readFileSync('image.png');
const base64Image = fileData.toString('base64');
```

### Go

```go
import "encoding/base64"

// Standard
encoded := base64.StdEncoding.EncodeToString([]byte("Hello"))
decoded, _ := base64.StdEncoding.DecodeString(encoded)

// URL-safe
urlEncoded := base64.URLEncoding.EncodeToString([]byte("Hello"))

// No padding
rawEncoded := base64.RawStdEncoding.EncodeToString([]byte("Hello"))
```

### Rust

```rust
use base64::{Engine, engine::general_purpose};

let encoded = general_purpose::STANDARD.encode(b"Hello");
let decoded = general_purpose::STANDARD.decode(&encoded).unwrap();

// URL-safe
let url_encoded = general_purpose::URL_SAFE.encode(b"Hello");
```

***

## Common Use Cases in Cryptography & Security

### JWT (JSON Web Token)

```
eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VyMTIzIn0.abc123
│                   │ │                        │ │     │
└── Header (Base64) ┘ └────── Payload (Base64) ┘ └─Sig─┘
```

### PEM Certificate

```
-----BEGIN CERTIFICATE-----
MIIDazCCAlOgAwIBAgIUYQ...   ← Base64-encoded DER certificate
-----END CERTIFICATE-----
```

### HTML Data URI

```html
<img src="data:image/png;base64,iVBORw0KGgo..." />
```

### Basic Auth HTTP Header

```
Authorization: Basic dXNlcjpwYXNzd29yZA==
                     └── base64("user:password")
```

***

## Security Considerations

| Misconception                | Reality                                |
| ---------------------------- | -------------------------------------- |
| Base64 is encryption         | ❌ It's encoding — trivially reversible |
| Base64 hides data            | ❌ Anyone can decode it instantly       |
| Base64 is compression        | ❌ It makes data 33% larger             |
| Base64 is safe for passwords | ❌ Never use Base64 alone for passwords |

```python
import base64
# "Decoding" Base64 is trivial:
base64.b64decode("dXNlcjpwYXNzd29yZA==")
# b'user:password'
```

***

## Base64 vs Alternatives

| Encoding       | Size overhead | Use case                 |
| -------------- | ------------- | ------------------------ |
| Hex            | 100%          | Debugging, checksums     |
| Base64         | 33%           | Files, binary in text    |
| Base85/Ascii85 | 25%           | PDF, git objects         |
| Base32         | 60%           | Case-insensitive systems |

***

## Best Practices

* Use **URL-safe Base64** (`-_` instead of `+/`) for URLs and JWTs
* Never use Base64 as a security measure — it's encoding, not encryption
* Strip or handle padding (`=`) carefully in URL contexts
* For binary comparison, always **decode first** then compare bytes
* Validate Base64 input before decoding (malformed input can cause errors)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://alham-rizvi.gitbook.io/alhamrizvi/cryptography/hashing/25.-base64.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.