Python SHA-256 হ্যাশ — hashlib গাইড ও কোড উদাহরণ

import hashlib

# বাইট স্ট্রিং সরাসরি হ্যাশ করুন
digest = hashlib.sha256(b"deployment-v4.2.1").hexdigest()
print(digest)
# a8f5f167f44f4964e6c998dee827110c3f1de4d0280c68cba98cf70b4b5157db

import hashlib

# হ্যাশ করার আগে স্ট্রিং বাইটে এনকোড করতে হবে
config_key = "redis://cache.internal:6379/0"
digest = hashlib.sha256(config_key.encode("utf-8")).hexdigest()
print(digest)
# 7d3f8c2a1b9e4f5d6c8a7b3e2f1d9c4a5b8e7f6d3c2a1b9e4f5d6c8a7b3e2f1d

import hashlib

h = hashlib.sha256()
h.update(b"request_id=req_7f3a91bc")
h.update(b"&timestamp=1741614120")
h.update(b"&amount=4999")
print(h.hexdigest())
# hashlib.sha256(b"request_id=req_7f3a91bc&timestamp=1741614120&amount=4999").hexdigest()-এর সমতুল্য

import hmac
import hashlib

# ওয়েবহুক স্বাক্ষর যাচাই
secret_key = b"whsec_9f3a7b2e1d4c8a5b"
payload = b'{"event":"invoice.paid","invoice_id":"inv_8d2c","amount":14900}'

signature = hmac.new(secret_key, payload, hashlib.sha256).hexdigest()
print(signature)
# 64-character hex HMAC-SHA256 digest

import hmac
import hashlib

def verify_webhook(payload: bytes, received_sig: str, secret: bytes) -> bool:
    """ধ্রুবক-সময় তুলনা ব্যবহার করে ওয়েবহুক স্বাক্ষর যাচাই করুন।"""
    expected = hmac.new(secret, payload, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, received_sig)

# Stripe-স্টাইল ওয়েবহুক যাচাই অনুকরণ
incoming_payload = b'{"event":"payment.completed","amount":4999}'
incoming_signature = "a1b2c3d4e5f6..."  # X-Signature হেডার থেকে
webhook_secret = b"whsec_9f3a7b2e1d4c"

if verify_webhook(incoming_payload, incoming_signature, webhook_secret):
    print("স্বাক্ষর বৈধ — ইভেন্ট প্রক্রিয়া করুন")
else:
    print("স্বাক্ষর অমিল — অনুরোধ প্রত্যাখ্যান করুন")

import hmac
import hashlib
import time

def sign_request(method: str, path: str, body: bytes, secret: bytes) -> str:
    """API অনুরোধের জন্য HMAC-SHA256 স্বাক্ষর তৈরি করুন।"""
    timestamp = str(int(time.time()))
    body_hash = hashlib.sha256(body).hexdigest()

    # ক্যানোনিকাল স্ট্রিং: method + path + timestamp + body hash
    canonical = f"{method}\n{path}\n{timestamp}\n{body_hash}"
    signature = hmac.new(secret, canonical.encode("utf-8"), hashlib.sha256).hexdigest()

    return f"ts={timestamp},sig={signature}"

# ব্যবহার
api_secret = b"sk_live_9f3a7b2e1d4c8a5b6e7f"
request_body = b'{"customer_id":"cust_4f2a","plan":"enterprise"}'
auth_header = sign_request("POST", "/api/v2/subscriptions", request_body, api_secret)
print(f"Authorization: HMAC-SHA256 {auth_header}")
# Authorization: HMAC-SHA256 ts=1741614120,sig=7d3f8c2a...

import hmac
import hashlib
import base64

secret = b"webhook_secret_9f3a"
message = b"POST /api/v2/events 1741614120"

# হেক্স আউটপুট: ৬৪ অক্ষর
hex_sig = hmac.new(secret, message, hashlib.sha256).hexdigest()
print(f"Hex:    {hex_sig}")

# Base64 আউটপুট: ৪৪ অক্ষর (ছোট, HTTP হেডারে সাধারণ)
raw_sig = hmac.new(secret, message, hashlib.sha256).digest()
b64_sig = base64.b64encode(raw_sig).decode("ascii")
print(f"Base64: {b64_sig}")

import hashlib
import uuid
from datetime import datetime, timezone

