🔐 Python Base64 Module - Complete Guide#

1
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

1
Text:    "Hi"
2
Binary:  01001000 01101001
3
Base64:  SGk=

1
import base64

1
import base64
2

3
# Original text
4
text = "Hello, World!"
5

6
# Encode (string → bytes → base64 bytes → base64 string)
7
encoded_bytes = base64.b64encode(text.encode('utf-8'))
8
encoded_string = encoded_bytes.decode('utf-8')
9

10
print(f"Original: {text}")
11
print(f"Encoded:  {encoded_string}")
12

13
# Output:
14
# Original: Hello, World!
15
# Encoded:  SGVsbG8sIFdvcmxkIQ==

1
import base64
2

3
# Encode
4
encoded = base64.b64encode(b"Hello").decode()
5
print(encoded)  # SGVsbG8=
6

7
# Alternative with string
8
text = "Hello, World!"
9
encoded = base64.b64encode(text.encode()).decode()
10
print(encoded)  # SGVsbG8sIFdvcmxkIQ==

1
import base64
2

3
# Binary data
4
data = bytes([0x48, 0x65, 0x6c, 0x6c, 0x6f])  # "Hello" in bytes
5

6
encoded = base64.b64encode(data)
7
print(encoded)  # b'SGVsbG8='

1
import base64
2

3
# Base64 encoded string
4
encoded = "SGVsbG8sIFdvcmxkIQ=="
5

6
# Decode (base64 string → bytes → string)
7
decoded_bytes = base64.b64decode(encoded)
8
decoded_string = decoded_bytes.decode('utf-8')
9

10
print(f"Encoded: {encoded}")
11
print(f"Decoded: {decoded_string}")
12

13
# Output:
14
# Encoded: SGVsbG8sIFdvcmxkIQ==
15
# Decoded: Hello, World!

1
import base64
2

3
# Decode
4
decoded = base64.b64decode("SGVsbG8sIFdvcmxkIQ==").decode()
5
print(decoded)  # Hello, World!

1
import base64
2

3
def safe_decode(encoded_string):
4
    try:
5
        decoded = base64.b64decode(encoded_string).decode('utf-8')
6
        return decoded
7
    except Exception as e:
8
        return f"Error: {e}"
9

10
# Test
11
print(safe_decode("SGVsbG8="))           # Hello
12
print(safe_decode("Invalid!!!"))          # Error: ...

1
import base64
2

3
text = "Hello?World+Test"
4

5
# Standard Base64
6
standard = base64.b64encode(text.encode()).decode()
7
print(f"Standard: {standard}")
8

9
# URL-Safe Base64
10
url_safe = base64.urlsafe_b64encode(text.encode()).decode()
11
print(f"URL-Safe: {url_safe}")
12

13
# Output:
14
# Standard: SGVsbG8/V29ybGQrVGVzdA==
15
# URL-Safe: SGVsbG8_V29ybGQrVGVzdA==

1
import base64
2

3
encoded = "SGVsbG8_V29ybGQrVGVzdA=="
4

5
decoded = base64.urlsafe_b64decode(encoded).decode()
6
print(decoded)  # Hello?World+Test

1
import base64
2

3
text = "Hello"
4

5
# Encode
6
encoded = base64.b32encode(text.encode()).decode()
7
print(f"Base32: {encoded}")  # JBSWY3DP
8

9
# Decode
10
decoded = base64.b32decode(encoded).decode()
11
print(f"Decoded: {decoded}")  # Hello

1
ABCDEFGHIJKLMNOPQRSTUVWXYZ234567

1
import base64
2

3
text = "Hello"
4

5
# Encode to hex
6
hex_encoded = base64.b16encode(text.encode()).decode()
7
print(f"Hex: {hex_encoded}")  # 48656C6C6F
8

9
# Decode from hex
10
decoded = base64.b16decode(hex_encoded).decode()
11
print(f"Decoded: {decoded}")  # Hello

1
# Using bytes method
2
text = "Hello"
3

4
# Encode
5
hex_str = text.encode().hex()
6
print(hex_str)  # 48656c6c6f
7

8
# Decode
9
decoded = bytes.fromhex(hex_str).decode()
10
print(decoded)  # Hello

