Python Base64 เข้ารหัส — b64encode() คู่มือ

import base64

# เข้ารหัสคู่ credential API สำหรับ HTTP Basic Auth header
service_id = "deploy-svc"
api_key    = "sk-prod-9f2a1c3e8b4d"

credential_bytes   = f"{service_id}:{api_key}".encode("utf-8")
encoded_bytes      = base64.b64encode(credential_bytes)
encoded_str        = encoded_bytes.decode("ascii")  # bytes → str

print(encoded_str)
# ZGVwbG95LXN2Yzpzay1wcm9kLTlmMmExYzNlOGI0ZA==

import urllib.request

req = urllib.request.Request("https://api.internal/v1/deployments")
req.add_header("Authorization", f"Basic {encoded_str}")
# ค่า header: Basic ZGVwbG95LXN2Yzpzay1wcm9kLTlmMmExYzNlOGI0ZA==

import base64
import json

# เข้ารหัส server configuration แบบมีโครงสร้างสำหรับ environment variable
server_config = {
    "host":           "db-primary.eu-west-1.internal",
    "port":           5432,
    "database":       "analytics_prod",
    "max_connections": 150,
    "ssl": {
        "mode":          "verify-full",
        "cert_path":     "/etc/ssl/certs/db-client.crt",
        "reject_self_signed": True,
    },
}

config_json    = json.dumps(server_config, sort_keys=True)
encoded_bytes  = base64.b64encode(config_json.encode("utf-8"))
encoded_str    = encoded_bytes.decode("ascii")

print(encoded_str[:60] + "...")
# eyJkYXRhYmFzZSI6ICJhbmFseXRpY3NfcHJvZCIsICJob3N0IjogImRi...

# ถอดรหัสและตรวจสอบ round-trip
decoded_json   = base64.b64decode(encoded_str).decode("utf-8")
restored       = json.loads(decoded_json)

print(restored["host"])            # db-primary.eu-west-1.internal
print(restored["ssl"]["mode"])     # verify-full

import base64

# เข้ารหัสเนื้อหาหลายภาษา — ชื่อแสดงผลผู้ใช้จากแพลตฟอร์มนานาชาติ
user_names = [
    "สมชาย ใจดี",           # ภาษาไทย — Unicode
    "田中太郎",              # อักขระ CJK — 3 bytes ต่อตัวใน UTF-8
    "Мария Соколова",      # Cyrillic — U+041C ขึ้นไป
    "สุนีย์ มีสุข",          # ภาษาไทย — Unicode
]

for name in user_names:
    encoded = base64.b64encode(name.encode("utf-8")).decode("ascii")
    decoded = base64.b64decode(encoded).decode("utf-8")

    print(f"ต้นฉบับ  : {name}")
    print(f"เข้ารหัส : {encoded}")
    print(f"Round-trip: {decoded}")
    print(f"ตรงกัน   : {name == decoded}")
    print()

# ต้นฉบับ  : Мария Соколова
# เข้ารหัส : 0JzQsNGA0LjRjyDQodC+0LrQvtC70L7QstCw
# Round-trip: Мария Соколова
# ตรงกัน   : True

import base64
import json

def encode_jwt_segment(data: dict) -> str:
    """เข้ารหัส dict เป็น URL-safe Base64 string โดยไม่มี padding (รูปแบบ JWT)"""
    json_bytes = json.dumps(data, separators=(",", ":")).encode("utf-8")
    return base64.urlsafe_b64encode(json_bytes).rstrip(b"=").decode("ascii")

def decode_jwt_segment(segment: str) -> dict:
    """ถอดรหัส URL-safe Base64 JWT segment (จัดการ padding ที่หายไป)"""
    # เพิ่ม padding กลับ: Base64 ต้องการให้ความยาวเป็นทวีคูณของ 4
    padding  = 4 - len(segment) % 4
    padded   = segment + ("=" * (padding % 4))
    raw      = base64.urlsafe_b64decode(padded)
    return json.loads(raw)

# สร้าง JWT header และ payload
header  = {"alg": "HS256", "typ": "JWT"}
payload = {
    "sub":       "usr_7c3a9f1b2d",
    "workspace": "ws_eu-west-1-prod",
    "role":      "data-engineer",
    "iat":       1741824000,
    "exp":       1741910400,
}

header_segment  = encode_jwt_segment(header)
payload_segment = encode_jwt_segment(payload)

print(header_segment)
# eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9

print(payload_segment)
# eyJzdWIiOiJ1c3JfN2MzYTlmMWIyZCIsIndvcmtzcGFjZSI6IndzX2...

# ตรวจสอบ round-trip
restored = decode_jwt_segment(payload_segment)
print(restored["role"])  # data-engineer

import base64
import json
from pathlib import Path

def encode_file_to_base64(file_path: str) -> str:
    """อ่านไฟล์ไบนารีและคืนการแทนค่าที่เข้ารหัส Base64"""
    try:
        raw_bytes = Path(file_path).read_bytes()
        return base64.b64encode(raw_bytes).decode("ascii")
    except FileNotFoundError:
        raise FileNotFoundError(f"ไม่พบไฟล์: {file_path}")
    except PermissionError:
        raise PermissionError(f"ปฏิเสธสิทธิ์การอ่าน: {file_path}")

