Хеширование в Python: современные алгоритмы и практическое применение

import hashlib

# Создание хеша SHA-256
data = "Секретные данные".encode('utf-8')
hash_object = hashlib.sha256(data)
hex_dig = hash_object.hexdigest()
print(f"SHA-256 хеш: {hex_dig}")

# Создание хеша MD5
hash_md5 = hashlib.md5(data).hexdigest()
print(f"MD5 хеш: {hash_md5}")

def hash_file(filename, algorithm="sha256"):
"""Вычисляет хеш файла, используя заданный алгоритм"""
hash_obj = getattr(hashlib, algorithm)()

with open(filename, "rb") as f:
# Чтение файла блоками по 4KB
for chunk in iter(lambda: f.read(4096), b""):
hash_obj.update(chunk)

return hash_obj.hexdigest()

# Использование
file_hash = hash_file("large_document.pdf")
print(f"Хеш файла: {file_hash}")

print(hashlib.algorithms_available)
print(hashlib.algorithms_guaranteed)

import hmac
import hashlib

def create_hmac_signature(key, message):
"""Создает HMAC-подпись сообщения с использованием секретного ключа"""
# Преобразуем данные в байтовые строки, если они еще не в этом формате
if isinstance(key, str):
key = key.encode()
if isinstance(message, str):
message = message.encode()

# Создаем HMAC с использованием SHA-256
signature = hmac.new(key, message, hashlib.sha256)

# Возвращаем подпись в шестнадцатеричном формате
return signature.hexdigest()

# Пример использования
secret_key = "мой_сверхсекретный_ключ"
data = "Важное сообщение, требующее аутентификации"

signature = create_hmac_signature(secret_key, data)
print(f"HMAC подпись: {signature}")

# Проверка подписи
def verify_hmac_signature(key, message, signature):
"""Проверяет HMAC-подпись"""
calculated_signature = create_hmac_signature(key, message)
# Сравнение в постоянном времени для защиты от атак по времени
return hmac.compare_digest(calculated_signature, signature)

is_valid = verify_hmac_signature(secret_key, data, signature)
print(f"Подпись действительна: {is_valid}")

# Проверка с модифицированными данными
is_valid = verify_hmac_signature(secret_key, data + " (изменено)", signature)
print(f"Подпись с измененными данными действительна: {is_valid}")

import hmac
import hashlib
import time
import base64

def generate_api_signature(api_key, api_secret, method, endpoint, payload=""):
"""Создает подпись для API-запроса"""
# Текущее время в секундах
timestamp = str(int(time.time()))

# Строка для подписи: timestamp + method + endpoint + payload
string_to_sign = timestamp + method + endpoint + payload

# Создание HMAC-подписи
signature = hmac.new(
api_secret.encode('utf-8'),
string_to_sign.encode('utf-8'),
hashlib.sha256
).digest()

# Base64-кодирование для удобства передачи
encoded_signature = base64.b64encode(signature).decode('utf-8')

return {
'X-API-Key': api_key,
'X-Timestamp': timestamp,
'X-Signature': encoded_signature
}

# Пример использования с requests
import requests

def make_authenticated_request(url, method, payload, api_key, api_secret):
endpoint = url.split('://')[-1].split('/', 1)[-1] if '/' in url.split('://')[-1] else ""

# Получение заголовков аутентификации
auth_headers = generate_api_signature(api_key, api_secret, method, endpoint, payload)

# Добавление заголовков к запросу
headers = {
'Content-Type': 'application/json',
**auth_headers
}

# Выполнение запроса с правильным методом
if method.upper() == 'GET':
response = requests.get(url, headers=headers)
elif method.upper() == 'POST':
response = requests.post(url, headers=headers, data=payload)
# Другие методы по необходимости...

return response

# Пример вызова
# response = make_authenticated_request(
# "https://api.example.com/v1/data",
# "GET",
# "",
# "your_api_key",
# "your_api_secret"
# )

import bcrypt

def hash_password(password):
"""Хеширует пароль с использованием bcrypt"""
# Преобразуем пароль в байтовую строку
password_bytes = password.encode('utf-8')

# Генерируем соль и хешируем пароль
# Параметр rounds (12) определяет сложность (2^12 итераций)
salt = bcrypt.gensalt(rounds=12)
hashed = bcrypt.hashpw(password_bytes, salt)

