yuzu
1.0.0
A Tangerine-Auth é uma biblioteca Python que fornece utilitários para autenticação do usuário e manuseio seguro de chaves e dados criptografados. Ele usa o BCRYPT para hash de senha e JWT para autenticação baseada em token.
Nota: Tangerine-Auth está atualmente na versão beta. Ainda não é recomendado para uso da produção. Por favor, sinta -se à vontade para baixar e brincar com ele enquanto isso! Estamos trabalhando para adicionar mais testes e documentação. Se você encontrar algum bug ou tiver alguma sugestão, abra um problema no GitHub.
Use PIP para instalar o pacote:
pip install tangerine-authAs etapas gerais para integrar Yuzu em seu aplicativo são as seguintes:
def get_user_by_email ( email ):
conn = psycopg2 . connect ( "postgresql://postgres:<your postgres password>@localhost:5432/local_development" )
cur = conn . cursor ()
cur . execute ( "SELECT * FROM tangerine.users WHERE email = %s" , ( email ,))
user = cur . fetchone ()
cur . close ()
conn . close ()
if user :
return { '_id' : user [ 0 ], 'email' : user [ 1 ], 'password' : user [ 2 ]}
else :
return None
def create_user ( user_data ):
conn = psycopg2 . connect ( "postgresql://<your postgres password>@localhost:5432/local_development" )
cur = conn . cursor ()
cur . execute ( "INSERT INTO tangerine.users (email, password) VALUES (%s, %s) RETURNING id" , ( user_data [ 'email' ], user_data [ 'password' ]))
user_id = cur . fetchone ()[ 0 ]
conn . commit ()
cur . close ()
conn . close ()
return { '_id' : user_id , 'email' : user_data [ 'email' ], 'password' : user_data [ 'password' ]}Crie um objeto Keylime e passe -o para o construtor Yuzu. O objeto Keylime é usado para manusear as chaves e dados criptografados com segurança. Você pode usar o objeto Keylime para criptografar e descriptografar dados e armazenar e recuperar chaves.
Crie um objeto yuzu e passe o objeto Keylime, a função para encontrar um usuário no seu banco de dados e a função para criar um usuário no seu banco de dados.
(Opcional) Yuzu usa BCRYPT para senhas de hash. Opcionalmente, você pode passar uma função de hash personalizada para o construtor Yuzu. A função de hash personalizada deve pegar uma sequência de senha como um argumento e retornar uma string de senha de hash.
Após a conclusão da etapa 3, agora você pode usar o objeto Yuzu para inscrever um novo usuário, fazer login um usuário, registrar um usuário e verificar tokens de autenticação.
Yuzu foi construído para trabalhar com frasco e tangerina, atualmente existem dois Middlewares JWT, empacotados com Yuzu, um para o frasco e outro para a tangerina. Depois de inicializar a classe Yuzu corretamente, você pode usar o middleware de tangerina ligando:
app . use ( auth . jwt_middleware ).A versão Flask JWT Middleware ainda é experimental e pode ser propensa a emoções. Não será recomendado para uso da produção até que tenha sido testado mais minuciosamente. O middleware JWT funciona um pouco diferente no frasco, para usá -lo com o frasco, você o usa como decorador:
from flask import Flask
from yuzu import Yuzu
app = Flask ( __name__ )
def get_user_by_email ( email ):
# Logic to create user in DB
pass
def create_user ( user_data ):
# Logic to create user in DB
pass
auth = Yuzu ( keychain , get_user_by_email , create_user ) # Fill with your functions
@ app . route ( '/secure_route' )
@ auth . flask_jwt_middleware ( auth )
def secure_route ():
# Your secure code here. This will only run if the JWT is valid.
return "This is a secure route"
if __name__ == "__main__" :
app . run ( debug = True )NOTA: O middleware de autenticação anexa os dados do usuário ao objeto CTX. Você pode acessar os dados do usuário em seu manipulador de rota ligando
ctx . auth . user or ctx . get ( "user" )Yuzu é uma classe que fornece funcionalidades de autenticação do usuário. Ele usa o BCRYPT para hash de senha e JWT para criar e verificar os tokens de autenticação.
Abaixo estão os principais métodos da classe Yuzu:
- `__init__(self, keychain, get_user_by_email, create_user, hash_func: Optional[Callable] = None)` : Initializes the Yuzu object .
- `get_config(self, key_name: str) -> str` : Fetches the configuration value for a given key .
- `authenticate(self, email: str, password: str) -> bool` : Checks if the given email and password are valid .
- `generate_auth_token(self, user_id: str, email: str) -> str` : Generates an authentication token for the given user .
- `verify_auth_token(self, token: str) -> dict` : Verifies if the given authentication token is valid .
- `sign_up(self, user_data: dict) -> dict` : Signs up a new user with the given user data .
- `login(self, email: str, password: str) -> Tuple[str, str]` : Logs in a user with the given email and password .
- `logout(self)` : Logs out the current user .
- `jwt_middleware()` : Tangerine middleware for JWT authentication .
- `flask_jwt_middleware(yuzu_instance)` : Flask middleware for JWT authentication .Keylime é uma classe que fornece funcionalidades para manusear teclas com segurança e dados criptografados.
Abaixo estão os principais métodos da classe Keylime:
- `__init__(self, keychain: Dict[str, bytes] = {})` : Initializes the KeyLime object .
- `add_key(self, key_name: str, key: bytes)` : Adds a key to the keychain .
- `remove_key(self, key_name: str)` : Removes a key from the keychain .
- `get_key(self, key_name: str) -> bytes` : Fetches a key from the keychain .
- `encrypt(self, key_name: str, message: str) -> str` : Encrypts a given message using a key from the keychain .
- `decrypt(self, key_name: str, cipher_text: str) -> str` : Decrypts a given cipher text using a key from the keychain .O Coept Geral para isso é que você deseja escrever duas funções, uma para encontrar um usuário no sistema de banco de dados escolhido e outro para criar um usuário no sistema de banco de dados escolhido. Essas funções devem tomar um dicionário de dados do usuário como argumento e retornar um dicionário de dados do usuário. O dicionário de dados do usuário deve conter pelo menos um campo de email e senha. O dicionário de dados do usuário pode conter outros campos que você deseja armazenar no seu banco de dados.
Aqui está um exemplo de como usar as classes Yuzu e Keylime:
from tangerine import Tangerine , Ctx , Router
from pymongo import MongoClient
from tangerine . key_lime import KeyLime
from tangerine . yuzu import Yuzu
import json
import jwt
import hashlib
app = Tangerine ( debug_level = 1 )
client = MongoClient ( 'mongodb://localhost:27017/' )
keychain = KeyLime ({
"SECRET_KEY" : "ILOVECATS" ,
})
def get_user_by_email ( email ):
db = client [ 'mydatabase' ]
users = db [ 'users' ]
query = { 'email' : email }
user = users . find_one ( query )
if user :
user [ '_id' ] = str ( user [ '_id' ]) # Convert ObjectId to string
return user
def create_user ( user_data ):
db = client [ 'mydatabase' ]
users = db [ 'users' ]
result = users . insert_one ( user_data )
if result . inserted_id :
user_data [ '_id' ] = str ( result . inserted_id ) # Convert ObjectId to string
return user_data
auth = Yuzu ( keychain , get_user_by_email , create_user )
# serve static files to any request not starting with /api
app . static ( '^/(?!api).*$' , './public' )
# This is how you define a custom middleware.
def hello_middle ( ctx : Ctx , next ) -> None :
ctx . hello_message = json . dumps ({ "message" : "Hello from middleware!" })
next ()
# ==================== AUTH HANDLERS ====================
def api_hello_world ( ctx : Ctx ) -> None :
ctx . body = ctx . hello_message
ctx . send ( 200 , content_type = 'application/json' )
def signup ( ctx : Ctx ) -> None :
user_data = ctx . request . body
created_user = auth . sign_up ( user_data )
if created_user :
ctx . body = json . dumps ( created_user )
ctx . send ( 201 , content_type = 'application/json' )
else :
ctx . send ( 500 , content_type = 'application/json' )
def login ( ctx : Ctx ) -> None :
user_data = ctx . request . body
email = user_data [ 'email' ]
password = user_data [ 'password' ]
user_id , token = auth . login ( email , password )
print ( ctx . user , "HELLO FROM LOGIN" )
if token :
ctx . body = json . dumps ({ "message" : "Logged in successfully" , "token" : token })
ctx . set_res_header ( "Set-Cookie" , f"auth_token= { token } ; HttpOnly; Path=/" )
ctx . send ( 200 , content_type = 'application/json' )
# Set the token as a cookie or in the response headers
else :
ctx . body = json . dumps ({ "message" : "Invalid credentials" })
ctx . send ( 401 , content_type = 'application/json' )
def logout ( ctx : Ctx ) -> None :
auth . logout ( ctx )
ctx . body = json . dumps ({ "message" : "Logged out successfully" })
ctx . send ( 200 , content_type = 'application/json' )
@ Router . auth_required
def get_protected_content ( ctx : Ctx ) -> None :
ctx . body = json . dumps ({ "message" : "This is protected content. Only authenticated users can see this. I hope you feel special ???." })
ctx . send ( 200 , content_type = 'application/json' )
# ==================== API ROUTES ====================
# if you need to bind more variables to your handler, you can pass in a closure
api_router = Router ( prefix = '/api' )
api_router . post ( '/logout' , logout )
api_router . post ( '/login' , login )
api_router . post ( '/signup' , signup )
api_router . get ( '/hello' , api_hello_world )
# api_router.get('/users', get_and_delete_users)
api_router . get ( '/protected' , get_protected_content )
app . use ( hello_middle )
app . use ( auth . jwt_middleware )
app . use_router ( api_router )
app . start ()Yuzu foi projetado para ser flexível, permitindo que você o adapte às necessidades específicas do seu projeto. Uma maneira pela qual você pode personalizar seu comportamento é alterando as funções de hash e verificação de senha padrão.
Por padrão, Yuzu usa a biblioteca bcrypt para hash e verificação de senha. Se você deseja usar uma abordagem diferente, pode passar suas próprias funções de hash e verificação para o construtor de classe Yuzu. Aqui está um exemplo de como fazer isso:
import hashlib
def my_hash_func ( password : str , salt : str = None ) -> str :
return hashlib . sha256 ( password . encode ()). hexdigest ()
def my_check_password_func ( password : str , hashed_password : str , salt : str = None ) -> bool :
return hashlib . sha256 ( password . encode ()). hexdigest () == hashed_password
auth = Yuzu ( keychain , get_user_by_email , create_user , hash_func = my_hash_func , checkpw_func = my_check_password_func )O uso do argon2 para hashing argon2 é um algoritmo moderno e seguro de hash de senha segura que é recomendada pela competição de hash de senha. Aqui está um exemplo de como usá -lo com Yuzu:
from argon2 import PasswordHasher , exceptions
ph = PasswordHasher ( time_cost = 16 , memory_cost = 65536 )
def my_hash_func ( password : str , salt : str = None ) -> str :
return ph . hash ( password )
def my_check_password_func ( password : str , hashed_password : str , salt : str = None ) -> bool :
try :
return ph . verify ( hashed_password , password )
except exceptions . VerifyMismatchError :
return False
auth = Yuzu ( keychain , get_user_by_email , create_user , hash_func = my_hash_func , checkpw_func = my_check_password_func )Esses exemplos permitem que você mude do algoritmo BCRYPT padrão para SHA256 ou Argon2. Você também pode modificar essas funções para alterar a dificuldade da função de hash (por exemplo, aumentando o número de iterações ou o uso da memória) conforme seus requisitos específicos.
Lembre -se de que alterar essas funções pode ter implicações para a segurança do seu aplicativo. Você deve entender o funcionamento da função de hash escolhida e seus pontos fortes e fracos antes de tomar uma decisão.
