MENCIPTA PERKHIDMATAN PENGESAHAN DALAM PYTHON MENGGUNAKAN GARAM

Menemui sistem pengesahan sebagai pengaturcara adalah sangat biasa kerana hari ini hampir setiap sistem web perlu mengawal dan menyelenggara data pelanggannya dan kerana kebanyakannya adalah sumber yang sensitif, adalah perlu untuk memastikannya selamat. Saya suka berfikir bahawa keselamatan, seperti banyak keperluan bukan fungsi API, boleh diukur atau diuji dengan membayangkan pelbagai senario. Dalam perkhidmatan pengesahan, sebagai contoh, kita boleh berfikir: bagaimana jika seseorang cuba menemui kata laluan pengguna melalui kekerasan, bagaimana jika pengguna lain cuba menggunakan token akses pelanggan lain, bagaimana jika, secara tidak sengaja, dua pengguna mencipta bukti kelayakan mereka dengan kata laluan yang sama, dsb.

Dengan membayangkan situasi ini, kita boleh menjangka dan membuat langkah pencegahan. Membuat kriteria untuk kata laluan boleh menyukarkan untuk ditemui melalui kekerasan, atau menggunakan had kadar pada API anda boleh menghalang tindakan berniat jahat, contohnya. Dalam artikel ini saya berhasrat untuk memberi tumpuan kepada masalah senario terakhir. Dua pengguna mendaftar pada sistem yang sama dengan kata laluan yang sama adalah pelanggaran serius dalam sistem.

Adalah amalan yang baik untuk memastikan kata laluan pengguna disulitkan di bank, yang memastikan data lebih selamat daripada kebocoran. Kod di bawah menunjukkan cara sistem pendaftaran kelayakan mudah berfungsi dalam 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

4 baris pertama ialah definisi kelas menggunakan penghias @dataclass untuk menghilangkan kaedah pembina, sifatnya dan tandatangan fungsi. Di dalam blok try/except, cap masa semasa ditakrifkan dahulu, kami membuat instantiate objek Hash, mengemas kininya dengan kata laluan yang disediakan, menyimpannya di bank dan, akhirnya, mengembalikan id kelayakan kepada pengguna. Di sini anda mungkin berfikir "okay... jika kata laluan disulitkan saya tidak perlu risau, bukan?". Walau bagaimanapun, ini tidak berlaku dan saya akan menerangkan.

Apa yang berlaku ialah apabila kata laluan disulitkan ini dilakukan melalui cincang, sejenis struktur data yang memetakan input kepada nilai akhir, namun, jika dua input adalah sama, kata laluan yang sama disimpan. Ini adalah sama dengan mengatakan bahawa hash adalah deterministik. Perhatikan contoh di bawah yang menggambarkan jadual ringkas dalam pangkalan data yang menyimpan pengguna dan cincang.

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!

Atas ialah kandungan terperinci MENCIPTA PERKHIDMATAN PENGESAHAN DALAM PYTHON MENGGUNAKAN GARAM. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!