Python SHA-256 Hashing — hashlib Rehberi

Dmitri Volkov·DevOps Engineer & Python Automation Specialist·İnceleyenMaria Santos·Yayınlandı 2026-03-28

Ücretsiz SHA-256 Hash Üreticisi aracını doğrudan tarayıcınızda kullanın — kurulum gerektirmez.

Kurduğum her dağıtım pipeline'ı bir noktada dosya checksum'ını doğrulamak, webhook yükünü imzalamak veya önbellek anahtarını parmak iziyle tanımlamak zorunda kalmıştır. Python SHA-256 hashleme, yerleşik hashlib modülüyle bu durumların tümünü karşılar — ve zaten kurulu gelir. hashlib.sha256() CPython üzerinde OpenSSL uygulamasını sarmaladığından hızlı ve kutudan çıkar çıkmaz FIPS uyumludur. Kod yazmadan hızlı bir hash için çevrimiçi SHA-256 hash üreticisi sonucu anında verir. Tüm örnekler Python 3.9+ hedefler.

✓hashlib.sha256(data).hexdigest() baytları hashlemek için standart yoldur — stdlib'in parçasıdır ve OpenSSL tarafından desteklenir.
✓Dizeler önce bayta kodlanmalıdır: hashlib.sha256("metin".encode("utf-8")).
✓Dosya checksum'ları için .update() ile parça parça besleyin — büyük bir dosyayı tek seferde belleğe yüklemeyin.
✓HMAC-SHA256 için hmac modülü gereklidir: hmac.new(key, msg, hashlib.sha256) — SHA-256'nın tek başına anahtarı yoktur.

SHA-256 Hashleme Nedir?

SHA-256 (Güvenli Hash Algoritması, 256-bit) keyfi uzunluktaki bir girdiyi alır ve sabit 256-bit (32 bayt) özet üretir. Aynı girdi her zaman aynı çıktıyı verir, ancak girdideki tek bitlik değişiklik bile tamamen farklı bir hash üretir — bu özelliğe çığ etkisi denir. SHA-256, SHA-2 ailesinin parçasıdır, NIST tarafından standardize edilmiştir ve TLS sertifika parmak izlerinin, Git commit kimliklerinin, Bitcoin blok başlıklarının ve dosya bütünlüğü doğrulamasının temelini oluşturur. Algoritma, 256-bit çıktısını üretmek için 64 sıkıştırma turuyla Merkle-Damgård yapısı kullanır.

Before · text

After · text

deployment-v4.2.1

a1f7c3d8e9b2...27ae41e4649b (64 hex karakter)

Yukarıdaki hex özeti standart gösterimdir — tek bir baytı veya tüm disk görüntüsünü hashlemenizden bağımsız olarak her zaman aynı uzunlukta 64 hexadecimal karakterden oluşur.

hashlib.sha256() — Standart Kütüphane Yaklaşımı

hashlib modülü her Python kurulumunda mevcuttur — pip install gerekmez. hashlib.sha256() fonksiyonunu bir bytes argümanıyla çağırarak hash nesnesi oluşturun, ardından .hexdigest() (hex dizisi) veya .digest() (ham baytlar) ile sonucu alın. Fonksiyon adı küçük harftir: sha256,SHA256 değil.

Python 3.9+ — minimal SHA-256 hash

import hashlib

# Bir bayt dizisini doğrudan hashle
digest = hashlib.sha256(b"deployment-v4.2.1").hexdigest()
print(digest)
# a8f5f167f44f4964e6c998dee827110c3f1de4d0280c68cba98cf70b4b5157db

hashlib.sha256() ile yapılan en yaygın hata, bytes yerine str geçirmektir. Python dizeleri Unicode'dur ve hash fonksiyonları ham baytlar üzerinde çalışır. Hashleme öncesinde .encode("utf-8") çağırmalısınız. Bu neredeyse herkesi ilk seferinde yanıltır.

Python 3.9+ — bir dizeyi hashleme

import hashlib

# Dizeler hashlenmeden önce bayta kodlanmalıdır
config_key = "redis://cache.internal:6379/0"
digest = hashlib.sha256(config_key.encode("utf-8")).hexdigest()
print(digest)
# 7d3f8c2a1b9e4f5d6c8a7b3e2f1d9c4a5b8e7f6d3c2a1b9e4f5d6c8a7b3e2f1d

.update() metodu veriyi artımlı olarak beslemenizi sağlar. h.update(a); h.update(b) çağrısı, hashlib.sha256(a + b) ile eşdeğerdir. Dosyaları tüm içeriklerini belleğe yüklemeden parça parça hashlemek bu şekilde yapılır.

Python 3.9+ — update() ile artımlı hashleme

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() ile eşdeğer

Not:.digest() ham 32 bayt döndürür. .hexdigest()64 karakterlik hex dizisi döndürür. Sonucu HMAC'e beslerken, Base64 kodlarken veya ikili protokollere yazarken .digest() kullanın. Günlük kaydı, veritabanı sütunları ve checksum karşılaştırması için .hexdigest() tercih edin.

