Хеширование в Python: безопасность данных с модулем hashlib

import hashlib

import hashlib

# Создание объекта хеш-функции
h = hashlib.sha256()

# Добавление данных для хеширования
h.update(b'Hello, World!')

# Получение хеша в шестнадцатеричном формате
print(h.hexdigest())
# Вывод: dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f

text = "Секретное сообщение"
h = hashlib.sha256(text.encode('utf-8'))
print(h.hexdigest())

print(hashlib.algorithms_guaranteed)
# Вывод может включать: 'sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5' и другие

import hashlib

# MD5 хеширование строки
md5_hash = hashlib.md5(b"Пример текста для хеширования").hexdigest()
print(f"MD5: {md5_hash}")

# SHA-1 (160 бит)
sha1_hash = hashlib.sha1(b"Пример текста для хеширования").hexdigest()
print(f"SHA-1: {sha1_hash}")

# SHA-256 (256 бит)
sha256_hash = hashlib.sha256(b"Пример текста для хеширования").hexdigest()
print(f"SHA-256: {sha256_hash}")

# SHA-512 (512 бит)
sha512_hash = hashlib.sha512(b"Пример текста для хеширования").hexdigest()
print(f"SHA-512: {sha512_hash}")

# Инкрементальное хеширование большого текста
h = hashlib.sha256()
h.update(b"Первая часть данных")
h.update(b"Вторая часть данных")
h.update(b"Третья часть данных")
print(h.hexdigest())

# Это эквивалентно:
h_single = hashlib.sha256(b"Первая часть данныхВторая часть данныхТретья часть данных")
print(h_single.hexdigest())

message1 = b"Python hashlib"
message2 = b"Python Hashlib" # Изменена только одна буква (h -> H)

print(f"SHA-256 сообщения 1: {hashlib.sha256(message1).hexdigest()}")
print(f"SHA-256 сообщения 2: {hashlib.sha256(message2).hexdigest()}")

# SHA3-256 (требуется Python 3.6+)
try:
sha3_hash = hashlib.sha3_256(b"Пример текста для хеширования").hexdigest()
print(f"SHA3-256: {sha3_hash}")
except AttributeError:
print("SHA3 не поддерживается в вашей версии Python")

import hashlib
import os

def hash_password_with_salt(password):
# Генерация случайной соли
salt = os.urandom(32)

# Хеширование пароля с солью
password_hash = hashlib.pbkdf2_hmac(
'sha256', # Используемый алгоритм хеширования
password.encode('utf-8'), # Пароль в виде байтов
salt, # Соль
100000, # Количество итераций
dklen=128 # Длина получаемого ключа в байтах
)

# Сохраняем соль вместе с хешем для последующей верификации
return salt, password_hash

def verify_password(stored_salt, stored_password_hash, provided_password):
# Хеширование предоставленного пароля с сохраненной солью
password_hash = hashlib.pbkdf2_hmac(
'sha256',
provided_password.encode('utf-8'),
stored_salt,
100000,
dklen=128
)

# Сравнение хешей
return password_hash == stored_password_hash

# Пример использования
password = "секретный_пароль"
salt, password_hash = hash_password_with_salt(password)

# Проверка правильного пароля
is_correct = verify_password(salt, password_hash, "секретный_пароль")
print(f"Корректный пароль подтвержден: {is_correct}") # True

# Проверка неправильного пароля
is_correct = verify_password(salt, password_hash, "неверный_пароль")
print(f"Некорректный пароль подтвержден: {is_correct}") # False

# Для установки: pip install bcrypt
import bcrypt

def hash_password_bcrypt(password):
# Генерация соли и хеширование
password_bytes = password.encode('utf-8')
salt = bcrypt.gensalt(rounds=12)
hashed = bcrypt.hashpw(password_bytes, salt)
return hashed

def verify_password_bcrypt(hashed_password, provided_password):
# Проверка пароля
return bcrypt.checkpw(provided_password.encode('utf-8'), hashed_password)

# Пример использования
hashed_pwd = hash_password_bcrypt("мой_безопасный_пароль")
print(f"Хеш bcrypt: {hashed_pwd}")
print(f"Проверка: {verify_password_bcrypt(hashed_pwd, 'мой_безопасный_пароль')}")

import hashlib
import os
import base64
import time
import secrets

class PasswordManager:
def __init__(self, iterations=100000, dklen=128):
self.iterations = iterations
self.dklen = dklen