# Возвращаем хеш в виде строки
return hashed.decode('utf-8')

def verify_password(stored_hash, provided_password):
"""Проверяет, соответствует ли введенный пароль сохраненному хешу"""
# Преобразуем данные в байтовые строки
stored_bytes = stored_hash.encode('utf-8')
provided_bytes = provided_password.encode('utf-8')

# Проверяем соответствие
return bcrypt.checkpw(provided_bytes, stored_bytes)

# Пример использования
user_password = "сложный_пароль123!"
hashed_password = hash_password(user_password)
print(f"Хешированный пароль: {hashed_password}")

# Проверка правильного пароля
is_correct = verify_password(hashed_password, user_password)
print(f"Пароль верный: {is_correct}")

# Проверка неправильного пароля
is_correct = verify_password(hashed_password, "неправильный_пароль")
print(f"Пароль верный: {is_correct}")

from passlib.hash import argon2

def hash_password_argon2(password):
"""Хеширует пароль с использованием Argon2"""
# Параметры:
# – time_cost: количество итераций
# – memory_cost: использование памяти (в килобайтах)
# – parallelism: степень параллелизма
return argon2.using(
time_cost=3, # количество итераций 
memory_cost=65536, # 64 МБ
parallelism=4 # 4 потока
).hash(password)

def verify_password_argon2(stored_hash, provided_password):
"""Проверяет пароль с хешем Argon2"""
return argon2.verify(provided_password, stored_hash)

# Пример использования
user_password = "очень_сложный_пароль456!"
hashed_password = hash_password_argon2(user_password)
print(f"Argon2 хешированный пароль: {hashed_password}")

# Проверка
is_correct = verify_password_argon2(hashed_password, user_password)
print(f"Пароль верный: {is_correct}")

import hashlib
import json
import functools

def memoize_with_hash(func):
"""Декоратор для мемоизации функции с использованием хешей аргументов"""
cache = {}

@functools.wraps(func)
def wrapper(*args, **kwargs):
# Создаем стабильное представление аргументов
key_dict = {'args': args, 'kwargs': sorted(kwargs.items())}
# Преобразуем в JSON и хешируем для получения ключа кэша
key = hashlib.sha256(json.dumps(key_dict, sort_keys=True).encode()).hexdigest()

# Проверяем кэш
if key not in cache:
# Вычисляем результат и сохраняем в кэш
cache[key] = func(*args, **kwargs)

return cache[key]

return wrapper

# Пример использования
@memoize_with_hash
def expensive_calculation(x, y, z=10):
print(f"Выполняется вычисление для x={x}, y={y}, z={z}")
# Имитация сложного вычисления
import time
time.sleep(1)
return x * y * z

# Первый вызов (вычисление)
result1 = expensive_calculation(5, 10, z=15)
print(f"Результат: {result1}")

# Второй вызов (из кэша)
result2 = expensive_calculation(5, 10, z=15)
print(f"Результат: {result2}")

import hashlib
import os
import requests

def download_file_with_verification(url, expected_hash, hash_algorithm='sha256'):
"""Скачивает файл и проверяет его хеш"""
local_filename = url.split('/')[-1]

# Скачиваем файл
with requests.get(url, stream=True) as r:
r.raise_for_status()

# Создаем хеш-объект для алгоритма
hash_obj = getattr(hashlib, hash_algorithm)()

with open(local_filename, 'wb') as f:
for chunk in r.iter_content(chunk_size=8192):
# Обновляем хеш
hash_obj.update(chunk)
# Записываем чанк
f.write(chunk)

# Получаем финальный хеш
file_hash = hash_obj.hexdigest()

# Проверяем соответствие
if file_hash != expected_hash:
# Удаляем файл, если хеш не совпадает
os.remove(local_filename)
raise ValueError(
f"Ошибка проверки целостности! Ожидался хеш {expected_hash}, "
f"получен {file_hash}"
)

return local_filename

# Пример использования
# try:
# file = download_file_with_verification(
# "https://example.com/downloads/file.zip",
# "a1b2c3d4e5f6...", # Ожидаемый хеш SHA-256
# "sha256"
# )
# print(f"Файл успешно скачан и проверен: {file}")
# except ValueError as e:
# print(f"Ошибка: {e}")

import hashlib
import json
import os
import time