HMAC-SHA256 — hmac Modülü ile Anahtarlı Hashleme

SHA-256'nın tek başına gizli anahtar kavramı yoktur — aynı girdiye sahip herkes aynı hash'i hesaplayabilir. Bir mesajın belirli bir göndericiden geldiğini kanıtlamanız gerekiyorsa (webhook doğrulama, API isteği imzalama, token kimlik doğrulama), HMAC gereklidir. hmac modülü Python'un standart kütüphanesinin parçasıdır ve anahtarı hashleme sürecine dahil ederek yalnızca anahtara sahip birinin aynı özeti üretebilmesini veya doğrulayabilmesini sağlar.

Python 3.9+ — temel HMAC-SHA256

import hmac
import hashlib

# Webhook imzası doğrulama
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 karakterlik hex HMAC-SHA256 özeti

Gelen bir HMAC'i doğrulamak için == operatörü yerine hmac.compare_digest() kullanılmalıdır. Eşitlik operatörü ilk uyumsuz baytta kısa devre yapar ve saldırgan, doğru imzayı bayt bayt tahmin etmek için yanıt sürelerini ölçebilir. compare_digest() uyumsuzluğun nerede gerçekleştiğinden bağımsız olarak sabit sürede çalışır.

Python 3.9+ — webhook imzasını doğrula

import hmac
import hashlib

def verify_webhook(payload: bytes, received_sig: str, secret: bytes) -> bool:
    """Sabit zamanlı karşılaştırma kullanarak webhook imzasını doğrula."""
    expected = hmac.new(secret, payload, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, received_sig)

# Stripe tarzı webhook doğrulaması simülasyonu
incoming_payload = b'{"event":"payment.completed","amount":4999}'
incoming_signature = "a1b2c3d4e5f6..."  # X-Signature başlığından
webhook_secret = b"whsec_9f3a7b2e1d4c"

if verify_webhook(incoming_payload, incoming_signature, webhook_secret):
    print("İmza geçerli — olayı işle")
else:
    print("İmza uyuşmazlığı — isteği reddet")

HMAC-SHA256 ile API İsteği İmzalama

API isteği imzalama aynı prensibe dayanır: istek bileşenlerinden (yöntem, yol, zaman damgası, gövde hash'i) kanonik bir dize oluşturun ve gizli anahtarınızla imzalayın. AWS Signature V4, Stripe ve GitHub webhook'ları bu kalıbın çeşitlerini kullanır.

Python 3.9+ — HMAC-SHA256 ile API isteği imzala

import hmac
import hashlib
import time

def sign_request(method: str, path: str, body: bytes, secret: bytes) -> str:
    """API isteği için HMAC-SHA256 imzası oluştur."""
    timestamp = str(int(time.time()))
    body_hash = hashlib.sha256(body).hexdigest()

    # Kanonik dize: yöntem + yol + zaman damgası + gövde hash'i
    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}"

# Kullanım
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...

Base64 Kodlu HMAC-SHA256

Bazı API'ler (AWS Signature V4, çeşitli ödeme ağ geçitleri) HMAC sonucunu hex yerine Base64 kodlu dize olarak bekler. Fark şudur: hex 64 karakter kullanırken Base64 aynı 32 baytlık özet için 44 karakter kullanır.

Python 3.9+ — Base64 kodlu HMAC-SHA256

import hmac
import hashlib
import base64

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

# Hex çıktı: 64 karakter
hex_sig = hmac.new(secret, message, hashlib.sha256).hexdigest()
print(f"Hex:    {hex_sig}")

# Base64 çıktı: 44 karakter (daha kısa, HTTP başlıklarında yaygın)
raw_sig = hmac.new(secret, message, hashlib.sha256).digest()
b64_sig = base64.b64encode(raw_sig).decode("ascii")
print(f"Base64: {b64_sig}")

datetime, UUID ve Özel Nesneleri Hashleme

SHA-256 ham baytlar üzerinde çalışır; bu nedenle bytes olmayan türler — datetime, UUID, dataclass'lar, Pydantic modelleri — hashlenmeden önce bayta dönüştürülmelidir. Otomatik dönüşüm yoktur; kanonik gösterimi siz seçersiniz. Sistemler arası deterministik hashleme için her zaman açık bir kodlama ve kararlı bir serileştirme biçimi kullanın (datetime için ISO 8601, UUID'ler için standart dize biçimi, sözlükler için anahtarı sıralanmış JSON).

Python 3.9+ — datetime ve UUID hashleme

import hashlib
import uuid
from datetime import datetime, timezone

# datetime — taşınabilirlik için açık UTC ofseti ile ISO 8601 kullanın
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 — kanonik dize biçimini (küçük harf, kısa çizgili) hashle
record_id = uuid.uuid4()
uuid_hash = hashlib.sha256(str(record_id).encode("utf-8")).hexdigest()
print(f"UUID hash: {uuid_hash[:16]}...")