def hash_password(self, password):
salt = os.urandom(32)
password_hash = hashlib.pbkdf2_hmac(
'sha256',
password.encode('utf-8'),
salt,
self.iterations,
dklen=self.dklen
)
# Сохраняем параметры хеширования для возможности будущего обновления
stored_password = {
'algorithm': 'pbkdf2_sha256',
'iterations': self.iterations,
'salt': base64.b64encode(salt).decode('ascii'),
'hash': base64.b64encode(password_hash).decode('ascii')
}
return stored_password

def verify_password(self, stored_password, provided_password):
# Защита от timing-атак с помощью константного времени сравнения
salt = base64.b64decode(stored_password['salt'])
stored_hash = base64.b64decode(stored_password['hash'])
iterations = stored_password['iterations']

# Вычисление хеша для введенного пароля
computed_hash = hashlib.pbkdf2_hmac(
'sha256',
provided_password.encode('utf-8'),
salt,
iterations,
dklen=self.dklen
)

# Сравнение с постоянным временем
return secrets.compare_digest(computed_hash, stored_hash)

# Пример использования
pm = PasswordManager()
user_password = "супер!сложный@пароль#123"
stored = pm.hash_password(user_password)

# Имитация хранения в базе данных
print(f"Хранимая информация о пароле: {stored}")

# Проверка при последующем логине
is_valid = pm.verify_password(stored, user_password)
print(f"Пароль верный: {is_valid}")

import hashlib

def calculate_file_hash(filename, algorithm='sha256', buffer_size=65536):
"""
Вычисление хеша файла с использованием выбранного алгоритма.

:param filename: Путь к файлу
:param algorithm: Алгоритм хеширования ('md5', 'sha1', 'sha256', и т.д.)
:param buffer_size: Размер буфера для чтения файла частями
:return: Хеш файла в шестнадцатеричном представлении
"""
hash_obj = hashlib.new(algorithm)

with open(filename, 'rb') as f:
# Чтение файла блоками для экономии памяти
while True:
data = f.read(buffer_size)
if not data:
break
hash_obj.update(data)

return hash_obj.hexdigest()

# Пример использования
try:
filename = "example.txt"
# Предположим, что файл существует
file_hash = calculate_file_hash(filename)
print(f"SHA-256 хеш файла {filename}: {file_hash}")

# Вычисление MD5 хеша
md5_hash = calculate_file_hash(filename, algorithm='md5')
print(f"MD5 хеш файла {filename}: {md5_hash}")
except FileNotFoundError:
print(f"Файл {filename} не найден")
except Exception as e:
print(f"Ошибка при вычислении хеша: {str(e)}")

def verify_file_integrity(filename, expected_hash, algorithm='sha256'):
"""
Проверка целостности файла путем сравнения его хеша с ожидаемым значением.

:param filename: Путь к проверяемому файлу
:param expected_hash: Ожидаемое значение хеша
:param algorithm: Алгоритм хеширования
:return: True, если хеш совпадает, иначе False
"""
calculated_hash = calculate_file_hash(filename, algorithm)
return calculated_hash.lower() == expected_hash.lower()

# Пример использования
expected_sha256 = "a1b2c3d4e5f6..." # Замените на реальное значение ожидаемого хеша
if verify_file_integrity("downloaded_update.exe", expected_sha256):
print("Файл не поврежден, целостность подтверждена.")
else:
print("ВНИМАНИЕ! Хеш файла не соответствует ожидаемому значению!")
print("Возможно, файл был поврежден или подменен.")

import os
import hashlib
import json
from datetime import datetime

def hash_directory(directory_path, algorithm='sha256'):
"""
Вычисляет хеши всех файлов в указанной директории и её поддиректориях.

:param directory_path: Путь к директории
:param algorithm: Алгоритм хеширования
:return: Словарь {относительный_путь: хеш_файла}
"""
file_hashes = {}

for root, dirs, files in os.walk(directory_path):
for filename in files:
file_path = os.path.join(root, filename)
relative_path = os.path.relpath(file_path, directory_path)

try:
file_hash = calculate_file_hash(file_path, algorithm)
file_hashes[relative_path] = file_hash
except Exception as e:
file_hashes[relative_path] = f"ERROR: {str(e)}"

return file_hashes

def save_hash_report(directory_path, output_file, algorithm='sha256'):
"""
Создает отчет о хешах файлов в директории и сохраняет его в JSON формате.

:param directory_path: Путь к проверяемой директории
:param output_file: Путь к файлу отчета
:param algorithm: Алгоритм хеширования
"""
hashes = hash_directory(directory_path, algorithm)

