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 versehentlichzwei Benutzer ihre Anmeldeinformationen erstellen? mit demselben Passwortusw.

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.

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

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!