Özel nesneler için hashleme öncesinde kanonik bayt gösterimine serileştirin. Sözlük benzeri nesneler için anahtarı sıralanmış JSON iyi sonuç verir:

Python 3.9+ — özel nesneyi hashleme

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:
    """Determinizm için anahtarı sıralanmış JSON kullanarak dataclass örneğini hashle."""
    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))  # çalıştırmalar ve makineler arasında kararlı

Not:JSON serileştirilen nesneleri hashlerken her zaman dict anahtarlarını sıralayın (sort_keys=True). Dict ekleme sırası Python 3.7+'da korunur ancak serileştirme yolları arasında farklılık gösterebilir ve özdeş veriler için farklı hash değerleri üretir.

SHA-256 Dosya Checksum — İndirmeleri ve Artifaktları Doğrulayın

Bir dosyanın SHA-256 checksum'ını hesaplamak algoritmanın en yaygın kullanımlarından biridir. Bunu her yerde görürsünüz: Go binary'leri için yayın sayfaları, Python wheel dosyaları, Docker görüntü manifestoleri, firmware güncellemeleri. Temel nokta dosyayı tek seferde yüklemek yerine parçalar halinde okumaktır — 2 GB'lık bir ISO görüntüsü sadece hashlenebilmesi için 2 GB RAM gerektirmemelidir.

Python 3.9+ — dosyanın SHA-256 checksum'ı (parçalı)

import hashlib

def sha256_checksum(filepath: str, chunk_size: int = 8192) -> str:
    """Belleği korumak için parça parça okuyarak dosyanın SHA-256 hash'ini hesapla."""
    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()

# Yayın artifaktını hashle
checksum = sha256_checksum("/tmp/release-v4.2.1.tar.gz")
print(f"SHA-256: {checksum}")

Python 3.11, hashlib.file_digest() fonksiyonunu ekledi; bu fonksiyon parçalı okumayı dahili olarak yapar ve desteklenen platformlarda sıfır kopya optimizasyonları kullanabilir. 3.11 veya sonrasındaysanız manuel döngü yerine bunu tercih edin.

Python 3.11+ — hashlib.file_digest()

import hashlib

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

print(digest.hexdigest())

İndirilen Dosyayı Bilinen Checksum ile Doğrula

Python 3.9+ — checksum doğrulama

import hashlib
import hmac as hmac_mod  # yalnızca compare_digest için

def verify_checksum(filepath: str, expected_hex: str) -> bool:
    """Sabit zamanlı karşılaştırma kullanarak SHA-256 checksum'ını doğrula."""
    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())

# Yayın artifaktını doğrula
expected = "a8f5f167f44f4964e6c998dee827110c3f1de4d0280c68cba98cf70b4b5157db"
if verify_checksum("/tmp/release-v4.2.1.tar.gz", expected):
    print("Checksum eşleşiyor — dosya sağlam")
else:
    print("Checksum uyuşmazlığı — dosya bozulmuş veya değiştirilmiş olabilir")

Not:Gizli anahtar olmasa bile checksum karşılaştırması için her zaman hmac.compare_digest() kullanın. Sabit zamanlı karşılaştırma zamanlama tabanlı bilgi sızıntısını önler. == operatörü işlevsel olarak çalışır ancak güvenlik açısından kritik bağlamlarda güvenli değildir.

Base64 Kodlama ile SHA-256

Bazı protokoller SHA-256 özetini hex yerine Base64 dizisi olarak bekler. Content-Digest ve Integrity (tarayıcılarda Subresource Integrity) gibi HTTP başlıkları Base64 kullanır ve JWT imzaları Base64url kodludur. Püf nokta, hex dizisi değil ham .digest() baytlarını Base64'e kodlamaktır.

Python 3.9+ — Base64 kodlu SHA-256

import hashlib
import base64

data = b"integrity check payload"

# Doğru: ham baytların Base64'ü (32 bayt → 44 Base64 karakter)
raw_digest = hashlib.sha256(data).digest()
b64_digest = base64.b64encode(raw_digest).decode("ascii")
print(f"sha256-{b64_digest}")
# sha256-<44 karakter>

# Yanlış: hex dizisinin Base64'ü (64 ASCII bayt → 88 Base64 karakter — iki kat büyük)
hex_digest = hashlib.sha256(data).hexdigest()
wrong = base64.b64encode(hex_digest.encode()).decode()
print(f"Yanlış uzunluk: {len(wrong)} karakter")  # 88 — API'lerin beklediği bu değil

Uyarı:Hex dizisini ham baytlar yerine Base64 kodlamak, beklenen uzunluğun iki katı olan bir çıktı üretir. API'ler bunu reddeder ve hata mesajı genellikle nedenini belirtmez. Base64 kodlamadan önce her zaman .hexdigest() değil .digest() çağırın.

hashlib.sha256() Referansı

SHA-256 hash nesnesi üzerindeki yapıcı ve metotlar:

Parametre / Metot

Tür

Açıklama

data (konumsal)

bytes

Hashlenecek başlangıç verisi — nesne oluşturulduktan hemen sonra update(data) çağrısına eşdeğer

.update(data)

bytes

Hash durumuna ek bayt besler — parçalı girdi için birden fazla kez çağrılabilir

.digest()

→ bytes

Ham 32 baytlık ikili özeti döndürür — HMAC girdileri, ikili protokoller ve Base64 kodlama için kullanılır

.hexdigest()

→ str

64 karakterlik küçük harfli hex dizisini döndürür — checksum ve doğrulama için standart gösterim

.copy()

→ hash nesnesi

Geçerli hash durumunun bir klonunu döndürür — sıfırdan yeniden hashleme olmadan özeti dallandırmanızı sağlar

hashlib.sha256()

yapıcı

CPython üzerinde OpenSSL destekli yeni bir SHA-256 hash nesnesi oluşturur — 3.9+ sürümünde usedfips=True, FIPS onaylı algoritmaları kısıtlar

Anahtarlı hashleme için hmac.new() parametreleri:

Parametre

Tür

Açıklama

key

bytes

Gizli anahtar — str değil bytes türünde olmalıdır

msg

bytes | None

Doğrulanacak başlangıç mesajı — varsayılan olarak None, daha sonra update() çağrılabilir

digestmod

str | callable

Hash algoritması: hashlib.sha256 veya "sha256" dizisini geçin

cryptography Kütüphanesi — Alternatif SHA-256 API

cryptography paketi, hazmat ilkellerini kullanarak SHA-256 için farklı bir API sunar. Yalnızca hash ihtiyacım olduğunda bunu pek tercih etmem — hashlib daha basittir ve harici bağımlılık gerektirmez. Ancak projeniz TLS, X.509 veya simetrik şifreleme için zaten cryptography'ye bağımlıysa, hash API'sini de kullanmak her şeyi tek kütüphane altında toplar ve tutarlı hata işleme sağlar.

Python 3.9+ — cryptography kütüphanesi ile SHA-256

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()  # ham 32 bayt

print(result.hex())  # 64 karakterlik hex dizisi
# a8f5f167f44f4964e6c998dee827110c3f1de4d0280c68cba98cf70b4b5157db

Uyarı:cryptography kütüphanesi pip install cryptography gerektirir. Hash nesnesi tek kullanımlıktır: ikinci kez .finalize() çağrısı AlreadyFinalized hatası fırlatır. Hash durumunu dallandırmanız gerekiyorsa finalize etmeden önce .copy() kullanın.

Dosya ve API Yanıtından Veri Hashleme

İki senaryo sürekli karşıma çıkar: yayın artifaktını doğrulamak için diskteki bir dosyayı hashlemek ve önbellek anahtarı olarak kullanmak veya webhook'u doğrulamak için HTTP yanıt gövdesini hashlemek.

Dosyayı Oku → SHA-256 Hesapla → Karşılaştır

Python 3.9+ — hata yönetimiyle yapılandırma yedeğini hashle

import hashlib
import sys

def hash_file_safe(filepath: str) -> str | None:
    """Uygun hata yönetimiyle dosyayı hashle."""
    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"Hata: {filepath} bulunamadı", file=sys.stderr)
        return None
    except PermissionError:
        print(f"Hata: {filepath} için okuma izni yok", file=sys.stderr)
        return None

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

HTTP Yanıtı → Önbellek Anahtarı için Gövdeyi Hashle

Python 3.9+ — API yanıtını hashle

import hashlib
import urllib.request
import json

def fetch_and_hash(url: str) -> tuple[dict, str]:
    """API'den JSON al ve hem veriyi hem de SHA-256 hash'ini döndür."""
    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} alınamadı: {exc}") from exc

# Yanıt içeriğine dayalı önbellek anahtarı
data, digest = fetch_and_hash("https://api.exchange.internal/v2/rates")
print(f"Yanıt hash'i: {digest[:16]}...")
print(f"EUR/USD: {data.get('rates', {}).get('EUR', 'N/A')}")

Hızlı tek seferlik bir kontrol için ToolDeck'in SHA-256 üreticisi tamamen tarayıcınızda çalışır — kod gerekmez.

Komut Satırından SHA-256 Hashleme

Bazen bir olay veya dağıtım sırasında terminalde hızlı hash almanız gerekir. Python'un hashlib modülünün yerleşik CLI alt komutu yoktur (python3 -m json.tool'un aksine), ancak tek satırlık komut veya sistem araçlarını kullanabilirsiniz.

bash — komut satırından dize hashleme

# Python tek satırlık komut
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 (çok platformlu)
echo -n "deployment-v4.2.1" | openssl dgst -sha256

bash — dosya hashleme

# Yayın tarball'ını hashle
sha256sum release-v4.2.1.tar.gz
# veya
openssl dgst -sha256 release-v4.2.1.tar.gz