report = {
'timestamp': datetime.now().isoformat(),
'directory': os.path.abspath(directory_path),
'algorithm': algorithm,
'file_count': len(hashes),
'hashes': hashes
}

with open(output_file, 'w') as f:
json.dump(report, f, indent=2)

return report

# Пример использования
report = save_hash_report("./important_data", "integrity_report.json")
print(f"Создан отчет по {report['file_count']} файлам.")

def verify_directory_integrity(directory_path, baseline_report_file):
"""
Проверяет текущее состояние директории относительно базового отчета.

:param directory_path: Путь к проверяемой директории
:param baseline_report_file: Путь к базовому отчету
:return: Словарь с результатами проверки
"""
with open(baseline_report_file, 'r') as f:
baseline = json.load(f)

algorithm = baseline['algorithm']
baseline_hashes = baseline['hashes']

current_hashes = hash_directory(directory_path, algorithm)

results = {
'timestamp': datetime.now().isoformat(),
'unchanged': [],
'modified': [],
'added': [],
'removed': []
}

# Проверяем текущие файлы
for file_path, current_hash in current_hashes.items():
if file_path in baseline_hashes:
if current_hash == baseline_hashes[file_path]:
results['unchanged'].append(file_path)
else:
results['modified'].append(file_path)
else:
results['added'].append(file_path)

# Находим удаленные файлы
for file_path in baseline_hashes:
if file_path not in current_hashes:
results['removed'].append(file_path)

return results

# Пример использования
integrity_results = verify_directory_integrity("./important_data", "baseline_report.json")
print(f"Неизмененные файлы: {len(integrity_results['unchanged'])}")
print(f"Модифицированные файлы: {len(integrity_results['modified'])}")
print(f"Новые файлы: {len(integrity_results['added'])}")
print(f"Удаленные файлы: {len(integrity_results['removed'])}")

if integrity_results['modified'] or integrity_results['removed']:
print("ВНИМАНИЕ! Обнаружены изменения в критически важных файлах!")
for file in integrity_results['modified']:
print(f"Модифицирован: {file}")
for file in integrity_results['removed']:
print(f"Удален: {file}")

import hashlib
import hmac
import secrets

def create_hmac(key, message, algorithm='sha256'):
"""
Создает HMAC для сообщения с использованием секретного ключа.

:param key: Секретный ключ (байты)
:param message: Сообщение для аутентификации (байты или строка)
:param algorithm: Алгоритм хеширования
:return: HMAC в шестнадцатеричном представлении
"""
if isinstance(message, str):
message = message.encode('utf-8')

h = hmac.new(key, message, getattr(hashlib, algorithm))
return h.hexdigest()

# Генерация секретного ключа
secret_key = secrets.token_bytes(32) # 256 бит

# Создание HMAC для сообщения
message = "Это важное сообщение, целостность которого нужно гарантировать"
signature = create_hmac(secret_key, message)

print(f"Сообщение: {message}")
print(f"HMAC подпись: {signature}")

# Проверка подлинности
def verify_hmac(key, message, expected_signature, algorithm='sha256'):
"""
Проверяет HMAC подпись для сообщения.

:param key: Секретный ключ (байты)
:param message: Исходное сообщение
:param expected_signature: Ожидаемая подпись
:param algorithm: Алгоритм хеширования
:return: True, если подпись верна, иначе False
"""
calculated_signature = create_hmac(key, message, algorithm)
# Используем сравнение с постоянным временем для защиты от timing-атак
return hmac.compare_digest(calculated_signature, expected_signature)

# Проверка легитимного сообщения
is_authentic = verify_hmac(secret_key, message, signature)
print(f"Сообщение подлинно: {is_authentic}") # True

# Проверка измененного сообщения
tampered_message = message + " с добавленным текстом"
is_authentic = verify_hmac(secret_key, tampered_message, signature)
print(f"Измененное сообщение подлинно: {is_authentic}") # False

import hashlib
import os
import base64

# Этот ключ должен храниться в защищенном месте, например, в переменных окружения или хранилище секретов
PEPPER = b"your-secret-pepper-key"

def hash_password_with_pepper(password, pepper=PEPPER):
"""
Хеширует пароль с использованием соли и перца.

:param password: Пароль пользователя
:param pepper: Секретный ключ (перец)
:return: Словарь с параметрами хеширования
"""
salt = os.urandom(32)

# Комбинируем пароль с перцем перед хешированием
peppered_password = password.encode('utf-8') + pepper

