Какие знаешь основные характеристики результата хеш функции?

Основные характеристики хеш-функций

Хеш-функция — это математическое преобразование данных в фиксированный размер выходного значения (хеш). Это фундаментальный инструмент криптографии и структур данных.

1. Детерминированность (Determinism)

Для одних и тех же входных данных хеш-функция всегда возвращает одинаковый результат.

import hashlib

# Один и тот же вход = один и тот же хеш
data = b"hello world"
hash1 = hashlib.sha256(data).hexdigest()
hash2 = hashlib.sha256(data).hexdigest()

print(hash1)  # b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
print(hash2)  # b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
print(hash1 == hash2)  # True

# Разные входные данные дают разные хеши
hash3 = hashlib.sha256(b"hello world!").hexdigest()  # Добавили восклицательный знак
print(hash3)  # 7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069
print(hash1 == hash3)  # False

2. Необратимость (Irreversibility)

Нельзя восстановить исходные данные из хеша. Это односторонняя функция.

import hashlib

# Хешируем пароль
password = b"secret123"
hashed = hashlib.sha256(password).hexdigest()
print(f"Хеш пароля: {hashed}")

# Невозможно восстановить пароль из хеша
print(f"Можем ли мы обратно получить пароль? НЕТ!")

# Единственный способ проверить пароль — хешировать его снова
test_password = b"secret123"
if hashlib.sha256(test_password).hexdigest() == hashed:
    print("Пароль верный!")
else:
    print("Пароль неверный!")

# Даже небольшое изменение входных данных полностью меняет хеш
password2 = b"secret124"  # Изменили только последнюю цифру
hashed2 = hashlib.sha256(password2).hexdigest()
print(f"Старый хеш: {hashed}")
print(f"Новый хеш: {hashed2}")
print(f"Похожи ли они? Нет!")

3. Фиксированный размер (Fixed Size)

Независимо от размера входных данных, хеш имеет фиксированный размер в битах.

import hashlib

# SHA-256 всегда выдаёт 256 бит (64 hex символа)
small_data = b"a"
large_data = b"a" * 1000000  # 1 млн копий символа

hash_small = hashlib.sha256(small_data).hexdigest()
hash_large = hashlib.sha256(large_data).hexdigest()

print(f"Длина маленького хеша: {len(hash_small)} символов"  )   # 64
print(f"Длина большого хеша: {len(hash_large)} символов")      # 64
print(f"Оба одинакового размера: {len(hash_small) == len(hash_large)}")

# Другие алгоритмы имеют другие размеры
sha1_hash = hashlib.sha1(large_data).hexdigest()
sha512_hash = hashlib.sha512(large_data).hexdigest()

print(f"SHA-1:   {len(sha1_hash)} символов (160 бит)")
print(f"SHA-256: {len(hashlib.sha256(large_data).hexdigest())} символов (256 бит)")
print(f"SHA-512: {len(sha512_hash)} символов (512 бит)")

4. Коллизионная устойчивость (Collision Resistance)

Сложно найти два разных входа, которые дают один и тот же хеш.

import hashlib

# В теории коллизии существуют (парадокс дня рождения)
# Но для хорошего алгоритма (SHA-256) найти их практически невозможно

# Попытка найти коллизию в SHA-256 потребовала бы 2^128 вычислений
# На современном компьютере это займёт > триллионов лет

# Обратите внимание: MD5 и SHA-1 уже имеют найденные коллизии!
# Поэтому они считаются небезопасными

# Пример коллизии в MD5 (не нужно использовать)
# Два разных файла дают один и тот же MD5 хеш
print("MD5 больше не рекомендуется использовать из-за найденных коллизий")

# Хорошие алгоритмы: SHA-256, SHA-512, Blake2
hash_256 = hashlib.sha256(b"data").hexdigest()
hash_512 = hashlib.sha512(b"data").hexdigest()

print(f"SHA-256 безопасен: {len(hash_256)} символов (очень сложно найти коллизию)")
print(f"SHA-512 ещё безопаснее: {len(hash_512)} символов")

5. Лавинный эффект (Avalanche Effect)

Малейшее изменение входа полностью меняет хеш.

import hashlib

data1 = b"The quick brown fox"
data2 = b"The quick brown fox."  # Добавили только точку!

hash1 = hashlib.sha256(data1).hexdigest()
hash2 = hashlib.sha256(data2).hexdigest()

print(f"Хеш 1: {hash1}")
print(f"Хеш 2: {hash2}")
print(f"Отличаются ли они полностью? Да!")

# Подсчитаем, сколько бит отличаются
bits1 = bin(int(hash1, 16))[2:]
bits2 = bin(int(hash2, 16))[2:]

different_bits = sum(1 for b1, b2 in zip(bits1, bits2) if b1 != b2)
total_bits = 256