class ChangeDetector:
"""Класс для обнаружения изменений в файлах или структурах данных"""

def __init__(self, hash_algorithm='sha256'):
self.hash_algorithm = hash_algorithm
self.hashes = {}

def hash_file(self, filename):
"""Вычисляет хеш файла"""
hash_obj = getattr(hashlib, self.hash_algorithm)()

with open(filename, 'rb') as f:
for chunk in iter(lambda: f.read(4096), b""):
hash_obj.update(chunk)

return hash_obj.hexdigest()

def hash_data(self, data):
"""Вычисляет хеш структуры данных"""
# Преобразуем в стабильное JSON-представление
serialized = json.dumps(data, sort_keys=True).encode()
hash_obj = getattr(hashlib, self.hash_algorithm)()
hash_obj.update(serialized)

return hash_obj.hexdigest()

def register_file(self, file_path):
"""Регистрирует файл для отслеживания изменений"""
self.hashes[file_path] = {
'type': 'file',
'hash': self.hash_file(file_path),
'timestamp': time.time()
}

def register_data(self, name, data):
"""Регистрирует структуру данных для отслеживания"""
self.hashes[name] = {
'type': 'data',
'hash': self.hash_data(data),
'timestamp': time.time()
}

def check_changes(self):
"""Проверяет все зарегистрированные объекты на изменения"""
changes = {}

for key, info in self.hashes.items():
current_hash = None

if info['type'] == 'file':
if not os.path.exists(key):
changes[key] = 'DELETED'
continue

current_hash = self.hash_file(key)
else: # data
# Для данных нужно передать текущее состояние извне
continue

if current_hash != info['hash']:
changes[key] = 'MODIFIED'
# Обновляем хеш
self.hashes[key]['hash'] = current_hash
self.hashes[key]['timestamp'] = time.time()

return changes

# Пример использования
# detector = ChangeDetector()
# detector.register_file("/etc/passwd")
# detector.register_file("/etc/hosts")
# detector.register_data("app_config", {"debug": False, "log_level": "INFO"})

# # Позже проверяем изменения
# changes = detector.check_changes()
# if changes:
# for item, status in changes.items():
# print(f"{item}: {status}")
# else:
# print("Изменений не обнаружено")

import hashlib
import hmac
import secrets

class DataAnonymizer:
"""Класс для анонимизации персональных данных"""

def __init__(self, secret_key=None):
# Создаем или используем существующий секретный ключ
self.secret_key = secret_key or secrets.token_bytes(32)

def anonymize_pii(self, personal_data, preserve_format=False):
"""Анонимизирует персональные данные"""
if not personal_data:
return personal_data

# Преобразуем данные в байты
if isinstance(personal_data, str):
data_bytes = personal_data.encode('utf-8')
else:
data_bytes = str(personal_data).encode('utf-8')

# Используем HMAC для создания детерминированного хеша
h = hmac.new(self.secret_key, data_bytes, hashlib.sha256)
hashed = h.hexdigest()

# Если требуется сохранить формат (например, для email)
if preserve_format and '@' in personal_data:
username, domain = personal_data.split('@', 1)
return f"{hashed[:8]}@{domain}"

return hashed

def anonymize_dataset(self, dataset, pii_fields):
"""Анонимизирует поля PII в наборе данных"""
anonymized = []

for record in dataset:
anon_record = dict(record) # Копируем запись

for field, preserve_format in pii_fields.items():
if field in anon_record:
anon_record[field] = self.anonymize_pii(
anon_record[field], 
preserve_format
)

anonymized.append(anon_record)

return anonymized

# Пример использования
# Данные пользователей
# users = [
# {"id": 1, "name": "Иван Петров", "email": "ivan@example.com", "phone": "+7 (123) 456-78-90"},
# {"id": 2, "name": "Анна Сидорова", "email": "anna@example.com", "phone": "+7 (987) 654-32-10"}
# ]

# # Поля для анонимизации (True = сохранить формат)
# pii_fields = {
# "name": False,
# "email": True,
# "phone": False
# }

# # Создаем анонимизатор и обрабатываем данные
# anonymizer = DataAnonymizer()
# anonymized_users = anonymizer.anonymize_dataset(users, pii_fields)

# # Выводим результат
# import json
# print(json.dumps(anonymized_users, indent=2, ensure_ascii=False))