1
import base64
2

3
text = "Hello, World!"
4

5
# Encode
6
encoded = base64.a85encode(text.encode()).decode()
7
print(f"ASCII85: {encoded}")
8

9
# Decode
10
decoded = base64.a85decode(encoded).decode()
11
print(f"Decoded: {decoded}")

1
import base64
2

3
text = "Hello, World!"
4

5
# Encode
6
encoded = base64.b85encode(text.encode()).decode()
7
print(f"Base85: {encoded}")
8

9
# Decode
10
decoded = base64.b85decode(encoded).decode()
11
print(f"Decoded: {decoded}")

1
import base64
2

3
def encode_file(filepath):
4
    """Read file and return Base64 encoded string"""
5
    with open(filepath, "rb") as f:
6
        data = f.read()
7
    encoded = base64.b64encode(data).decode()
8
    return encoded
9

10
# Usage
11
encoded_content = encode_file("document.pdf")
12
print(encoded_content[:100])  # First 100 chars
13

14
# Save encoded to file
15
with open("document.b64", "w") as f:
16
    f.write(encoded_content)

1
import base64
2

3
def decode_file(encoded_string, output_path):
4
    """Decode Base64 string and save to file"""
5
    decoded = base64.b64decode(encoded_string)
6
    with open(output_path, "wb") as f:
7
        f.write(decoded)
8

9
# Usage
10
with open("document.b64", "r") as f:
11
    encoded_content = f.read()
12

13
decode_file(encoded_content, "restored_document.pdf")

1
import base64
2

3
def encode_file_streaming(input_path, output_path):
4
    """Encode large file in chunks"""
5
    with open(input_path, "rb") as fin:
6
        with open(output_path, "wb") as fout:
7
            while True:
8
                # Read in chunks of 57 bytes (produces 76 Base64 chars)
9
                chunk = fin.read(57)
10
                if not chunk:
11
                    break
12
                encoded = base64.b64encode(chunk)
13
                fout.write(encoded)
14
                fout.write(b"\n")  # Add newline for readability
15

16
encode_file_streaming("large_file.zip", "large_file.b64")

1
import base64
2

3
def image_to_base64(image_path):
4
    """Convert image to Base64 string"""
5
    with open(image_path, "rb") as f:
6
        data = f.read()
7
    return base64.b64encode(data).decode()
8

9
# Usage
10
image_b64 = image_to_base64("photo.jpg")
11
print(f"Length: {len(image_b64)} characters")
12
print(f"Preview: {image_b64[:50]}...")

1
import base64
2

3
def base64_to_image(b64_string, output_path):
4
    """Convert Base64 string back to image"""
5
    data = base64.b64decode(b64_string)
6
    with open(output_path, "wb") as f:
7
        f.write(data)
8

9
# Usage
10
base64_to_image(image_b64, "restored_photo.jpg")

1
import base64
2
from PIL import Image
3
import io
4

5
# Image to Base64
6
def pil_to_base64(image):
7
    buffer = io.BytesIO()
8
    image.save(buffer, format="PNG")
9
    return base64.b64encode(buffer.getvalue()).decode()
10

11
# Base64 to Image
12
def base64_to_pil(b64_string):
13
    data = base64.b64decode(b64_string)
14
    return Image.open(io.BytesIO(data))
15

16
# Usage
17
img = Image.open("photo.png")
18
b64 = pil_to_base64(img)
19

20
restored_img = base64_to_pil(b64)
21
restored_img.show()

1
data:[<mediatype>][;base64],<data>

1
import base64
2

3
def image_to_data_url(image_path):
4
    """Create data URL from image"""
5
    # Determine MIME type
6
    extension = image_path.split(".")[-1].lower()
7
    mime_types = {
8
        "jpg": "image/jpeg",
9
        "jpeg": "image/jpeg",
10
        "png": "image/png",
11
        "gif": "image/gif",
12
        "svg": "image/svg+xml",
13
        "webp": "image/webp"
14
    }
15
    mime_type = mime_types.get(extension, "application/octet-stream")
16

17
    # Encode image
18
    with open(image_path, "rb") as f:
19
        data = base64.b64encode(f.read()).decode()
20

21
    return f"data:{mime_type};base64,{data}"
22

23
# Usage
24
data_url = image_to_data_url("logo.png")
25
print(data_url)
26

27
# Use in HTML
28
html = f'<img src="{data_url}" alt="Logo">'

1
# Text
2
text_url = f"data:text/plain;base64,{base64.b64encode(b'Hello').decode()}"
3

4
# HTML
5
html_content = "<h1>Hello</h1>"
6
html_url = f"data:text/html;base64,{base64.b64encode(html_content.encode()).decode()}"
7

8
# JSON
9
import json
10
json_data = {"name": "Ahmed", "age": 25}
11
json_url = f"data:application/json;base64,{base64.b64encode(json.dumps(json_data).encode()).decode()}"
12

13
# PDF
14
with open("doc.pdf", "rb") as f:
15
    pdf_url = f"data:application/pdf;base64,{base64.b64encode(f.read()).decode()}"

1
import base64
2
import json
3

4
# Data to encode
5
data = {
6
    "name": "Ahmed",
7
    "age": 25,
8
    "skills": ["Python", "Hacking"],
9
    "active": True
10
}
11

12
# Convert to JSON string, then Base64
13
json_string = json.dumps(data)
14
encoded = base64.b64encode(json_string.encode()).decode()
15

16
print(f"JSON: {json_string}")
17
print(f"Base64: {encoded}")

1
import base64
2
import json
3

4
encoded = "eyJuYW1lIjogIkFobWVkIiwgImFnZSI6IDI1fQ=="
5

6
# Decode Base64, then parse JSON
7
json_string = base64.b64decode(encoded).decode()
8
data = json.loads(json_string)
9

10
print(f"Name: {data['name']}")
11
print(f"Age: {data['age']}")

1
import base64
2
import json
3

4
# Sometimes APIs use Base64-encoded JSON in JSON
5
payload = {
6
    "type": "message",
7
    "data": base64.b64encode(json.dumps({
8
        "text": "Hello",
9
        "timestamp": 1234567890
10
    }).encode()).decode()
11
}
12

13
# To read it:
14
inner_data = json.loads(base64.b64decode(payload["data"]).decode())
15
print(inner_data)  # {'text': 'Hello', 'timestamp': 1234567890}

1
import base64
2

3
# This is NOT secure!
4
password = "secret123"
5
encoded = base64.b64encode(password.encode()).decode()
6

7
print(f"Encoded: {encoded}")  # c2VjcmV0MTIz
8

9
# Anyone can decode it!
10
decoded = base64.b64decode(encoded).decode()
11
print(f"Decoded: {decoded}")  # secret123

1
import base64
2
from cryptography.fernet import Fernet  # pip install cryptography
3

4
# Generate key (store this securely!)
5
key = Fernet.generate_key()
6
cipher = Fernet(key)
7

8
# Encrypt
9
message = "Secret message"
10
encrypted = cipher.encrypt(message.encode())
11
print(f"Encrypted: {encrypted}")
12

13
# Decrypt
14
decrypted = cipher.decrypt(encrypted).decode()
15
print(f"Decrypted: {decrypted}")

1
import base64
2
import requests
3

4
def basic_auth(username, password):
5
    """Create Basic Auth header"""
6
    credentials = f"{username}:{password}"
7
    encoded = base64.b64encode(credentials.encode()).decode()
8
    return f"Basic {encoded}"
9

10
# Usage
11
headers = {
12
    "Authorization": basic_auth("admin", "secret123")
13
}
14

15
# Makes: Authorization: Basic YWRtaW46c2VjcmV0MTIz
16
response = requests.get("https://api.example.com", headers=headers)

1
import base64
2
from email.mime.base import MIMEBase
3
from email import encoders
4

5
def create_attachment(filepath):
6
    """Create email attachment"""
7
    with open(filepath, "rb") as f:
8
        data = f.read()
9

10
    # Encode for email
11
    encoded = base64.b64encode(data).decode()
12

13
    # Split into lines of 76 characters (MIME standard)
14
    lines = [encoded[i:i+76] for i in range(0, len(encoded), 76)]