# datetime — বহনযোগ্যতার জন্য স্পষ্ট UTC অফসেট সহ ISO 8601 ব্যবহার করুন
event_time = datetime(2026, 3, 28, 12, 0, 0, tzinfo=timezone.utc)
time_hash = hashlib.sha256(event_time.isoformat().encode("utf-8")).hexdigest()
print(f"datetime hash: {time_hash[:16]}...")

# UUID — ক্যানোনিকাল স্ট্রিং রূপ হ্যাশ করুন (ছোট হাতে, হাইফেন সহ)
record_id = uuid.uuid4()
uuid_hash = hashlib.sha256(str(record_id).encode("utf-8")).hexdigest()
print(f"UUID hash: {uuid_hash[:16]}...")

import hashlib
import json
from dataclasses import dataclass, asdict

@dataclass
class Event:
    id: str
    type: str
    amount: int
    timestamp: str

def hash_event(event: Event) -> str:
    """নির্ধারণের জন্য বাছাই-চাবি JSON ব্যবহার করে dataclass উদাহরণ হ্যাশ করুন।"""
    canonical = json.dumps(asdict(event), sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()

e = Event(id="evt_4f2a", type="payment.completed", amount=4999, timestamp="2026-03-28T12:00:00Z")
print(hash_event(e))  # চালন ও মেশিন জুড়ে স্থিতিশীল

import hashlib

def sha256_checksum(filepath: str, chunk_size: int = 8192) -> str:
    """মেমোরি সাশ্রয়ে খণ্ডে পড়ে ফাইলের SHA-256 হ্যাশ গণনা করুন।"""
    h = hashlib.sha256()
    with open(filepath, "rb") as f:
        for chunk in iter(lambda: f.read(chunk_size), b""):
            h.update(chunk)
    return h.hexdigest()

# একটি রিলিজ আর্টিফ্যাক্ট হ্যাশ করুন
checksum = sha256_checksum("/tmp/release-v4.2.1.tar.gz")
print(f"SHA-256: {checksum}")

import hashlib

with open("/tmp/release-v4.2.1.tar.gz", "rb") as f:
    digest = hashlib.file_digest(f, "sha256")

print(digest.hexdigest())

import hashlib
import hmac as hmac_mod  # শুধু compare_digest-এর জন্য

def verify_checksum(filepath: str, expected_hex: str) -> bool:
    """ধ্রুবক-সময় তুলনা ব্যবহার করে SHA-256 চেকসাম যাচাই করুন।"""
    h = hashlib.sha256()
    with open(filepath, "rb") as f:
        for chunk in iter(lambda: f.read(8192), b""):
            h.update(chunk)
    return hmac_mod.compare_digest(h.hexdigest(), expected_hex.lower())

# একটি রিলিজ আর্টিফ্যাক্ট যাচাই করুন
expected = "a8f5f167f44f4964e6c998dee827110c3f1de4d0280c68cba98cf70b4b5157db"
if verify_checksum("/tmp/release-v4.2.1.tar.gz", expected):
    print("চেকসাম মিলেছে — ফাইল অক্ষুণ্ণ")
else:
    print("চেকসাম অমিল — ফাইল নষ্ট বা পরিবর্তিত হতে পারে")

import hashlib
import base64

data = b"integrity check payload"

# সঠিক: কাঁচা বাইটের Base64 (৩২ বাইট → ৪৪ Base64 অক্ষর)
raw_digest = hashlib.sha256(data).digest()
b64_digest = base64.b64encode(raw_digest).decode("ascii")
print(f"sha256-{b64_digest}")
# sha256-<44 characters>

# ভুল: হেক্স স্ট্রিংয়ের Base64 (৬৪ ASCII বাইট → ৮৮ Base64 অক্ষর — দ্বিগুণ আকার)
hex_digest = hashlib.sha256(data).hexdigest()
wrong = base64.b64encode(hex_digest.encode()).decode()
print(f"ভুল দৈর্ঘ্য: {len(wrong)} অক্ষর")  # 88 — API যা প্রত্যাশা করে তা নয়

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend

digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
digest.update(b"deployment-v4.2.1")
result = digest.finalize()  # কাঁচা ৩২ বাইট

print(result.hex())  # 64-char hex string
# a8f5f167f44f4964e6c998dee827110c3f1de4d0280c68cba98cf70b4b5157db

import hashlib
import sys

def hash_file_safe(filepath: str) -> str | None:
    """সঠিক ত্রুটি পরিচালনা সহ একটি ফাইল হ্যাশ করুন।"""
    try:
        h = hashlib.sha256()
        with open(filepath, "rb") as f:
            for chunk in iter(lambda: f.read(16384), b""):
                h.update(chunk)
        return h.hexdigest()
    except FileNotFoundError:
        print(f"ত্রুটি: {filepath} পাওয়া যায়নি", file=sys.stderr)
        return None
    except PermissionError:
        print(f"ত্রুটি: {filepath}-এর জন্য পড়ার অনুমতি নেই", file=sys.stderr)
        return None

result = hash_file_safe("/etc/nginx/nginx.conf")
if result:
    print(f"SHA-256: {result}")

import hashlib
import urllib.request
import json

def fetch_and_hash(url: str) -> tuple[dict, str]:
    """API থেকে JSON আনুন এবং ডেটা ও SHA-256 হ্যাশ উভয় ফেরত দিন।"""
    try:
        with urllib.request.urlopen(url, timeout=10) as resp:
            body = resp.read()
            content_hash = hashlib.sha256(body).hexdigest()
            data = json.loads(body)
            return data, content_hash
    except urllib.error.URLError as exc:
        raise ConnectionError(f"{url} আনতে ব্যর্থ: {exc}") from exc

# প্রতিক্রিয়া বিষয়বস্তুর উপর ভিত্তিক ক্যাশ কী
data, digest = fetch_and_hash("https://api.exchange.internal/v2/rates")
print(f"প্রতিক্রিয়া হ্যাশ: {digest[:16]}...")
print(f"EUR/USD: {data.get('rates', {}).get('EUR', 'N/A')}")

# Python ওয়ান-লাইনার
echo -n "deployment-v4.2.1" | python3 -c "import hashlib,sys; print(hashlib.sha256(sys.stdin.buffer.read()).hexdigest())"

# macOS / BSD
echo -n "deployment-v4.2.1" | shasum -a 256

# Linux (coreutils)
echo -n "deployment-v4.2.1" | sha256sum

# OpenSSL (ক্রস-প্ল্যাটফর্ম)
echo -n "deployment-v4.2.1" | openssl dgst -sha256

# একটি রিলিজ tarball হ্যাশ করুন
sha256sum release-v4.2.1.tar.gz
# অথবা
openssl dgst -sha256 release-v4.2.1.tar.gz

# পরিচিত চেকসামের বিরুদ্ধে যাচাই করুন
echo "a8f5f167f44f4964e6c998dee827110c release-v4.2.1.tar.gz" | sha256sum -c -
# release-v4.2.1.tar.gz: OK

pip install pycryptodome

from Crypto.Hash import SHA256

h = SHA256.new()
h.update(b"deployment-v4.2.1")
print(h.hexdigest())
# a8f5f167f44f4964e6c998dee827110c3f1de4d0280c68cba98cf70b4b5157db

import hashlib
import os
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor

def hash_file(path: Path) -> tuple[str, str]:
    """একটি ফাইল হ্যাশ করুন এবং (path, hex digest) ফেরত দিন।"""
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(65536), b""):  # 64 KB চাংক
            h.update(chunk)
    return str(path), h.hexdigest()