# Bilinen checksum ile doğrula
echo "a8f5f167f44f4964e6c998dee827110c release-v4.2.1.tar.gz" | sha256sum -c -
# release-v4.2.1.tar.gz: OK

Not:Komut satırında dizeleri hashlerken her zaman echo -n (sonda satır sonu olmadan) kullanın. Sıradan bir echo \n ekler ve hash değişir. Bu, insanların Python ile kabuk arasında farklı hash elde etmesinin bir numaralı nedenidir.

Yüksek Performanslı Alternatif — OpenSSL ile hashlib ve pycryptodome

CPython'da hashlib.sha256() zaten OpenSSL'in C uygulamasına yetki devreder, dolayısıyla hızlıdır — modern donanımda genellikle 500+ MB/s.

SHA-256 hashleme profil ölçümünüzde görünüyorsa — örneğin CI pipeline'ında binlerce dosya için checksum hesaplıyor ya da yüksek hacimli API ağ geçidinde her istek gövdesini hashliyorsanız — iki seçenek vardır: hashlib çağırma kalıbını optimize edin ya da SHA-3 ve BLAKE2'yi de kapsayan birleşik bir kripto API'si için pycryptodome'a geçin:

bash — pycryptodome kur

pip install pycryptodome

Python 3.9+ — pycryptodome ile SHA-256

from Crypto.Hash import SHA256

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

Yüksek hacimli paralel dosya hashleme için daha büyük kazanımlar, daha büyük parça boyutları ve threading ile Python ek yükünü azaltmaktan gelir:

Python 3.9+ — hashlib ile toplu dosya hashleme

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

def hash_file(path: Path) -> tuple[str, str]:
    """Tek bir dosyayı hashle ve (yol, hex özet) döndür."""
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(65536), b""):  # 64 KB parçalar
            h.update(chunk)
    return str(path), h.hexdigest()

def hash_directory(directory: str, pattern: str = "*.tar.gz") -> dict[str, str]:
    """Thread kullanarak eşleşen tüm dosyaları paralelde hashle."""
    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

# Tüm yayın artifaktlarını paralelde hashle
checksums = hash_directory("/var/releases", "*.tar.gz")
for path, digest in checksums.items():
    print(f"{digest}  {path}")

8 KB yerine 64 KB parçalar kullanmak Python'dan C'ye yapılan çağrıları 8 kat azaltır. C düzeyinde hashleme sırasında GIL serbest bırakıldığından thread'ler burada iyi sonuç verir — darboğaz CPU değil disk G/Ç'dir.

Söz Dizimi Vurgulamalı Terminal Çıktısı

rich kütüphanesi, bir dosya grubunu doğrulamanız ve ham hex çıktısı yerine dosya başına geçti/kaldı durumunu gösteren bir tablo istediğinizde işe yarar.

bash — rich kur

pip install rich

Python 3.9+ — hash doğrulama için rich çıktısı

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:
    """Dosyaları hashle ve renk kodlu doğrulama ile sonuçları göster."""
    table = Table(title="SHA-256 Doğrulama")
    table.add_column("Dosya", style="cyan")
    table.add_column("SHA-256", style="dim", max_width=20)
    table.add_column("Durum")

    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]✓ OK[/green]" if expected.get(name) == digest else "[red]✗ UYUŞMAZLIK[/red]"
        table.add_row(name, f"{digest[:16]}...", status)

    console.print(table)

# Kullanım
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,
)

Not:Rich çıktısı yalnızca terminal görüntüsü içindir. Log dosyalarına veya API yanıtlarına ANSI kaçış kodları yazmayın — bunları console.print(data, highlight=False) ile kaldırın ya da Console(file=open(...)) ile dosyaya yönlendirin.

Büyük Dosyalarla Çalışma

Parçalı .update() kalıbı, her boyuttaki dosyayı sabit bellek kullanımıyla işler. Çok büyük dosyalarda (çok GB'lık disk görüntüleri, veritabanı yedekleri) ana endişe bellekten kullanıcı geri bildirime kayar — 500 MB/s hızında 10 GB'ı hashlemek 20 saniye sürer ve bu süredeki sessizlik insanları tedirgin eder.

Python 3.9+ — ilerleme bildirimiyle büyük dosya hashleme

import hashlib
import os

def sha256_with_progress(filepath: str) -> str:
    """Stderr'e ilerleme bildirerek büyük dosyayı hashle."""
    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 parçalar
            h.update(chunk)
            bytes_read += len(chunk)
            pct = (bytes_read / file_size) * 100
            print(f"\r  Hashleniyor: {pct:.1f}% ({bytes_read >> 20} MB / {file_size >> 20} MB)",
                  end="", flush=True)

    print()  # ilerleme sonrası yeni satır
    return h.hexdigest()

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

NDJSON / JSON Lines — Her Kaydı Ayrı Ayrı Hashleme

Python 3.9+ — NDJSON akışındaki her kaydı hashle

import hashlib
import json

def hash_ndjson_records(filepath: str) -> dict[str, str]:
    """Yinelenen kayıtları tespit etmek için NDJSON dosyasındaki her JSON kaydını hashle."""
    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)
                # Hashleme öncesi normalize et: deterministik çıktı için anahtarları sırala
                canonical = json.dumps(record, sort_keys=True, separators=(",", ":"))
                digest = hashlib.sha256(canonical.encode("utf-8")).hexdigest()

                if digest in seen:
                    print(f"Satır {line_num}: {seen[digest]}. satırın kopyası")
                else:
                    seen[digest] = line_num
            except json.JSONDecodeError:
                print(f"Satır {line_num}: geçersiz JSON, atlandı")

    print(f"{line_num} satır işlendi, {len(seen)} benzersiz kayıt")
    return seen

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

