Python HMAC — hmac.new() SHA-256 গাইড ও কোড উদাহরণ

import hmac
import hashlib

key = b"webhook_signing_key_2026"
message = b'{"event":"invoice.paid","invoice_id":"inv_8f3a","amount":19900}'

# HMAC অবজেক্ট তৈরি করুন এবং হেক্স স্বাক্ষর পান
signature = hmac.new(key, message, hashlib.sha256).hexdigest()
print(signature)
# "b4e74f6c9a1d3e5f8b2a7c0d4e6f1a3b5c7d9e0f2a4b6c8d0e1f3a5b7c9d0e2f"

import hmac
import hashlib

key = b"service_auth_key"
msg = b"GET /api/v2/orders 2026-03-28T14:30:00Z"

h = hmac.new(key, msg, hashlib.sha256)

raw_bytes = h.digest()
print(type(raw_bytes), len(raw_bytes))
# <class 'bytes'> 32

hex_string = h.hexdigest()
print(type(hex_string), len(hex_string))
# <class 'str'> 64

# উভয় একই ডেটা উপস্থাপন করে — হেক্স শুধু bytes-এর স্ট্রিং এনকোডিং
assert raw_bytes.hex() == hex_string

import hmac
import hashlib

# স্ট্রিং চাবি ও বার্তা — .encode() UTF-8 bytes-এ রূপান্তর করে
api_key = "sk_live_9f3a2b7c4d8e"
request_body = '{"customer_id":"cust_4421","plan":"enterprise"}'

signature = hmac.new(
    api_key.encode(),
    request_body.encode(),
    hashlib.sha256
).hexdigest()

print(signature)
# "3a9f1b..."  — সামঞ্জস্যপূর্ণ হেক্স স্ট্রিং আউটপুট

import hmac
import hashlib
import base64

key = b"whsec_MbkP7x9yFqHGn3tRdWz5"
payload = b'{"id":"evt_1Nq","type":"charge.succeeded","data":{"amount":4200}}'

# কাঁচা ডাইজেস্ট → Base64 (Authorization হেডার ও ওয়েবহুক স্বাক্ষরের জন্য সাধারণ)
raw_digest = hmac.new(key, payload, hashlib.sha256).digest()
b64_signature = base64.b64encode(raw_digest).decode("ascii")

print(b64_signature)
# "dGhpcyBpcyBhIHNhbXBsZSBzaWduYXR1cmU="

# এটি X-Signature হেডারের সাথে তুলনার মান
header_value = f"sha256={b64_signature}"
print(header_value)
# "sha256=dGhpcyBpcyBhIHNhbXBsZSBzaWduYXR1cmU="

import hmac
import hashlib

consumer_secret = b"oauth_consumer_secret_2026"
token_secret = b"oauth_token_secret_2026"

# OAuth 1.0a consumer_secret&token_secret স্বাক্ষর চাবি হিসেবে ব্যবহার করে
signing_key = consumer_secret + b"&" + token_secret
base_string = b"GET&https%3A%2F%2Fapi.service.com%2Fv1%2Forders&oauth_nonce%3D7f3a91bc"

sig = hmac.new(signing_key, base_string, hashlib.sha1).digest()

import base64
oauth_signature = base64.b64encode(sig).decode("ascii")
print(oauth_signature)
# "Tza3R9sE..."  — Authorization হেডারের জন্য URL-এনকোড করুন

import hmac
import hashlib

key = b"high_security_signing_key_64_bytes_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
msg = b'{"transfer_id":"xfr_9c2e","amount":500000,"currency":"EUR"}'

h = hmac.new(key, msg, hashlib.sha512)

print(len(h.digest()))   # ৬৪ bytes (৫১২ বিট)
print(len(h.hexdigest()))  # ১২৮ হেক্স অক্ষর
print(h.hexdigest()[:40] + "...")
# "8e3a1f9b2c4d6e7f0a1b3c5d7e9f0a2b4c6d8e0f..."

import hmac
import hashlib