def hash_directory(directory: str, pattern: str = "*.tar.gz") -> dict[str, str]:
    """থ্রেড ব্যবহার করে সমান্তরালে সব মিলে যাওয়া ফাইল হ্যাশ করুন।"""
    files = list(Path(directory).glob(pattern))
    results = {}
    with ThreadPoolExecutor(max_workers=os.cpu_count()) as pool:
        for path, digest in pool.map(hash_file, files):
            results[path] = digest
    return results

# সমান্তরালে সব রিলিজ আর্টিফ্যাক্ট হ্যাশ করুন
checksums = hash_directory("/var/releases", "*.tar.gz")
for path, digest in checksums.items():
    print(f"{digest}  {path}")

pip install rich

import hashlib
from pathlib import Path
from rich.console import Console
from rich.table import Table

console = Console()

def hash_and_display(files: list[str], expected: dict[str, str]) -> None:
    """ফাইল হ্যাশ করুন এবং রঙ-কোড করা যাচাইয়ের ফলাফল প্রদর্শন করুন।"""
    table = Table(title="SHA-256 যাচাই")
    table.add_column("ফাইল", style="cyan")
    table.add_column("SHA-256", style="dim", max_width=20)
    table.add_column("স্ট্যাটাস")

    for filepath in files:
        h = hashlib.sha256()
        with open(filepath, "rb") as f:
            for chunk in iter(lambda: f.read(8192), b""):
                h.update(chunk)
        digest = h.hexdigest()

        name = Path(filepath).name
        status = "[green]✓ ঠিক আছে[/green]" if expected.get(name) == digest else "[red]✗ অমিল[/red]"
        table.add_row(name, f"{digest[:16]}...", status)

    console.print(table)