Not:Dosyalar 50–100 MB'ı aştığında basit hashlib.sha256(data) tek seferlik kullanımdan parçalı .update() döngüsüne geçin. Bu eşiğin altında tüm dosyayı f.read() ile okumak sorunsuzdur — bellek kullanımı yaklaşık dosya boyutuna eşit olacaktır.

Yaygın Hatalar

❌ hashlib.sha256()'a bytes yerine str geçirme

Sorun: hashlib.sha256('metin') TypeError fırlatır: Unicode nesneleri hashlenmeden önce kodlanmalıdır. Fonksiyon str değil bytes gerektirir.

Çözüm: Önce dizeyi kodlayın: hashlib.sha256('metin'.encode('utf-8')). Sabit kodlanmış değerler için b'' literali kullanın.

Before · Python

After · Python

import hashlib
digest = hashlib.sha256("deployment-v4.2.1").hexdigest()
# TypeError: Unicode nesneleri hashlenmeden önce kodlanmalıdır

import hashlib
digest = hashlib.sha256("deployment-v4.2.1".encode("utf-8")).hexdigest()
# Çalışır — 64 karakterlik hex dizisi döndürür

❌ İmza doğrulama için hmac.compare_digest() yerine == kullanma

Sorun: == operatörü ilk uyumsuz baytta kısa devre yapar. Saldırgan, yanıt süresini ölçerek doğru imzayı bayt bayt tahmin edebilir.

Çözüm: Tüm güvenlik açısından kritik karşılaştırmalar için hmac.compare_digest() kullanın — uyumsuzluğun nerede gerçekleştiğinden bağımsız olarak sabit sürede çalışır.

Before · Python

After · Python

received_sig = request.headers["X-Signature"]
expected_sig = hmac.new(key, body, hashlib.sha256).hexdigest()
if received_sig == expected_sig:  # zamanlama saldırısına açık
    process_webhook(body)

received_sig = request.headers["X-Signature"]
expected_sig = hmac.new(key, body, hashlib.sha256).hexdigest()
if hmac.compare_digest(received_sig, expected_sig):  # sabit zamanlı
    process_webhook(body)

❌ Ham baytlar yerine hex dizisini Base64 kodlama

Sorun: base64.b64encode(digest.hexdigest().encode()) beklenen 44 karakterin iki katı olan 88 karakterlik dizi üretir. Base64 kodlu SHA-256 bekleyen API'ler bunu reddeder.

Çözüm: Base64 kodlamadan önce .hexdigest() (hex dizisi) değil .digest() (ham baytlar) çağırın.

Before · Python

After · Python

import hashlib, base64
hex_str = hashlib.sha256(data).hexdigest()
b64 = base64.b64encode(hex_str.encode())  # 88 karakter — yanlış!

import hashlib, base64
raw = hashlib.sha256(data).digest()
b64 = base64.b64encode(raw)  # 44 karakter — doğru

❌ Hashleme öncesinde büyük dosyanın tamamını belleğe okuma

Sorun: hashlib.sha256(open('large.iso', 'rb').read()) tüm dosyayı belleğe yükler. 4 GB'lık dosya yalnızca hash hesaplaması için 4 GB RAM gerektirir.

Çözüm: Döngü ve .update() ile parça parça okuyun. Bellek kullanımı dosya boyutundan bağımsız olarak sabit kalır.

Before · Python

After · Python

import hashlib
# 4 GB'lık dosyanın tamamını belleğe yükler
digest = hashlib.sha256(open("disk.iso", "rb").read()).hexdigest()

import hashlib
h = hashlib.sha256()
with open("disk.iso", "rb") as f:
    for chunk in iter(lambda: f.read(8192), b""):
        h.update(chunk)
digest = h.hexdigest()  # sabit bellek kullanımı

hashlib vs hmac vs Alternatifler — Hızlı Karşılaştırma

Yöntem

Çıktı

Anahtarlı

Hız

Dosya Akışı

Kurulum Gerekir

Özel Türler

hashlib.sha256()

hex / bytes

✗

Hızlı (C/OpenSSL)

✓ update() ile

Hayır (stdlib)

Manuel encode()

hmac.new()

hex / bytes

✓