# MD5 ক্রিপ্টোগ্রাফিকভাবে ভাঙা — শুধুমাত্র পুরনো প্রোটোকল সামঞ্জস্যের জন্য ব্যবহার করুন
key = b"legacy_api_key"
msg = b"action=charge&amount=1500&merchant=store_42"

sig = hmac.new(key, msg, hashlib.md5).hexdigest()
print(sig)  # ৩২-অক্ষরের হেক্স স্ট্রিং
# "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6"

import hmac
import hashlib

key = b"batch_signing_key_2026"
messages = [
    b'{"order_id":"ord_001","total":4500}',
    b'{"order_id":"ord_002","total":8900}',
    b'{"order_id":"ord_003","total":2200}',
]

# এককালীন ডাইজেস্ট — মধ্যবর্তী HMAC অবজেক্ট নেই
signatures = [hmac.digest(key, msg, hashlib.sha256) for msg in messages]

# প্রদর্শনের জন্য হেক্সে রূপান্তর করুন
for msg, sig in zip(messages, signatures):
    print(f"{msg[:30]}... -> {sig.hex()[:24]}...")

import hmac
import hashlib
from flask import Flask, request, abort

app = Flask(__name__)
WEBHOOK_SECRET = b"whsec_MbkP7x9yFqHGn3tRdWz5"

@app.route("/webhooks/payments", methods=["POST"])
def handle_payment_webhook():
    # কাঁচা বডি পান — যা স্বাক্ষরিত হয়েছিল তার সাথে হুবহু মিলতে হবে
    raw_body = request.get_data()

    # হেডার থেকে স্বাক্ষর পান
    received_sig = request.headers.get("X-Signature-256", "")

    # কাঁচা বডির উপর HMAC পুনরায় গণনা করুন
    expected_sig = hmac.new(WEBHOOK_SECRET, raw_body, hashlib.sha256).hexdigest()

    # স্থির-সময় তুলনা — টাইমিং আক্রমণ প্রতিরোধ করে
    if not hmac.compare_digest(f"sha256={expected_sig}", received_sig):
        abort(403, "Invalid signature")

    # স্বাক্ষর যাচাই হয়েছে — ইভেন্ট প্রক্রিয়া করুন
    event = request.get_json()
    print(f"Verified event: {event['type']} for {event['data']['amount']}")
    return "", 200

import hmac
import hashlib
from flask import Flask, request, abort

app = Flask(__name__)
GITHUB_WEBHOOK_SECRET = b"your_github_webhook_secret"