print(f"Отличающихся битов: {different_bits} из {total_bits}")
print(f"Процент отличия: {100 * different_bits / total_bits:.1f}%")
# Обычно около 50% битов отличаются (лавинный эффект)

6. Быстрое вычисление (Fast Computation)

Хеш-функция должна вычисляться быстро, но для паролей должна быть медленной.

import hashlib
import time
from passlib.context import CryptContext

# Быстрое хеширование для целостности данных
data = b"a" * 1000000  # 1 MB данных

start = time.time()
for _ in range(1000):
    hashlib.sha256(data).hexdigest()
fast_time = time.time() - start
print(f"SHA-256 (быстрое): {fast_time:.3f}s для 1000 операций")

# Медленное хеширование для паролей
pwd_context = CryptContext(schemes=["bcrypt"])
password = "secret123"

start = time.time()
for _ in range(10):
    pwd_context.hash(password)
slow_time = time.time() - start
print(f"bcrypt (медленное): {slow_time:.3f}s для 10 операций")

print(f"\nВывод: bcrypt специально медленный для защиты от brute force")

7. Простота в использовании (Simplicity)

Хеш-функция должна быть простой в реализации и использовании.

import hashlib

# Очень просто
result = hashlib.sha256(b"data").hexdigest()
print(f"Простая строка кода: {result}")

# Для разных форматов данных
string_hash = hashlib.sha256("hello".encode()).hexdigest()
file_hash = hashlib.sha256(open('file.txt', 'rb').read()).hexdigest()

print(f"Строка: {string_hash}")
print(f"Файл: {file_hash}")

8. Безопасность (Security)

Для криптографических целей хеш должен быть устойчив к различным атакам.

import hashlib

# УЯЗВИМЫЕ алгоритмы (НЕ ИСПОЛЬЗУЙ)
print("Не используй:")
print("- MD5: найдены коллизии, быстрый")
print("- SHA-1: найдены коллизии, быстрый")

# БЕЗОПАСНЫЕ алгоритмы
print("\nИспользуй:")
print("- SHA-256: криптографически безопасный")
print("- SHA-512: ещё более безопасный")
print("- Blake2: современный и быстрый")
print("- bcrypt: для паролей")
print("- Argon2: лучше всех для паролей")

# Пример
data = b"important data"
safe_hash = hashlib.sha256(data).hexdigest()
print(f"\nБезопасный хеш: {safe_hash}")

9. Непредсказуемость (Unpredictability)

Нельзя предсказать хеш без вычисления функции.

import hashlib
import secrets

# Невозможно предсказать
print(hashlib.sha256(b"1").hexdigest())
print(hashlib.sha256(b"2").hexdigest())
print(hashlib.sha256(b"3").hexdigest())
# Нет паттерна, который можно было бы использовать для предсказания

# Даже близкие входы дают совершенно разные хеши
for i in range(5):
    h = hashlib.sha256(f"{i}".encode()).hexdigest()
    print(f"{i}: {h}")

10. Допускает параллельность (Parallelizable)

Хеширование больших данных может быть распараллелено.

import hashlib
from concurrent.futures import ThreadPoolExecutor

def hash_chunk(chunk):
    return hashlib.sha256(chunk).digest()

# Большой файл
data = b"x" * (10 * 1024 * 1024)  # 10 MB
chunk_size = 1024 * 1024  # 1 MB на chunk

# Параллельное хеширование
chunks = [data[i:i+chunk_size] for i in range(0, len(data), chunk_size)]

with ThreadPoolExecutor() as executor:
    hashes = list(executor.map(hash_chunk, chunks))

final_hash = hashlib.sha256(b''.join(hashes)).hexdigest()
print(f"Финальный хеш после объединения: {final_hash}")

Практический пример: проверка целостности файла

import hashlib

def calculate_file_hash(filepath):
    """Считаем хеш большого файла экономно"""
    hash_obj = hashlib.sha256()
    with open(filepath, 'rb') as f:
        while True:
            chunk = f.read(4096)  # Читаем по 4KB
            if not chunk:
                break
            hash_obj.update(chunk)
    return hash_obj.hexdigest()

# Использование
# file_hash = calculate_file_hash('large_file.bin')
# Если хеш совпадает с оригиналом — файл не повреждён

Выводы

Основные характеристики хеш-функций:

1. Детерминированность — один вход = один выход
2. Необратимость — нельзя восстановить исходные данные
3. Фиксированный размер — независимо от размера входа
4. Коллизионная устойчивость — сложно найти одинаковые хеши
5. Лавинный эффект — малое изменение входа меняет хеш полностью
6. Быстрое вычисление — быстро для целостности, медленно для паролей
7. Простота — легко реализовать и использовать
8. Безопасность — устойчива к известным атакам
9. Непредсказуемость — нельзя предсказать результат
10. Параллелизируемость — можно распараллелить для больших данных

Для различных целей выбирай соответствующие алгоритмы: SHA-256 для целостности, bcrypt для паролей.