Hızlı (C/OpenSSL)

✓ update() ile

Hayır (stdlib)

Manuel encode()

hashlib.file_digest()

hex / bytes

✗

Hızlı (sıfır kopya)

✓ (yerleşik)

Hayır (3.11+)

Manuel encode()

cryptography hashes.SHA256()

bytes

✗

Hızlı (OpenSSL)

✓ update() ile

pip install

Manuel encode()

subprocess openssl dgst

hex dizisi

✗ / ✓

Yavaş (fork)

✓ (OS düzeyinde)

Sistem openssl

Manuel encode()

pyhashcat / özel

değişken

✗

GPU hızlandırmalı

✗

pip install

Manuel encode()

Doğrudan hashleme — checksum'lar, önbellek anahtarları, içerik parmak izi — için hashlib.sha256()'da kalın. Gizli anahtara ihtiyaç duyduğunuz anda (webhook'lar, API imzaları, token doğrulama) hmac.new()'e geçin. cryptography kütüphanesini yalnızca proje zaten şifreleme veya TLS için kullanıyorsa tercih edin — hashlib zaten OpenSSL tarafından desteklenirken yalnızca hashleme için C uzantısı bağımlılığı eklemek gereksizdir.

SHA-256 Şifresi Çözülebilir mi? — Hashleme ve Şifreleme

Kısa cevap: hayır. SHA-256 tek yönlü bir fonksiyondur. Algoritma tersine çevrilemez olacak şekilde tasarlanmıştır — 256 bitlik özetten orijinal girdiyi yeniden oluşturamazsınız. Bu bir uygulama sınırlaması değil, hash fonksiyonunun matematiksel bir özelliğidir. 256 bitlik çıktı uzayı astronomik büyüklüktedir (2²⁵⁶ olası değer) ve fonksiyon 64 sıkıştırma turu sırasında bilgiyi atar.

Saldırganlar zayıf girdilere (yaygın parolalar, kısa dizeler) karşı kaba kuvvet veya sözlük saldırısı deneyebilir; ancak makul entropi içeren herhangi bir girdi için — API anahtarları, rastgele token'lar, dosya içerikleri — mevcut donanımla SHA-256'yı tersine çevirmek hesaplama açısından olanaksızdır. Tersine çevrilebilir dönüşüme ihtiyaç duyuyorsanız simetrik şifreleme kullanın:

Python 3.9+ — şifreleme ve hashleme

# Hashleme — tek yönlü, orijinal kurtarılamaz
import hashlib
digest = hashlib.sha256(b"secret-config-value").hexdigest()
# digest'ten "secret-config-value" geri alınamaz

# Şifreleme — çift yönlü, anahtarla çözülebilir
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" — orijinal kurtarıldı

Hızlıca SHA-256 hash oluşturmak için kurulum gerektirmeyen çevrimiçi araç tamamen tarayıcınızda çalışır.

Python'da Bir Dizenin Geçerli SHA-256 Hash Olup Olmadığını Kontrol Etme

Geçerli bir SHA-256 hex özeti tam olarak 64 hexadecimal karakterden oluşur (0-9, a-f, A-F). Güvenilmeyen girdiyi işlemeden önce hızlı doğrulama, kafa karıştırıcı aşağı akış hatalarını önler.

Python 3.9+ — SHA-256 biçimini doğrula

import re

def is_sha256_hex(value: str) -> bool:
    """Bir dizenin SHA-256 hex özeti biçimiyle eşleşip eşleşmediğini kontrol et."""
    return bool(re.fullmatch(r"[a-fA-F0-9]{64}", value))

# Test durumları
print(is_sha256_hex("e3b0c44298fc1c149afbf4c8996fb924"
                     "27ae41e4649b934ca495991b7852b855"))  # True — boş dizenin SHA-256'sı
print(is_sha256_hex("e3b0c44298fc1c14"))                   # False — çok kısa
print(is_sha256_hex("zzzz" * 16))                          # False — geçersiz hex karakterleri

Not:Bu yalnızca biçimi doğrular, hash'in belirli bir girdiden hesaplanıp hesaplanmadığını değil. 64 karakterlik hex dizisinin "gerçek" bir SHA-256 özeti mi yoksa rastgele hex mi olduğunu söylemenin yolu yoktur — SHA-256 çıktısı tasarım gereği rastgele veriden ayırt edilemez.

Sıkça Sorulan Sorular

Python'da bir dizeyi SHA-256 ile nasıl hashlerim?

Dizeyi bayta kodlayarak hashlib.sha256() çağırın. Python dizeleri Unicode'dur ve hash fonksiyonları ham baytlar üzerinde çalışır, bu nedenle önce .encode("utf-8") çağırmalısınız. .hexdigest() metodu tanıdık 64 karakterlik hex dizisini döndürür.

Python

import hashlib

api_key = "sk_live_9f3a7b2e1d4c"
digest = hashlib.sha256(api_key.encode("utf-8")).hexdigest()
print(digest)
# e3b7c4a1f8d2...64 hex karakter

SHA-256 hash'i orijinal metne geri çözebilir misiniz?

Hayır. SHA-256 tek yönlü bir fonksiyondur — keyfi uzunluktaki girdiyi sabit 256 bitlik çıktıya eşler ve işlem sırasında yapıyı atar. Matematiksel tersi yoktur. Saldırganlar zayıf girdilere (kısa parolalar, yaygın kelimeler) karşı kaba kuvvet veya gökkuşağı tablosu araması deneyebilir; ancak makul entropiye sahip herhangi bir girdi için SHA-256'yı tersine çevirmek hesaplama açısından olanaksızdır. Tersine çevrilebilir dönüşüme ihtiyaç duyuyorsanız hashleme yerine şifreleme (AES-GCM, Fernet) kullanın.

.digest() ve .hexdigest() arasındaki fark nedir?

.digest() hash'in ham 32 baytını bytes nesnesi olarak döndürür. .hexdigest() aynı veriyi 64 karakterlik küçük harfli hexadecimal dizi olarak kodlanmış biçimde döndürür. HMAC'e besleme, Base64 kodlama veya ikili protokollere yazma gibi durumlarda ikili çıktıya ihtiyaç duyduğunuzda .digest() kullanın. Günlük kaydı, veritabanı depolama ve checksum karşılaştırması için .hexdigest() tercih edin.

Python

import hashlib

h = hashlib.sha256(b"deployment-v4.2.1")
print(len(h.digest()))     # 32 (bayt)
print(len(h.hexdigest()))  # 64 (hex karakter)

Python'da bir dosyanın SHA-256 checksum'ını nasıl hesaplarım?

Dosyayı ikili modda açın ve .update() ile hasher'a parça parça besleyin. Python 3.11+ sürümünde daha basit bir API için hashlib.file_digest() kullanın. Büyük dosyalarda f.read() asla çağırmayın — tüm dosyayı belleğe yükler.

Python

import hashlib

def sha256_file(path: str) -> str:
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(8192), b""):
            h.update(chunk)
    return h.hexdigest()