15
    return "\n".join(lines)
16

17
attachment_data = create_attachment("document.pdf")

1
import base64
2
import json
3

4
def decode_jwt_payload(token):
5
    """Extract payload from JWT (don't use for security!)"""
6
    parts = token.split(".")
7
    if len(parts) != 3:
8
        raise ValueError("Invalid JWT format")
9

10
    # Payload is the second part (with padding fix)
11
    payload_b64 = parts[1]
12
    # Add padding if needed
13
    padding = 4 - len(payload_b64) % 4
14
    if padding != 4:
15
        payload_b64 += "=" * padding
16

17
    payload_json = base64.urlsafe_b64decode(payload_b64).decode()
18
    return json.loads(payload_json)
19

20
# Example JWT
21
token = "eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoiQWhtZWQiLCJyb2xlIjoiYWRtaW4ifQ.signature"
22
payload = decode_jwt_payload(token)
23
print(payload)  # {'name': 'Ahmed', 'role': 'admin'}

1
import base64
2

3
def simple_obfuscate(text, layers=3):
4
    """Multiple Base64 encoding layers (NOT SECURE!)"""
5
    result = text.encode()
6
    for _ in range(layers):
7
        result = base64.b64encode(result)
8
    return result.decode()
9

10
def simple_deobfuscate(encoded, layers=3):
11
    """Reverse multiple Base64 encoding"""
12
    result = encoded.encode()
13
    for _ in range(layers):
14
        result = base64.b64decode(result)
15
    return result.decode()
16

17
# Usage
18
original = "Secret Message"
19
obfuscated = simple_obfuscate(original)
20
print(f"Obfuscated: {obfuscated}")
21

22
restored = simple_deobfuscate(obfuscated)
23
print(f"Restored: {restored}")

1
import base64
2
import os
3

4
def create_html_with_images(folder_path, output_html):
5
    """Create HTML page with embedded images"""
6
    html = """<!DOCTYPE html>
7
<html>
8
<head>
9
    <title>Image Gallery</title>
10
    <style>
11
        body { font-family: Arial; padding: 20px; background: #222; }
12
        .gallery { display: flex; flex-wrap: wrap; gap: 10px; }
13
        .gallery img { max-width: 300px; border-radius: 10px; }
14
    </style>
15
</head>
16
<body>
17
    <h1 style="color: white;">Image Gallery</h1>
18
    <div class="gallery">
19
"""
20

21
    for filename in os.listdir(folder_path):
22
        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif')):
23
            filepath = os.path.join(folder_path, filename)
24

25
            # Determine MIME type
26
            ext = filename.split('.')[-1].lower()
27
            mime = f"image/{'jpeg' if ext == 'jpg' else ext}"
28

29
            # Encode image
30
            with open(filepath, "rb") as f:
31
                b64 = base64.b64encode(f.read()).decode()
32

33
            html += f'        <img src="data:{mime};base64,{b64}" alt="{filename}">\n'
34

35
    html += """    </div>
36
</body>
37
</html>"""
38

39
    with open(output_html, "w") as f:
40
        f.write(html)
41

42
    print(f"Created: {output_html}")
43

44
# Usage
45
# create_html_with_images("./images", "gallery.html")

1
import base64
2
import argparse
3
import sys
4

5
def main():
6
    parser = argparse.ArgumentParser(description="Base64 Encoder/Decoder")
7
    parser.add_argument("action", choices=["encode", "decode"], help="Action to perform")
8
    parser.add_argument("-t", "--text", help="Text to encode/decode")
9
    parser.add_argument("-f", "--file", help="File to encode/decode")
10
    parser.add_argument("-o", "--output", help="Output file")
11
    parser.add_argument("-u", "--urlsafe", action="store_true", help="Use URL-safe Base64")
12

13
    args = parser.parse_args()
14

15
    # Get input data
16
    if args.text:
17
        data = args.text.encode() if args.action == "encode" else args.text
18
    elif args.file:
19
        mode = "rb" if args.action == "encode" else "r"
20
        with open(args.file, mode) as f:
21
            data = f.read() if args.action == "encode" else f.read()
22
    else:
23
        print("Provide --text or --file")
24
        sys.exit(1)
25

26
    # Process
27
    if args.action == "encode":
28
        if args.urlsafe:
29
            result = base64.urlsafe_b64encode(data).decode()
30
        else:
31
            result = base64.b64encode(data).decode()
32
    else:
33
        if args.urlsafe:
34
            result = base64.urlsafe_b64decode(data)
35
        else:
36
            result = base64.b64decode(data)
37
        if isinstance(result, bytes):
38
            result = result.decode()
39

40
    # Output
41
    if args.output:
42
        mode = "w" if isinstance(result, str) else "wb"
43
        with open(args.output, mode) as f:
44
            f.write(result)
45
        print(f"Saved to: {args.output}")
46
    else:
47
        print(result)
48

49
if __name__ == "__main__":
50
    main()
51

52
# Usage:
53
# python base64_tool.py encode -t "Hello World"
54
# python base64_tool.py decode -t "SGVsbG8gV29ybGQ="
55
# python base64_tool.py encode -f image.png -o image.b64
56
# python base64_tool.py decode -f image.b64 -o restored.png

1
import base64
2

3
def hide_in_spaces(cover_text, secret_message):
4
    """Hide message in whitespace (tabs vs spaces)"""
5
    # Encode secret to binary
6
    secret_b64 = base64.b64encode(secret_message.encode()).decode()
7
    binary = ''.join(format(ord(c), '08b') for c in secret_b64)
8

9
    # Add length header
10
    length_bin = format(len(binary), '016b')
11
    binary = length_bin + binary
12

13
    # Replace spaces based on binary
14
    result = []
15
    bin_index = 0
16

17
    for char in cover_text:
18
        if char == ' ' and bin_index < len(binary):
19
            # 0 = space, 1 = tab
20
            result.append('\t' if binary[bin_index] == '1' else ' ')
21
            bin_index += 1
22
        else:
23
            result.append(char)
24

25
    return ''.join(result)
26

27
def extract_from_spaces(stego_text):
28
    """Extract hidden message from whitespace"""
29
    # Extract binary from spaces/tabs
30
    binary = ''
31
    for char in stego_text:
32
        if char in ' \t':
33
            binary += '1' if char == '\t' else '0'
34

35
    # Get length
36
    length = int(binary[:16], 2)
37
    data_binary = binary[16:16+length]
38

39
    # Convert binary to characters
40
    chars = [chr(int(data_binary[i:i+8], 2)) for i in range(0, len(data_binary), 8)]
41
    secret_b64 = ''.join(chars)
42

43
    # Decode Base64
44
    return base64.b64decode(secret_b64).decode()
45

46
# Usage
47
cover = "This is a normal looking text with many spaces for hiding data"
48
secret = "Secret!"
49

50
stego = hide_in_spaces(cover, secret)
51
print(f"Stego text: {repr(stego)}")
52

53
extracted = extract_from_spaces(stego)
54
print(f"Extracted: {extracted}")

1
import base64
2
import qrcode  # pip install qrcode[pil]
3
import io
4

5
def data_to_qr(data, output_path="qr.png"):
6
    """Convert data to QR code"""
7
    # Encode data
8
    encoded = base64.b64encode(data.encode()).decode()
9

10
    # Generate QR code
11
    qr = qrcode.QRCode(version=1, box_size=10, border=5)
12
    qr.add_data(encoded)
13
    qr.make(fit=True)
14

15
    img = qr.make_image(fill_color="black", back_color="white")
16
    img.save(output_path)
17

18
    print(f"QR code saved: {output_path}")
19
    return output_path
20

21
def qr_to_data(qr_image_path):
22
    """Read QR code and decode data"""
23
    from pyzbar.pyzbar import decode  # pip install pyzbar
24
    from PIL import Image
25

26
    img = Image.open(qr_image_path)
27
    decoded = decode(img)
28

29
    if decoded:
30
        encoded = decoded[0].data.decode()
31
        return base64.b64decode(encoded).decode()
32
    return None
33

34
# Usage
35
# data_to_qr("Secret message in QR code!")
36
# message = qr_to_data("qr.png")
37
# print(message)