CRÉATION D'UN SERVICE D'AUTHENTIFICATION EN PYTHON À L'AIDE DE SALT

Trouver un système d'authentification en tant que programmeur est très courant car aujourd'hui presque tous les systèmes Web ont besoin de contrôler et de maintenir les données de leurs clients et comme la plupart d'entre elles sont des ressources sensibles, il est nécessaire de les sécuriser. J'aime penser que la sécurité, comme de nombreuses exigences non fonctionnelles d'une API, peut être mesurée ou testée en imaginant divers scénarios. Dans un service d'authentification, par exemple, nous pouvons penser : que se passe-t-il si quelqu'un essaie de découvrir le mot de passe d'un utilisateur par force brute, que se passe-t-il si un autre utilisateur tente d'utiliser le jeton d'accès d'un autre client, que se passe-t-il si, accidentellement, deux utilisateurs créent leurs identifiants avec le même mot de passe, etc.

En imaginant ces situations, nous pouvons anticiper et créer des mesures préventives. La création de critères pour le mot de passe peut rendre sa découverte très difficile par force brute, ou l'application d'une limite de débit à votre API peut empêcher les actions malveillantes, par exemple. Dans cet article, j'ai l'intention de me concentrer sur le problème du dernier scénario. Deux utilisateurs s'inscrivant sur le même système avec le même mot de passe constituent une grave violation du système.

Il est de bonne pratique de garder les mots de passe des utilisateurs cryptés à la banque, ce qui protège les données contre les fuites. Le code ci-dessous montre comment fonctionne un système simple d'enregistrement des informations d'identification en Python.

@dataclass
class CreateCredentialUsecase:
    _credential_repository: CredentialRepositoryInterface
    _password_salt_repository: PasswordSaltRepositoryInterface

    async def handle(self, data: CreateCredentialInputDto) -> CreateCredentialOutputDto:
        try:
            now = datetime.now()

            self.__hash = sha256()
            self.__hash.update(data.password.encode())
            self.__credential = Credential(
                uuid4(), data.email, self.__hash.hexdigest(), now, now
            )

            credential_id = await self._credential_repository.create(self.__credential)

            return CreateCredentialOutputDto(UUID(credential_id))
        except Exception as e:
            raise e

Les 4 premières lignes sont la définition de la classe utilisant le décorateur @dataclass pour omettre la méthode constructeur, ses propriétés et la signature de la fonction. À l'intérieur du bloc try/sauf, l'horodatage actuel est d'abord défini, nous instancions l'objet Hash, le mettons à jour avec le mot de passe fourni, l'enregistrons dans la banque et, enfin, renvoyons l'identifiant d'identification à l'utilisateur. Ici, vous pourriez penser "d'accord... si le mot de passe est crypté, je n'ai pas à m'inquiéter, n'est-ce pas ?". Cependant, ce n'est pas le cas et je vais vous l'expliquer.

Ce qui se passe, c'est que lorsque les mots de passe sont cryptés, cela se fait via un hachage, un type de structure de données qui mappe une entrée à une valeur finale. Cependant, si deux entrées sont identiques, le même mot de passe est stocké. Cela revient à dire que le hachage est déterministe. Notez l'exemple ci-dessous qui illustre une table simple dans une base de données qui stocke l'utilisateur et le hachage.

user	password
alice@example.com	5e884898da28047151d0e56f8dc6292773603d0d
bob@example.com	6dcd4ce23d88e2ee9568ba546c007c63e8f6f8d6
carol@example.com	a3c5b2c98b4325c6c8c6f6e6dbda6cf17b5d7f9a
dave@example.com	1a79a4d60de6718e8e5b326e338ae533
eve@example.com	5e884898da28047151d0e56f8dc6292773603d0d
frank@example.com	7c6a180b36896a8a8c6a2c29e7d7b1d3
grace@example.com	3c59dc048e885024e146d1e4d9d0e4b2

Neste exemplo, as linhas 1 e 5 compartilham o mesmo hash e, portanto, a mesma senha. Para contornarmos esse problema podemos utilizar o salt.

Vamos colocar um pouco de sal nessa senha...

A ideia é que no momento do cadastro do usuário uma string seja gerada de forma aleatória e seja concatenada a senha do usuário antes das credenciais serem salvas no banco. Em seguida esse salt é salvo em uma tabela separada e deve ser utilizada novamente durante o login do usuário. O código alterado ficaria como o exemplo abaixo:

@dataclass
class CreateCredentialUsecase:
    _credential_repository: CredentialRepositoryInterface
    _password_salt_repository: PasswordSaltRepositoryInterface

    async def handle(self, data: CreateCredentialInputDto) -> CreateCredentialOutputDto:
        try:
            now = datetime.now()

            self.__salt = urandom(32)
            self.__hash = sha256()
            self.__hash.update(self.__salt + data.password.encode())
            self.__credential = Credential(
                uuid4(), data.email, self.__hash.hexdigest(), now, now
            )
            self.__salt = PasswordSalt(
                uuid4(), self.__salt.hex(), self.__credential.id, now, now
            )

            credential_id = await self._credential_repository.create(self.__credential)
            await self._password_salt_repository.create(self.__salt)

            return CreateCredentialOutputDto(UUID(credential_id))
        except Exception as e:
            raise e

Agora é possível notar o salt gerado na linha 59. Em seguida ele é utilizado para gerar o hash junto com a senha que o usuário cadastrou, na linha 61. Por fim ele é instanciado através da classe PasswordSalt na linha 65 e armazenado no banco na linha 70. Por último, o código abaixo é o caso de uso de autenticação/login utilizando o salt.

@dataclass
class AuthUsecase:
    _credential_repository: CredentialRepositoryInterface
    _jwt_service: JWTService
    _refresh_token_repository: RefreshTokenRepositoryInterface

    async def handle(self, data: AuthInputDto) -> AuthOutputDto:
        try:

            ACCESS_TOKEN_HOURS_TO_EXPIRATION = int(
                getenv("ACCESS_TOKEN_HOURS_TO_EXPIRATION")
            )
            REFRESH_TOKEN_HOURS_TO_EXPIRATION = int(
                getenv("REFRESH_TOKEN_HOURS_TO_EXPIRATION")
            )

            self.__credential = await self._credential_repository.find_by_email(
                data.email
            )

            if self.__credential is None:
                raise InvalidCredentials()

            self.__hash = sha256()
            self.__hash.update(
                bytes.fromhex(self.__credential.salt) + data.password.encode()
            )

            if self.__hash.hexdigest() != self.__credential.hashed_password:
                raise InvalidCredentials()

            access_token_expiration_time = datetime.now() + timedelta(
                hours=(
                    ACCESS_TOKEN_HOURS_TO_EXPIRATION
                    if ACCESS_TOKEN_HOURS_TO_EXPIRATION is not None
                    else 24
                )
            )
            refresh_token_expiration_time = datetime.now() + timedelta(
                hours=(
                    REFRESH_TOKEN_HOURS_TO_EXPIRATION
                    if REFRESH_TOKEN_HOURS_TO_EXPIRATION is not None
                    else 48
                )
            )

            access_token_payload = {
                "credential_id": self.__credential.id,
                "email": self.__credential.email,
                "exp": access_token_expiration_time,
            }

            access_token = self._jwt_service.encode(access_token_payload)

            refresh_token_payload = {
                "exp": refresh_token_expiration_time,
                "context": {
                    "credential": {
                        "id": self.__credential.id,
                        "email": self.__credential.email,
                    },
                },
            }

            refresh_token = self._jwt_service.encode(refresh_token_payload)
            print(self._jwt_service.decode(refresh_token))

            now = datetime.now()

            await self._refresh_token_repository.create(
                RefreshToken(
                    uuid4(),
                    refresh_token,
                    False,
                    self.__credential.id,
                    refresh_token_expiration_time,
                    now,
                    now,
                    now,
                )
            )

            return AuthOutputDto(
                UUID(self.__credential.id),
                self.__credential.email,
                access_token,
                refresh_token,
            )
        except Exception as e:
            raise e

O tempo de expiração dos tokens é recuperado através de variáveis de ambiente e a credencial com o salt são recuperados através do email. Entre as linhas 103 e 106 a senha fornecida pelo usuário é concatenada ao salt e o hash dessa string resultante é gerado, assim é possível comparar com a senha armazenada no banco. Por fim acontecem os processos de criação dos access_token e refresh_token, o armazenamento do refresh_token e o retorno dos mesmos ao client. Utilizar essa técnica é bem simples e permite fechar uma falha de segurança no seu sistema, além de dificultar alguns outros possíveis ataques. O código exposto no texto faz parte de um projeto maior meu e está no meu github: https://github.com/geovanymds/auth.

Espero que esse texto tenha sido útil para deixar os processos de autenticação no seu sistem mais seguros. Nos vemos no próximo artigo!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!