доработай удостоверяющий центр для работы в системе электронного документооборота организации
import os
import logging
import bcrypt  # Для хэширования паролей
import random  # Для генерации случайного серийного номера
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import rsa, padding
import cryptography.x509
from cryptography.x509.oid import NameOID
from datetime import datetime, timedelta
# Настройка логирования
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
class UserManager:
    def __init__(self):
        self.users = {}  # Хранение информации о пользователях в памяти
    def register_user(self, username, password):
        """Регистрация нового пользователя с хэшированным паролем."""
        if username in self.users:
            raise ValueError("Пользователь уже существует.")
        # Генерация соли и хэширование пароля
        salt = bcrypt.gensalt()
        hashed_password = bcrypt.hashpw(password.encode(), salt)
        self.users[username] = hashed_password
        logging.info(f"Пользователь {username} зарегистрирован.")
    def authenticate_user(self, username, password):
        """Аутентификация пользователя."""
        hashed_password = self.users.get(username)
        if hashed_password and bcrypt.checkpw(password.encode(), hashed_password):
            logging.info(f"Пользователь {username} успешно аутентифицирован.")
            return True
        logging.warning(f"Ошибка аутентификации для пользователя: {username}")
        return False
class CryptoProvider:
    def __init__(self):
        self.private_key = None
        self.public_key = None
        self.cert = None
        self.audit_log = []
        self.user_manager = UserManager()  # Инициализация менеджера пользователей
    def log_audit(self, action):
        """Запись операции в журнал аудита."""
        log_entry = f"{datetime.utcnow()}: {action}"
        self.audit_log.append(log_entry)
        logging.info(log_entry)
    def generate_keys(self):
        """Генерация ключей RSA."""
        self.private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=2048,
            backend=default_backend()
        )
        self.public_key = self.private_key.public_key()
        self.log_audit("Generated new RSA key pair.")
    def encrypt(self, plaintext):
        """Шифрование данных с использованием публичного ключа."""
        if self.public_key is None:
            raise ValueError("Публичный ключ не инициализирован.")
        ciphertext = self.public_key.encrypt(
            plaintext.encode(),
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        self.log_audit("Encrypted data.")
        return ciphertext
    def decrypt(self, ciphertext):
        """Дешифрование данных с использованием приватного ключа."""
        if self.private_key is None:
            raise ValueError("Приватный ключ не инициализирован.")
        plaintext = self.private_key.decrypt(
            ciphertext,
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        self.log_audit("Decrypted data.")
        return plaintext.decode()
    def sign(self, data):
        """Создание электронной подписи."""
        if self.private_key is None:
            raise ValueError("Приватный ключ не инициализирован.")
        signature = self.private_key.sign(
            data.encode(),
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
        self.log_audit("Created digital signature.")
        return signature
    def verify(self, data, signature):
        """Проверка электронной подписи."""
        try:
            self.public_key.verify(
                signature,
                data.encode(),
                padding.PSS(
                    mgf=padding.MGF1(hashes.SHA256()),
                    salt_length=padding.PSS.MAX_LENGTH
                ),
                hashes.SHA256()
            )
            self.log_audit("Verified signature successfully.")
            return True
        except Exception as e:
            self.log_audit(f"Failed to verify signature: {e}")
            return False
    def save_keys(self, priv_key_path='private_key.pem', pub_key_path='public_key.pem'):
        """Сохранение ключей в файлы."""
        if self.private_key is None or self.public_key is None:
            raise ValueError("Ключи не сгенерированы.")
        with open(priv_key_path, 'wb') as f:
            f.write(self.private_key.private_bytes(
                encoding=serialization.Encoding.PEM,
                format=serialization.PrivateFormat.TraditionalOpenSSL,
                encryption_algorithm=serialization.NoEncryption()  # Для упрощения
            ))
        with open(pub_key_path, 'wb') as f:
            f.write(self.public_key.public_bytes(
                encoding=serialization.Encoding.PEM,
                format=serialization.PublicFormat.SubjectPublicKeyInfo,
            ))
        self.log_audit("Saved keys to files.")
    def load_keys(self, priv_key_path='private_key.pem', pub_key_path='public_key.pem'):
        """Загрузка ключей из файлов."""
        with open(priv_key_path, 'rb') as f:
            self.private_key = serialization.load_pem_private_key(
                f.read(),
                password=None,
                backend=default_backend()
            )
        with open(pub_key_path, 'rb') as f:
            self.public_key = serialization.load_pem_public_key(
                f.read(),
                backend=default_backend()
            )
        self.log_audit("Loaded keys from files.")
    def create_self_signed_certificate(self, subject_name, validity_days=365):
        """Создание самоподписанного сертификата."""
        subject = issuer = cryptography.x509.Name([
            cryptography.x509.NameAttribute(NameOID.COUNTRY_NAME, subject_name.get('country', 'RU')),
            cryptography.x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, subject_name.get('state', 'Moscow')),
            cryptography.x509.NameAttribute(NameOID.LOCALITY_NAME, subject_name.get('locality', 'Moscow')),
            cryptography.x509.NameAttribute(NameOID.ORGANIZATION_NAME, subject_name.get('organization', 'MyOrg')),
            cryptography.x509.NameAttribute(NameOID.COMMON_NAME, subject_name.get('common_name', 'myorg.com')),
        ])
        # Генерация уникального серийного номера
        serial_number = random.randint(1, 2 ** 64 - 1)  # Генерация случайного целого числа
        self.cert = cryptography.x509.CertificateBuilder().subject_name(
            subject
        ).issuer_name(
            issuer
        ).not_valid_before(
            datetime.utcnow()
        ).not_valid_after(
            datetime.utcnow() + timedelta(days=validity_days)
        ).serial_number(
            serial_number  # Используем целое число
        ).public_key(
            self.public_key
        ).sign(self.private_key, hashes.SHA256(), default_backend())
        self.log_audit("Created self-signed certificate.")
    def save_certificate(self, cert_path='certificate.pem'):
        """Сохранение сертификата в файл."""
        if self.cert is None:
            raise ValueError("Сертификат не создан.")
        with open(cert_path, 'wb') as f:
            f.write(self.cert.public_bytes(serialization.Encoding.PEM))
        self.log_audit("Saved certificate to file.")
    def load_certificate(self, cert_path='certificate.pem'):
        """Загрузка сертификата из файла."""
        with open(cert_path, 'rb') as f:
            self.cert = cryptography.x509.load_pem_x509_certificate(
                f.read(),
                default_backend()
            )
        self.log_audit("Loaded certificate from file.")
    def get_audit_log(self):
        """Получение журнала аудита."""
        return self.audit_log
# Пример использования
if __name__ == "__main__":
    cp = CryptoProvider()
    # Регистрация пользователя
    username = input("Введите имя пользователя для регистрации: ")
    password = input("Введите пароль для регистрации: ")
    cp.user_manager.register_user(username, password)
    # Аутентификация
    username_login = input("Введите имя пользователя для входа: ")
    password_login = input("Введите пароль для входа: ")
    if cp.user_manager.authenticate_user(username_login, password_login):
        # После успешной аутентификации можно продолжить работу
        cp.generate_keys()
        message = "Hello, World!"
        ciphertext = cp.encrypt(message)
        print("Encrypted message:", ciphertext)
        decrypted_message = cp.decrypt(ciphertext)
        print("Decrypted message:", decrypted_message)
        signature = cp.sign(message)
        print("Signature:", signature)
        is_valid = cp.verify(message, signature)
        print("Signature valid:", is_valid)
        cp.save_keys()
        # Загрузка ключей
        cp2 = CryptoProvider()
        cp2.load_keys()
        print("Keys loaded successfully.")
        # Создание и сохранение самоподписанного сертификата
        cp.create_self_signed_certificate(subject_name={
            'country': 'RU',
            'state': 'Moscow',
            'locality': 'Moscow',
            'organization': 'MyOrg',
            'common_name': 'myorg.com'
        })
        cp.save_certificate()
        # Получение и вывод журнала аудита
        audit_log = cp.get_audit_log()
        print("Audit log:")
        for entry in audit_log:
            print(entry)
    else:
        print("Ошибка аутентификации.")
сделай клиентскую часть для удобства работы в системе электронного документооборота организации