@app.route("/webhooks/github", methods=["POST"])
def handle_github_webhook():
    # GitHub পাঠায়: X-Hub-Signature-256: sha256=<hex_digest>
    sig_header = request.headers.get("X-Hub-Signature-256", "")

    if not sig_header.startswith("sha256="):
        abort(403, "Missing or malformed signature header")

    received_hex = sig_header[len("sha256="):]
    raw_body = request.get_data()  # কাঁচা bytes — এর আগে JSON পার্স করবেন না

    expected_hex = hmac.new(
        GITHUB_WEBHOOK_SECRET, raw_body, hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(expected_hex, received_hex):
        abort(403, "Signature mismatch — payload may have been tampered with")

    event_type = request.headers.get("X-GitHub-Event", "unknown")
    payload = request.get_json()
    print(f"Verified GitHub {event_type} event: {payload.get('action', '')}")
    return "", 200

import hmac
import hashlib
import time
import json

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

    # স্বাক্ষর স্ট্রিং তৈরি করুন — method + path + timestamp + body
    signing_string = f"{method}\n{path}\n{timestamp}\n{body}"

    signature = hmac.new(
        secret,
        signing_string.encode(),
        hashlib.sha256
    ).hexdigest()

    return {
        "X-Timestamp": timestamp,
        "X-Signature": signature,
    }

# ব্যবহার
api_secret = b"sk_hmac_9f3a2b7c4d8e1a6f"
body = json.dumps({"customer_id": "cust_4421", "action": "suspend_account"})

headers = sign_request(api_secret, "POST", "/api/v2/customers/actions", body)
print(headers)
# {"X-Timestamp": "1711612200", "X-Signature": "a3f1b9c0..."}

import hmac
import hashlib
import time
import json
import requests

API_SECRET = b"sk_hmac_9f3a2b7c4d8e1a6f"
BASE_URL = "https://api.billing-service.internal"

def make_signed_request(method: str, path: str, payload: dict) -> requests.Response:
    body = json.dumps(payload, separators=(",", ":"))  # সংক্ষিপ্ত JSON, নির্ধারণীয়
    timestamp = str(int(time.time()))

    signing_string = f"{method}\n{path}\n{timestamp}\n{body}"
    signature = hmac.new(API_SECRET, signing_string.encode(), hashlib.sha256).hexdigest()

    headers = {
        "Content-Type": "application/json",
        "X-Timestamp": timestamp,
        "X-Signature": f"hmac-sha256={signature}",
    }

    try:
        return requests.request(method, f"{BASE_URL}{path}", data=body, headers=headers)
    except requests.RequestException as e:
        raise RuntimeError(f"Signed request failed: {e}") from e

# একটি স্বাক্ষরিত POST অনুরোধ পাঠান
resp = make_signed_request("POST", "/api/v2/invoices", {
    "customer_id": "cust_4421",
    "line_items": [
        {"description": "Pro plan - March 2026", "amount": 4900},
        {"description": "Extra seats (3)", "amount": 2100},
    ],
})
print(resp.status_code, resp.json())

python3 -c "
import hmac, hashlib
print(hmac.new(b'my_secret', b'message_to_sign', hashlib.sha256).hexdigest())
"
# আউটপুট: ৬৪-অক্ষরের হেক্স স্ট্রিং

echo -n "message_to_sign" | openssl dgst -sha256 -hmac "my_secret"
# SHA2-256(stdin)= 7d11...

# ফাইল openssl HMAC-এর মধ্যে দিয়ে পাস করুন
openssl dgst -sha256 -hmac "my_secret" < payload.json

# শেল ইতিহাস প্রকাশ এড়াতে চাবি env ভেরিয়েবলে সংরক্ষণ করুন
export HMAC_KEY="sk_live_9f3a2b"
echo -n '{"event":"test"}' | python3 -c "
import hmac, hashlib, sys, os
key = os.environ['HMAC_KEY'].encode()
msg = sys.stdin.buffer.read()
print(hmac.new(key, msg, hashlib.sha256).hexdigest())
"

pip install cryptography

from cryptography.hazmat.primitives import hashes, hmac as crypto_hmac

key = b"webhook_signing_key_2026"
message = b'{"event":"subscription.renewed","plan":"enterprise"}'

h = crypto_hmac.HMAC(key, hashes.SHA256())
h.update(message)
signature = h.finalize()  # কাঁচা bytes

print(signature.hex())
# "9c4e2a..."

# যাচাই মোড — অমিলে InvalidSignature উত্থাপন করে
h_verify = crypto_hmac.HMAC(key, hashes.SHA256())
h_verify.update(message)
h_verify.verify(signature)  # ভুল হলে cryptography.exceptions.InvalidSignature উত্থাপন করে

pip install rich

import hmac
import hashlib
from rich.console import Console
from rich.table import Table

console = Console()

key = b"debug_signing_key"
messages = {
    "/api/v2/orders": b'{"status":"active"}',
    "/api/v2/invoices": b'{"status":"pending"}',
    "/api/v2/customers": b'{"status":"verified"}',
}

table = Table(title="HMAC-SHA256 Signatures")
table.add_column("Endpoint", style="cyan")
table.add_column("Signature (first 32 chars)", style="green")

for endpoint, body in messages.items():
    sig = hmac.new(key, body, hashlib.sha256).hexdigest()
    table.add_row(endpoint, sig[:32] + "...")

console.print(table)

import hmac
import hashlib

def hmac_file(key: bytes, filepath: str, chunk_size: int = 8192) -> str:
    """পুরো ফাইল মেমোরিতে না নিয়ে HMAC-SHA256 গণনা করুন।"""
    h = hmac.new(key, digestmod=hashlib.sha256)

    try:
        with open(filepath, "rb") as f:
            while True:
                chunk = f.read(chunk_size)
                if not chunk:
                    break
                h.update(chunk)
    except OSError as e:
        raise OSError(f"Cannot read file '{filepath}': {e}") from e

    return h.hexdigest()

# ২ GB ডেটাবেস এক্সপোর্ট স্বাক্ষর করুন
signing_key = b"backup_integrity_key_2026"
signature = hmac_file(signing_key, "/var/backups/db-export-2026-03.sql.gz")
print(f"HMAC-SHA256: {signature}")

import hmac
import hashlib

def verify_file_hmac(key: bytes, filepath: str, expected_hex: str) -> bool:
    """ফাইলের HMAC-SHA256 স্বাক্ষর যাচাই করুন।"""
    h = hmac.new(key, digestmod=hashlib.sha256)

    with open(filepath, "rb") as f:
        for chunk in iter(lambda: f.read(65536), b""):
            h.update(chunk)

    return hmac.compare_digest(h.hexdigest(), expected_hex)

# ডাউনলোড করা আর্টিফ্যাক্ট যাচাই করুন
is_valid = verify_file_hmac(
    key=b"release_signing_key",
    filepath="/tmp/release-v3.2.0.tar.gz",
    expected_hex="8e3a1f9b2c4d6e7f0a1b3c5d7e9f0a2b4c6d8e0f1a2b3c4d5e6f7a8b9c0d1e2f",
)
print(f"File integrity: {'valid' if is_valid else 'CORRUPTED'}")

import secrets

# হ্যাশ অ্যালগরিদমের ব্লক আকারের সাথে মিলিয়ে চাবি তৈরি করুন
sha256_key = secrets.token_bytes(32)   # ২৫৬ বিট — HMAC-SHA256-এর জন্য
sha512_key = secrets.token_bytes(64)   # ৫১২ বিট — HMAC-SHA512-এর জন্য

# হেক্স উপস্থাপনা — কনফিগ ফাইল ও এনভায়রনমেন্ট ভেরিয়েবলের জন্য নিরাপদ
print(f"HMAC-SHA256 key: {sha256_key.hex()}")
# যেমন "a3f1b9c04e7d2f8a1b3c5d7e9f0a2b4c6d8e0f1a2b3c4d5e6f7a8b9c0d1e2f"

print(f"HMAC-SHA512 key: {sha512_key.hex()}")
# ১২৮-অক্ষরের হেক্স স্ট্রিং

# URL-নিরাপদ Base64 — সংক্ষিপ্ত, HTTP হেডারের জন্য নিরাপদ
import base64
b64_key = base64.urlsafe_b64encode(sha256_key).decode("ascii")
print(f"Base64 key: {b64_key}")
# যেমন "o_G5wE59L4obPF1-nwortG2ODwobPExdXnqLnA0dLi8="

import hmac
import hashlib

# bytearray — পরিবর্তনযোগ্য bytes, বাইনারি প্রোটোকল বাফারের জন্য উপযোগী
key = bytearray(b"protocol_signing_key")
frame = bytearray(b'\x01\x02\x03\x04payload_data_here')

sig = hmac.new(key, frame, hashlib.sha256).hexdigest()
print(f"Frame signature: {sig[:32]}...")

# memoryview — বড় বাফারের শূন্য-কপি স্লাইস
large_buffer = bytearray(4096)
large_buffer[:20] = b"sensor_reading_12345"

# কপি না করে শুধু প্রথম ২০ bytes-এর HMAC করুন
view = memoryview(large_buffer)[:20]
sig = hmac.new(key, view, hashlib.sha256).hexdigest()
print(f"Sensor signature: {sig[:32]}...")