print(sha256_file("release-v4.2.1.tar.gz"))

Python'da HMAC-SHA256 imzası nasıl oluştururum?

digestmod olarak hashlib.sha256 ile hmac modülünü kullanın. Gizli anahtarı ve mesajı bytes olarak geçin. Sonuç, hem bütünlüğü hem de özgünlüğü kanıtlayan anahtarlı bir hash'tir — doğrulama için alıcının aynı anahtara ihtiyacı vardır.

Python

import hmac
import hashlib

secret = b"webhook_secret_9f3a"
payload = b'{"event":"payment.completed","amount":4999}'
signature = hmac.new(secret, payload, hashlib.sha256).hexdigest()
print(signature)  # 64 karakterlik hex HMAC

Bir dizenin geçerli SHA-256 hex özeti olup olmadığını nasıl doğrularım?

Bir SHA-256 hex özeti tam olarak 64 hexadecimal karakterden oluşur. Regex veya basit uzunluk ve karakter kontrolü kullanın. Regex yaklaşımı en okunabilir olanıdır.

Python

import re

def is_sha256(s: str) -> bool:
    return bool(re.fullmatch(r"[a-fA-F0-9]{64}", s))

print(is_sha256("e3b0c44298fc1c149afbf4c8996fb924"
                 "27ae41e4649b934ca495991b7852b855"))  # True
print(is_sha256("geçersiz-hash"))  # False

İlgili Araçlar

SHA-256 Hash Üreticisi

Tarayıcıda anında SHA-256 hash oluşturun — kod veya Python kurulumu gerekmez. Metni yapıştırın, hex özetini alın.

HMAC Üreticisi

SHA-256, SHA-512 veya MD5 ile çevrimiçi HMAC imzaları oluşturun — Python kodu yazmadan önce webhook doğrulama mantığını test etmek için kullanışlıdır.

Base64 Kodlayıcı

HTTP başlıkları, JWT imzaları ve API kimlik doğrulama şemaları için ikili SHA-256 özetlerini Base64'e kodlayın.

JWT Çözücü

HS256 (HMAC-SHA256) imzalaması kullanan JWT token'larını inceleyin — başlık ve yükü çözün, imza yapısını doğrulayın.

Dmitri VolkovDevOps Engineer & Python Automation Specialist

Dmitri is a DevOps engineer who relies on Python as his primary scripting and automation language. He builds internal tooling, CI/CD pipelines, and infrastructure automation scripts that run in production across distributed teams. He writes about the Python standard library, subprocess management, file processing, encoding utilities, and the practical shell-adjacent Python that DevOps engineers use every day.

Maria SantosTeknik İnceleyici

Maria is a backend developer specialising in Python and API integration. She has broad experience with data pipelines, serialisation formats, and building reliable server-side services. She is an active member of the Python community and enjoys writing practical, example-driven guides that help developers solve real problems without unnecessary theory.