# ব্যবহার
expected_checksums = {
    "api-gateway-v3.1.tar.gz": "a8f5f167f44f4964...",
    "worker-v3.1.tar.gz": "7d3f8c2a1b9e4f5d...",
}
hash_and_display(
    ["/var/releases/api-gateway-v3.1.tar.gz", "/var/releases/worker-v3.1.tar.gz"],
    expected_checksums,
)

import hashlib
import os

def sha256_with_progress(filepath: str) -> str:
    """stderr-এ অগ্রগতি রিপোর্ট সহ একটি বড় ফাইল হ্যাশ করুন।"""
    file_size = os.path.getsize(filepath)
    h = hashlib.sha256()
    bytes_read = 0

    with open(filepath, "rb") as f:
        while chunk := f.read(1 << 20):  # 1 MB চাংক
            h.update(chunk)
            bytes_read += len(chunk)
            pct = (bytes_read / file_size) * 100
            print(f"\r  হ্যাশিং: {pct:.1f}% ({bytes_read >> 20} MB / {file_size >> 20} MB)",
                  end="", flush=True)

    print()  # অগ্রগতির পরে নিউলাইন
    return h.hexdigest()

digest = sha256_with_progress("/mnt/backups/db-snapshot-2026-03.sql.gz")
print(f"SHA-256: {digest}")

import hashlib
import json

def hash_ndjson_records(filepath: str) -> dict[str, str]:
    """নকল সনাক্তকরণের জন্য NDJSON ফাইলের প্রতিটি JSON রেকর্ড হ্যাশ করুন।"""
    seen = {}
    with open(filepath, "r", encoding="utf-8") as f:
        for line_num, line in enumerate(f, 1):
            line = line.strip()
            if not line:
                continue
            try:
                record = json.loads(line)
                # হ্যাশ করার আগে স্বাভাবিক করুন: নির্ধারিত আউটপুটের জন্য চাবি বাছাই
                canonical = json.dumps(record, sort_keys=True, separators=(",", ":"))
                digest = hashlib.sha256(canonical.encode("utf-8")).hexdigest()

                if digest in seen:
                    print(f"লাইন {line_num}: লাইন {seen[digest]}-এর নকল")
                else:
                    seen[digest] = line_num
            except json.JSONDecodeError:
                print(f"লাইন {line_num}: অবৈধ JSON, বাদ দেওয়া হয়েছে")

    print(f"{line_num} লাইন প্রক্রিয়া করা হয়েছে, {len(seen)} অনন্য রেকর্ড")
    return seen

hash_ndjson_records("telemetry-events-2026-03.ndjson")

# হ্যাশিং — একমুখী, মূল পুনরুদ্ধার করা যায় না
import hashlib
digest = hashlib.sha256(b"secret-config-value").hexdigest()
# digest থেকে "secret-config-value" ফিরে পাওয়ার কোনো উপায় নেই

# এনক্রিপশন — দ্বিমুখী, চাবি দিয়ে ডিক্রিপ্ট করা যায়
from cryptography.fernet import Fernet
key = Fernet.generate_key()
cipher = Fernet(key)
encrypted = cipher.encrypt(b"secret-config-value")
decrypted = cipher.decrypt(encrypted)
print(decrypted)  # b"secret-config-value" — মূল পুনরুদ্ধার হয়েছে

import re

def is_sha256_hex(value: str) -> bool:
    """একটি স্ট্রিং SHA-256 হেক্স ডাইজেস্ট ফরম্যাটের সাথে মিলে কিনা পরীক্ষা করুন।"""
    return bool(re.fullmatch(r"[a-fA-F0-9]{64}", value))

# পরীক্ষার ক্ষেত্র
print(is_sha256_hex("e3b0c44298fc1c149afbf4c8996fb924"
                     "27ae41e4649b934ca495991b7852b855"))  # True — খালি স্ট্রিংয়ের SHA-256
print(is_sha256_hex("e3b0c44298fc1c14"))                   # False — অনেক ছোট
print(is_sha256_hex("zzzz" * 16))                          # False — অবৈধ হেক্স অক্ষর