# แนบ TLS certificate กับ deployment manifest
cert_b64 = encode_file_to_base64("./ssl/service-client.crt")

deployment_manifest = {
    "service":     "payment-processor",
    "environment": "production",
    "region":      "eu-west-1",
    "tls": {
        "client_cert":     cert_b64,
        "cert_format":     "base64-pem",
    },
}

# เขียน manifest — certificate ฝังอย่างปลอดภัยเป็น string
with open("./dist/deployment-manifest.json", "w") as f:
    json.dump(deployment_manifest, f, indent=2)

print(f"เข้ารหัส certificate แล้ว: {len(cert_b64)} อักขระ")

import base64
import requests  # pip install requests

def fetch_and_encode_binary(url: str, headers: dict | None = None) -> str:
    """ดึงทรัพยากรไบนารีจาก API และคืนเป็น Base64"""
    response = requests.get(url, headers=headers or {}, timeout=10)
    response.raise_for_status()  # raise HTTPError สำหรับ 4xx/5xx

    content_type = response.headers.get("Content-Type", "unknown")
    encoded      = base64.b64encode(response.content).decode("ascii")

    print(f"Content-Type : {content_type}")
    print(f"ขนาดดิบ     : {len(response.content):,} bytes")
    print(f"ขนาดเข้ารหัส: {len(encoded):,} อักขระ")
    return encoded

# ตัวอย่าง: ดาวน์โหลดใบแจ้งหนี้ PDF ที่เซ็นชื่อจาก billing API ภายใน
invoice_b64 = fetch_and_encode_binary(
    "https://billing.internal/api/v2/invoices/INV-2026-0042/pdf",
    headers={"Authorization": "Bearer eyJhbGc..."},
)

# แนบกับ notification payload
notification = {
    "recipient_id":  "team-finance",
    "invoice_id":    "INV-2026-0042",
    "attachment": {
        "filename":     "invoice-2026-0042.pdf",
        "content":      invoice_b64,
        "content_type": "application/pdf",
        "encoding":     "base64",
    },
}
print(f"Payload พร้อมแล้ว: {len(str(notification)):,} อักขระ")

import base64
import mimetypes
from pathlib import Path

def image_to_data_uri(image_path: str) -> str:
    """แปลงไฟล์รูปภาพเป็น Base64 data URI สำหรับการฝัง HTML แบบ inline"""
    path      = Path(image_path)
    mime_type = mimetypes.guess_type(image_path)[0] or "image/octet-stream"
    raw_bytes = path.read_bytes()
    encoded   = base64.b64encode(raw_bytes).decode("ascii")
    return f"data:{mime_type};base64,{encoded}"

# ฝังรูปภาพสินค้าแบบ inline ใน HTML email template
hero_uri      = image_to_data_uri("./assets/product-hero-768px.png")
thumbnail_uri = image_to_data_uri("./assets/product-thumb-128px.webp")

html_fragment = f"""
<img src="{hero_uri}"
     alt="ภาพหลักสินค้า"
     width="768" height="432"
     style="display:block;max-width:100%" />
"""

print(f"PNG data URI เริ่มต้นด้วย: {hero_uri[:60]}...")
# data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAwAAAAA...

import base64
from pathlib import Path

CHUNK_SIZE = 3 * 1024 * 256  # 786,432 bytes — ทวีคูณของ 3, ~768 KB ต่อ chunk

def encode_large_file(input_path: str, output_path: str) -> int:
    """
    เข้ารหัสไฟล์ไบนารีขนาดใหญ่เป็น Base64 โดยไม่โหลดทั้งหมดเข้าหน่วยความจำ
    คืนจำนวนอักขระ Base64 ที่เขียน
    """
    total_chars = 0
    with open(input_path, "rb") as src, open(output_path, "w") as dst:
        while True:
            chunk = src.read(CHUNK_SIZE)
            if not chunk:
                break
            encoded_chunk = base64.b64encode(chunk).decode("ascii")
            dst.write(encoded_chunk)
            total_chars += len(encoded_chunk)
    return total_chars

# เข้ารหัสวิดีโอสินค้า 300 MB สำหรับ asset delivery manifest
chars_written = encode_large_file(
    "./uploads/product-demo-4k.mp4",
    "./dist/product-demo-4k.b64",
)
print(f"เข้ารหัสแล้ว: {chars_written:,} อักขระ Base64")
# เข้ารหัสแล้ว: 407,374,184 อักขระ Base64

import base64
import json
from pathlib import Path

