Se deparar com um sistema de autenticação sendo um programador é muito comum porque hoje quase todo sistema web precisa controlar e manter dados de seus clientes e como boa parte deles são recursos sensíveis, é necessário mante-los seguros. Gosto de pensar que a segurança, assim como muitos requisitos não funcionais de uma api, pode ser mensurado ou testado imaginando vários cenários. Em um serviço de autenticação, por exemplo, podemos pensar: e se um alguém tentar descobrir a senha de um usuário através de força bruta, e se outro usuário tentar utilizar o token de acesso de um outro cliente, e se, acidentalmente, dois usuários criam suas credenciais com a mesma senha, etc.
Imaginando essas situações conseguimos nos antecipar e criar medidas preventivas. Criar critérios para a senha podem fazer com que seja muito difícil descobri-la através de força bruta, ou aplicar um rate limit na sua api pode impedir ações maliciosas, por exemplo. Neste artigo pretendo focar no problema do último cenário. Dois usuários se cadastrando no mesmo sistema com a mesma senha é uma brecha grave no sistema.
É uma boa prática manter as senhas dos usuários criptografadas no banco, o que mantém os dados mais seguros contra vazamentos. O código abaixo mostra como funciona um sistema simples de cadastro de credenciais em 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
As 4 primeiras linhas são a definição da classe utilizando o decorator @dataclass para omitirmos o método construtor, as suas propriedades e a assinatura da função. Dentro do bloco try/except primeiro é definido o timestamp atual, instanciamos o objeto de Hash, atualizamos ele com a senha que é fornecida, salvamos no banco e, por fim, retornamos o id da credencial ao usuário. Aqui você pode pensar "tudo bem... se a senha está criptografada eu não preciso me preocupar, certo ?". Porém não é esse o caso e eu vou explicar.
O que acontece é que quando as senhas são criptografadas isso é feito através de um hash, um tipo de estrutura de dados que mapeia um input para um valor final, porém, se dois inputs são iguais, a mesma senha é armazenada. Isso é o mesmo que dizer que o hash é determinístico. Observe o exemplo abaixo que ilustra uma tabela simples em um banco de dados que armazena o usuário e o hash.
| 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!
Top comments (0)