ERSTELLEN EINES AUTHENTIFIZIERUNGSDIENSTES IN PYTHON MIT SALT

Als Programmierer stößt man häufig auf ein Authentifizierungssystem, da heutzutage fast jedes Websystem die Daten seiner Kunden kontrollieren und verwalten muss und da es sich bei den meisten davon um sensible Ressourcen handelt, ist es notwendig, sie zu schützen. Ich denke gerne, dass Sicherheit, wie viele nichtfunktionale Anforderungen einer API, gemessen oder getestet werden kann, indem man sich verschiedene Szenarien vorstellt. Bei einem Authentifizierungsdienst können wir uns zum Beispiel Folgendes vorstellen: Was wäre, wenn jemand mit roher Gewalt versuchen würde, das Passwort eines Benutzers herauszufinden? Was wäre, wenn ein anderer Benutzer versuchen würde, das Zugriffstoken eines anderen Clients zu verwenden? Was wäre, wenn versehentlich zwei Benutzer ihre Anmeldeinformationen erstellen? mit demselben Passwort usw.

Indem wir uns diese Situationen vorstellen, können wir präventive Maßnahmen antizipieren und ergreifen. Das Erstellen von Kriterien für das Passwort kann es sehr schwierig machen, es durch Brute-Force zu entdecken, oder die Anwendung einer Ratenbegrenzung auf Ihre API kann beispielsweise böswillige Aktionen verhindern. In diesem Artikel möchte ich mich auf das Problem des letzten Szenarios konzentrieren. Wenn sich zwei Benutzer auf demselben System mit demselben Passwort registrieren, stellt dies einen schwerwiegenden Verstoß gegen das System dar.

Es ist eine gute Praxis, Benutzerpasswörter in der Bank zu verschlüsseln, um Daten vor Datenlecks zu schützen. Der folgende Code zeigt, wie ein einfaches Registrierungssystem für Anmeldeinformationen in Python funktioniert.

@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

Die ersten 4 Zeilen sind die Klassendefinition unter Verwendung des @dataclass-Dekorators, um die Konstruktormethode, ihre Eigenschaften und die Funktionssignatur wegzulassen. Im try/exclusive-Block wird zunächst der aktuelle Zeitstempel definiert, wir instanziieren das Hash-Objekt, aktualisieren es mit dem bereitgestellten Passwort, speichern es in der Bank und geben schließlich die Anmeldeinformations-ID an den Benutzer zurück. Hier denken Sie vielleicht: „Okay ... wenn das Passwort verschlüsselt ist, brauche ich mir keine Sorgen zu machen, oder?“. Dies ist jedoch nicht der Fall und ich werde es erklären.

Bei der Verschlüsselung von Passwörtern geschieht dies über einen Hash, eine Art Datenstruktur, die eine Eingabe einem Endwert zuordnet. Wenn jedoch zwei Eingaben gleich sind, wird dasselbe Passwort gespeichert. Dies ist dasselbe, als würde man sagen, dass der Hash deterministisch ist. Beachten Sie das folgende Beispiel, das eine einfache Tabelle in einer Datenbank zeigt, die den Benutzer und den Hash speichert.

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!

Das obige ist der detaillierte Inhalt vonERSTELLEN EINES AUTHENTIFIZIERUNGSDIENSTES IN PYTHON MIT SALT. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!