def encode_assets_to_ndjson(asset_dir: str, output_path: str) -> int:
    """
    เข้ารหัสไฟล์ไบนารีทั้งหมดในไดเรกทอรีเป็น NDJSON manifest
    แต่ละบรรทัดคือ JSON object: {"path": "...", "mime": "...", "data": "<base64>"}
    คืนจำนวนไฟล์ที่ประมวลผล
    """
    import mimetypes

    asset_path = Path(asset_dir)
    count = 0

    with open(output_path, "w") as out:
        for file_path in sorted(asset_path.rglob("*")):
            if not file_path.is_file():
                continue
            mime = mimetypes.guess_type(str(file_path))[0] or "application/octet-stream"
            encoded = base64.b64encode(file_path.read_bytes()).decode("ascii")
            record  = {"path": str(file_path.relative_to(asset_path)), "mime": mime, "data": encoded}
            out.write(json.dumps(record) + "\n")
            count += 1

    return count

processed = encode_assets_to_ndjson("./dist/static/", "./dist/asset-bundle.ndjson")
print(f"เข้ารหัส {processed} ไฟล์เป็น NDJSON asset bundle")

# ── python -m base64 ───────────────────────────────────────────────────
# เข้ารหัส string (pipe stdin)
echo -n "deploy-svc:sk-prod-9f2a1c3e8b4d" | python3 -m base64
# ZGVwbG95LXN2Yzpzay1wcm9kLTlmMmExYzNlOGI0ZA==

# เข้ารหัสไฟล์
python3 -m base64 ./ssl/service-client.crt

# ถอดรหัส Base64 string
echo "ZGVwbG95LXN2Yzpzay1wcm9kLTlmMmExYzNlOGI0ZA==" | python3 -m base64 -d

# ถอดรหัสไฟล์ Base64 กลับเป็นไบนารี
python3 -m base64 -d ./dist/service-client.b64 > ./restored.crt

# ── Python one-liner — ข้ามแพลตฟอร์ม ทำงานบน Windows ────────────────
# เข้ารหัส string
python3 -c "import base64,sys; print(base64.b64encode(sys.argv[1].encode()).decode())" "my-secret"
# bXktc2VjcmV0

# เข้ารหัสแบบ URL-safe (ไม่มี padding)
python3 -c "import base64,sys; print(base64.urlsafe_b64encode(sys.argv[1].encode()).rstrip(b'=').decode())" "my-secret"
# bXktc2VjcmV0

# เข้ารหัสไฟล์แบบ inline (ผลลัพธ์บน stdout)
python3 -c "import base64,sys; print(base64.b64encode(open(sys.argv[1],'rb').read()).decode())" ./config.json

pip install pybase64

import pybase64
import time

# pybase64 เป็นตัวแทน drop-in — ลายเซ็นฟังก์ชันเหมือนกับ stdlib
sample_payload = b"x" * (1024 * 1024)  # 1 MB ข้อมูลไบนารี

# การเข้ารหัสมาตรฐาน — เอาต์พุตเหมือนกับ base64.b64encode()
encoded = pybase64.b64encode(sample_payload)
decoded = pybase64.b64decode(encoded)
assert decoded == sample_payload

# การเข้ารหัสแบบ URL-safe — เอาต์พุตเหมือนกับ base64.urlsafe_b64encode()
url_safe = pybase64.urlsafe_b64encode(sample_payload)

# b64encode_as_string() คืน str โดยตรง — ไม่ต้องเรียก .decode()
telemetry_event = b'{"event":"page_view","session_id":"sess_3a7f91c2","ts":1741824000}'
encoded_str: str = pybase64.b64encode_as_string(telemetry_event)

print(encoded_str[:48] + "...")
# eyJldmVudCI6InBhZ2VfdmlldyIsInNlc3Npb25faWQi...

# การเปรียบเทียบ throughput (โดยประมาณ ขึ้นอยู่กับฮาร์ดแวร์)
# stdlib  base64.b64encode(1 MB):   ~80 MB/s
# pybase64.b64encode(1 MB):         ~800 MB/s (เส้นทาง SIMD บน CPU AVX2)

pip install rich

import base64
import json
from rich import print as rprint
from rich.syntax import Syntax
from rich.console import Console

console = Console()

def decode_and_pretty_print(encoded: str, label: str = "Payload ที่ถอดรหัส") -> None:
    """ถอดรหัส Base64 string, parse เป็น JSON และพิมพ์พร้อม syntax highlighting"""
    raw_bytes = base64.b64decode(encoded + "==")  # tolerant padding
    try:
        parsed  = json.loads(raw_bytes)
        pretty  = json.dumps(parsed, indent=2, ensure_ascii=False)
        syntax  = Syntax(pretty, "json", theme="monokai", line_numbers=False)
        console.rule(f"[bold blue]{label}")
        console.print(syntax)
    except json.JSONDecodeError:
        # ไม่ใช่ JSON — พิมพ์ข้อความดิบ
        console.rule(f"[bold yellow]{label} (ข้อความดิบ)")
        rprint(raw_bytes.decode("utf-8", errors="replace"))

# ตรวจสอบ JWT payload segment จาก request การยืนยันตัวตนที่ล้มเหลว
jwt_payload_segment = "eyJzdWIiOiJ1c3JfN2MzYTlmMWIyZCIsInJvbGUiOiJkYXRhLWVuZ2luZWVyIiwiZXhwIjoxNzQxOTEwNDAwfQ"
decode_and_pretty_print(jwt_payload_segment, "JWT Payload")