yuzu
1.0.0
Tangerine-Auth-это библиотека Python, которая предоставляет утилиты для аутентификации пользователей и безопасной обработки ключей и зашифрованных данных. Он использует Bcrypt для хэсширования пароля и JWT для аутентификации на основе токенов.
Примечание: Tangerine-Auth в настоящее время находится в бета-версии. Это еще не рекомендуется для производства. Пожалуйста, не стесняйтесь скачать и поиграть с ним в то же время! Мы работаем над добавлением большего количества тестов и документации. Если вы найдете какие -либо ошибки или у вас есть какие -либо предложения, откройте проблему на GitHub.
Используйте PIP, чтобы установить пакет:
pip install tangerine-authОбщие шаги по интеграции Yuzu в ваше приложение следующие:
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' ]}Создайте объект Keylime и передайте его конструктору Yuzu. Объект Keylime используется для надежной обработки клавиш и зашифрованных данных. Вы можете использовать объект Keylime для шифрования и расшифровки данных, а также для хранения и извлечения ключей.
Создайте объект Yuzu и передайте его объект Keylime, функцию для поиска пользователя в вашей базе данных и функцию для создания пользователя в вашей базе данных.
(Необязательно) Yuzu использует Bcrypt для хэш -паролей. При желании вы можете передать пользовательскую хэш -функцию конструктору Yuzu. Пользовательская хэш -функция должна принимать строку пароля в качестве аргумента и возвращать хеширующую строку пароля.
После завершения шага 3 вы можете использовать объект Yuzu, чтобы зарегистрировать нового пользователя, войти в пользователя, вывести пользователя и проверить токены аутентификации.
Юдзу был построен для работы с Флакой, а также с мандарином, в настоящее время есть два JWT Middlewares, связанные с юзу, один для колбы и один для мандарина. После того, как вы инициализируете класс Yuzu должным образом, вы можете использовать промежуточное программное обеспечение Tangerine, позвонив:
app . use ( auth . jwt_middleware ).Версия Flask Version Jwt промежуточное программное обеспечение по-прежнему экспериментально и может быть подвержено проблеме. Это не будет рекомендовано для использования производства, пока не будет тестировано более тестировано. Промежуточное программное обеспечение JWT работает немного по -разному в колбе, чтобы использовать его с помощью колбы, вы используете его в качестве декоратора:
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 )Примечание. Промежуточное программное обеспечение Auth добавляет пользовательские данные в объект CTX. Вы можете получить доступ к пользовательским данным в вашем обработчике маршрута, позвонив по
ctx . auth . user or ctx . get ( "user" )Yuzu - это класс, который предоставляет функциональные возможности аутентификации пользователя. Он использует Bcrypt для хэшкола пароля и JWT для создания и проверки токенов аутентификации.
Ниже приведены ключевые методы класса 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 - это класс, который обеспечивает функциональные возможности для надежного обработки клавиш и зашифрованных данных.
Ниже приведены ключевые методы класса 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 .Общий конуп для этого заключается в том, что вы хотите написать две функции, одна для поиска пользователя в выбранной вами системе баз данных, и одна для создания пользователя в выбранной вами системе баз данных. Эти функции должны принимать словарь пользовательских данных в качестве аргумента и возвращать словарь пользовательских данных. Словарь пользовательских данных должен содержать по крайней мере поле электронной почты и пароля. Словарь пользовательских данных может содержать любые другие поля, которые вы хотите сохранить в вашей базе данных.
Вот пример того, как использовать классы Yuzu и 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 разработан, чтобы быть гибким, что позволяет вам адаптировать его к конкретным потребностям вашего проекта. Одним из способов настроить его поведение является изменение функций хэшкового и проверки паролей по умолчанию.
По умолчанию Yuzu использует библиотеку bcrypt для хэшкола пароля и проверки. Если вы хотите использовать другой подход, вы можете передать свои собственные функции хэширования и проверки конструктору класса Yuzu. Вот пример того, как это сделать:
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 )Использование Argon2 для хэширования Argon2 - это современный, защищенный алгоритм хеширования паролей, который рекомендуется в конкурсе хеширования паролей. Вот пример того, как использовать его с 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 )Эти примеры позволяют переключаться с алгоритма BCRYPT по умолчанию на SHA256 или Argon2. Вы также можете изменить эти функции, чтобы изменить сложность функции хэш (например, увеличивая количество итераций или использования памяти) в соответствии с вашими конкретными требованиями.
Помните, что изменение этих функций может иметь значение для безопасности вашего приложения. Вы должны понимать работу выбранной хэш -функции, ее сильные и слабые стороны, прежде чем принимать решение.