password_hash = hashlib.pbkdf2_hmac(
'sha256',
peppered_password,
salt,
100000,
dklen=64
)

return {
'salt': base64.b64encode(salt).decode('ascii'),
'hash': base64.b64encode(password_hash).decode('ascii'),
'iterations': 100000
}

def verify_password_with_pepper(stored_password_info, provided_password, pepper=PEPPER):
"""
Проверяет пароль с учетом перца.

:param stored_password_info: Сохраненная информация о пароле
:param provided_password: Предоставленный пользователем пароль
:param pepper: Секретный ключ (перец)
:return: True, если пароль верен, иначе False
"""
salt = base64.b64decode(stored_password_info['salt'])
stored_hash = base64.b64decode(stored_password_info['hash'])
iterations = stored_password_info['iterations']

# Комбинируем предоставленный пароль с перцем
peppered_password = provided_password.encode('utf-8') + pepper

# Вычисляем хеш с теми же параметрами
computed_hash = hashlib.pbkdf2_hmac(
'sha256',
peppered_password,
salt,
iterations,
dklen=64
)

# Сравнение с постоянным временем
return hmac.compare_digest(computed_hash, stored_hash)

def multi_layer_hash(data, num_iterations=3):
"""
Применяет многоуровневое хеширование данных с использованием разных алгоритмов.

:param data: Данные для хеширования (строка или байты)
:param num_iterations: Количество итераций
:return: Финальный хеш
"""
if isinstance(data, str):
current = data.encode('utf-8')
else:
current = data

# Список используемых алгоритмов
algorithms = ['sha256', 'sha512', 'sha3_256', 'sha3_512', 'blake2b']

for i in range(num_iterations):
# Выбор алгоритма в зависимости от номера итерации
algo = algorithms[i % len(algorithms)]
try:
hash_func = getattr(hashlib, algo)
current = hash_func(current).digest()
except AttributeError:
# Если алгоритм не поддерживается, используем SHA-256
current = hashlib.sha256(current).digest()

# Финальный хеш в шестнадцатеричном представлении
return hashlib.sha256(current).hexdigest()

# НЕПРАВИЛЬНО: Простое хеширование пароля без соли
def insecure_hash_password(password):
return hashlib.sha256(password.encode('utf-8')).hexdigest()

# НЕПРАВИЛЬНО: Уязвимое сравнение хешей (подвержено timing-атакам)
def vulnerable_verify(stored_hash, password):
calculated_hash = hashlib.sha256(password.encode('utf-8')).hexdigest()
return stored_hash == calculated_hash # Уязвимо к timing-атакам

# ПРАВИЛЬНО: Безопасное хеширование пароля
def secure_hash_password(password):
salt = os.urandom(32)
password_hash = hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt, 100000)
return {'salt': salt, 'hash': password_hash}

# ПРАВИЛЬНО: Безопасное сравнение хешей
def secure_verify(stored_info, password):
calculated_hash = hashlib.pbkdf2_hmac(
'sha256', 
password.encode('utf-8'), 
stored_info['salt'], 
100000
)
return hmac.compare_digest(calculated_hash, stored_info['hash']) # Защищено от timing-атак

def verify_and_upgrade_if_needed(user_id, stored_password_info, provided_password):
"""
Проверяет пароль и обновляет хеш, если используется устаревший алгоритм.

:param user_id: Идентификатор пользователя
:param stored_password_info: Сохраненная информация о пароле
:param provided_password: Предоставленный пароль
:return: True, если пароль верен, иначе False
"""
# Проверка текущим методом
is_valid = verify_password(stored_password_info, provided_password)

if is_valid:
# Проверяем необходимость обновления
if needs_upgrade(stored_password_info):
# Хеширование пароля по новому алгоритму
new_password_info = hash_password_with_latest_algorithm(provided_password)
# Сохранение нового хеша в базе данных
update_password_in_database(user_id, new_password_info)
print("Хеш пароля обновлен до более современного алгоритма")

return is_valid

def needs_upgrade(stored_info):
"""
Определяет, нужно ли обновить метод хеширования.

:param stored_info: Информация о хеше пароля
:return: True, если требуется обновление
"""
# Примеры причин для обновления:
# – Устаревший алгоритм (MD5, SHA-1)
# – Недостаточное количество итераций
# – Отсутствие соли

if 'algorithm' in stored_info:
if stored_info['algorithm'] in ['md5', 'sha1']:
return True

if 'iterations' in stored_info:
if stored_info['iterations'] < 100000:
return True

return False