几个概念
OAuth2
OAuth2是一个规范,它定义了几种处理身份认证和授权的方法。
它是一个相当广泛的规范,涵盖了一些复杂的使用场景。
它包括了使用第三方进行身份认证的方法。
详细介绍见OAuth2官网。
OpenID Connect
OpenID Connect是另一个基于OAuth2的规范。
它只是扩展了OAuth2,并明确了一些在OAuth2中相对模糊的内容,以尝试使其更具操作性。
详细介绍见OpenID Connect官网
OpenAPI
fastapi基于OpenAPI。
OpenAPI有一种定义多个安全方案的方法。
通过它们,可以利用所有这些基于标准的工具,包括这些交互式文档系统。
详细介绍见OpenAPI官网
OpenAPI定义了以下安全方案:
- apikey:一个特定于应用程序的密钥,可以来自:
- 查询参数
- 请求头
- cookie
- http:标准的HTTP身份认证系统,包括:
- bearer:一个值为Bearer加令牌字符串的Authorization请求头。这是从OAuth2继承的。
- HTTP Basic认证方式
- HTTP Digest,等等
- oauth2:所有的OAuth2处理安全性的方式。
- openIdConnect:提供了一种定义如何自动发现OAuth2身份认证数据的方法。
安全的流程
代码实现
首次登录
步骤1:验证用户名和密码是否正确
步骤2:验证通过后生成token,返回客户端
# 第一步:指定创建token的路径,通常和登录为同一个路径
# OAuth2PasswordBearer被调用时会去获取header中是否有Authorization的值
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/login")
# 第二步:创建token路径的路径装饰器和路径操作函数
@app.post("/login")
# 在创建token中以OAuth2PasswordRequestForm为依赖,作为请求体
# OAuth2PasswordRequestForm默认接收username和password的form数据
async def login(form_data:OAuth2PasswordRequestForm=Depends()):
# 根据用户名首先判断该用户名在数据库中是否存在,如果不存就报错
user_dict = fake_users_db.get(form_data.username)
if not user_dict:
raise HTTPException(status_code=400,detail="Incorrect username")
# 然后获取该用户名在数据库中的加密后的密码
user = UserInDB(**user_dict)
# 根据后端固定的加密规则对输入的用户密码进行加密,
# 然后对比本次输入的加密密码和数据库中存储的加密密码是否一致,不一致报错
hashed_password = fake_hash_password(form_data.password)
if not hashed_password == user.hashed_password:
raise HTTPException(status_code=400,detail="Incorrect pwd")
# 用户名和密码都验证通过后,生成token返回前端
# 通常有一个方法来生成token,此处为了简单,直接用username作为token返回前端
# token_type指定token的类型,是OAuth2协议的规定
return {
"access_token":user.username,
"token_type":"bearer"
}
再次登录
步骤1:验证token
步骤2:验证通过后,进行响应
# 第三步:在后面的请求中,首先都要进行安全性验证
# 即通过token来验证用户信息
# 定义根据用户名在数据库中获取用户信息
def get_user(db,username:str):
if username in db:
user_dict = db[username]
return UserInDB(**user_dict)
# 定义解密token的方法
def fake_decode_token(token):
user = get_user(fake_users_db,token)
return user
# 定义获取当前用户的方法
# 依赖oauth2_scheme去获取请求头中是否有Authorization,其对应的值应该是token
async def get_current_user(token:str = Depends(oauth2_scheme)):
# 解析token
user = fake_decode_token(token)
# 用户不存在时报错
if not user:
raise HTTPException(
status_code=401,
detail="Invalid authentication credentials",
# 此处的headers回复时OAuth2的规定
headers={"WWW-Authenticate": "Bearer"}
)
return user
# 模拟再次请求
@app.get("/users/me")
# 依赖验证token的方法进行二次请求,满足验证时响应,否则报错
async def read_users_me(current_user:User=Depends(get_current_user)):
return current_user
完整代码:
from fastapi import FastAPI,Depends,HTTPException,status
# OAuth2PasswordBearer用来指定生成token的路径
# OAuth2PasswordRequestForm用来指定生成token操作函数的输入
from fastapi.security import OAuth2PasswordBearer,OAuth2PasswordRequestForm
from pydantic import BaseModel
from typing import Union
# fake_users_db用来模拟数据库中存储的用户信息
fake_users_db = {
"johndoe": {
"username": "johndoe",
"full_name": "John Doe",
"email": "johndoe@example.com",
"hashed_password": "fakehashedsecret",
"disabled": False,
},
"alice": {
"username": "alice",
"full_name": "Alice Wonderson",
"email": "alice@example.com",
"hashed_password": "fakehashedsecret2",
"disabled": True,
},
}
# 用户数据模型
class User(BaseModel):
username: str
email: Union[str, None] = None
full_name: Union[str, None] = None
disabled: Union[bool, None] = None
# 用户在数据库中的数据模型
class UserInDB(User):
hashed_password: str
# 用来加密密码
def fake_hash_password(password: str):
return "fakehashed" + password
app = FastAPI()
# 第一步:指定创建token的路径,通常和登录为同一个路径
# OAuth2PasswordBearer被调用时会去获取header中是否有Authorization的值
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/login")
# 第二步:创建token路径的路径装饰器和路径操作函数
@app.post("/login")
# 在创建token中以OAuth2PasswordRequestForm为依赖,作为请求体
# OAuth2PasswordRequestForm默认接收username和password的form数据
async def login(form_data:OAuth2PasswordRequestForm=Depends()):
# 根据用户名首先判断该用户名在数据库中是否存在,如果不存就报错
user_dict = fake_users_db.get(form_data.username)
if not user_dict:
raise HTTPException(status_code=400,detail="Incorrect username")
# 然后获取该用户名在数据库中的加密后的密码
user = UserInDB(**user_dict)
# 根据后端固定的加密规则对输入的用户密码进行加密,
# 然后对比本次输入的加密密码和数据库中存储的加密密码是否一致,不一致报错
hashed_password = fake_hash_password(form_data.password)
if not hashed_password == user.hashed_password:
raise HTTPException(status_code=400,detail="Incorrect pwd")
# 用户名和密码都验证通过后,生成token返回前端
# 通常有一个方法来生成token,此处为了简单,直接用username作为token返回前端
# token_type指定token的类型,是OAuth2协议的规定
return {
"access_token":user.username,
"token_type":"bearer"
}
# 第三步:在后面的请求中,首先都要进行安全性验证
# 即通过token来验证用户信息
# 定义根据用户名在数据库中获取用户信息
def get_user(db,username:str):
if username in db:
user_dict = db[username]
return UserInDB(**user_dict)
# 定义解密token的方法
def fake_decode_token(token):
user = get_user(fake_users_db,token)
return user
# 定义获取当前用户的方法
# 依赖oauth2_scheme去获取请求头中是否有Authorization,其对应的值应该是token
async def get_current_user(token:str = Depends(oauth2_scheme)):
# 解析token
user = fake_decode_token(token)
# 用户不存在时报错
if not user:
raise HTTPException(
status_code=401,
detail="Invalid authentication credentials",
# 此处的headers回复时OAuth2的规定
headers={"WWW-Authenticate": "Bearer"}
)
return user
# 模拟再次请求
@app.get("/users/me")
# 依赖验证token的方法进行二次请求,满足验证时响应,否则报错
async def read_users_me(current_user:User=Depends(get_current_user)):
return current_user
if __name__ == "__main__":
import uvicorn
uvicorn.run(app="main:app",host="127.0.0.1",port=8080,reload=True)
测试结果:
首次登录:获取token
访问其他页面:发送token
token中加入Bearer是由token_type决定的。
JWT生成token
安装 python-jose[cryptography],生成jwt token
安装passlib[bcrypt]用来处理哈希密码
完整代码:
from datetime import datetime, timedelta
from typing import Union
from fastapi import FastAPI,Depends,HTTPException,status
from fastapi.security import OAuth2PasswordBearer,OAuth2PasswordRequestForm
from jose import JWTError,jwt
from passlib.context import CryptContext
from pydantic import BaseModel
# 模拟数据库中的用户记录
fake_users_db = {
"johndoe": {
"username": "johndoe",
"full_name": "John Doe",
"email": "johndoe@example.com",
"hashed_password": "$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW",
"disabled": False,
}
}
# 定义token的回复数据模型
class Token(BaseModel):
access_token: str
token_type: str
class TokenData(BaseModel):
username: Union[str, None] = None
# 定义用户回复数据模型
class User(BaseModel):
username: str
email: Union[str, None] = None
full_name: Union[str, None] = None
disabled: Union[bool, None] = None
# 定义数据库中用户数据模型
class UserInDB(User):
hashed_password: str
# to get a string like this run:
# openssl rand -hex 32
SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30
# 加密模式,用来加密和验证密码
pwd_context = CryptContext(schemes=['bcrypt'],deprecated="auto")
# 加密密码
def get_password_hash(password):
return pwd_context.hash(password)
# 验证密码
def verify_password(plain_password,hashed_password):
return pwd_context.verify(plain_password,hashed_password)
# 根据用户名在数据库中获取用户信息
def get_user(db, username: str):
if username in db:
user_dict = db[username]
return UserInDB(**user_dict)
# 验证用户名和密码
def authenticate_user(fake_db, username: str, password: str):
user = get_user(fake_db, username)
if not user:
return False
if not verify_password(password, user.hashed_password):
return False
return user
# 创建token
def create_access_token(data: dict, expires_delta: Union[timedelta, None] = None):
to_encode = data.copy()
# 追加过期时间
if expires_delta:
expire = datetime.utcnow() + expires_delta
else:
expire = datetime.utcnow() + timedelta(minutes=15)
to_encode.update({"exp": expire})
# 注意此处的to_encode中的键,解token后也通过这些键来取值!
# 利用密钥和加密算法生成token
encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
return encoded_jwt
# 定义token创建和获取方法
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/login")
app = FastAPI()
# 首次登录
@app.post("/login", response_model=Token)
async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
user = authenticate_user(fake_users_db, form_data.username, form_data.password)
if not user:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Incorrect username or password",
headers={"WWW-Authenticate": "Bearer"},
)
access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
access_token = create_access_token(
data={"sub": user.username}, expires_delta=access_token_expires
)
return {"access_token": access_token, "token_type": "bearer"}
# 获取当前用户
async def get_current_user(token: str = Depends(oauth2_scheme)):
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
try:
# 解token
payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
username: str = payload.get("sub")
if username is None:
raise credentials_exception
token_data = TokenData(username=username)
except JWTError:
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
raise credentials_exception
return user
# 验证用户是否处于激活状态
async def get_current_active_user(current_user: User = Depends(get_current_user)):
if current_user.disabled:
raise HTTPException(status_code=400, detail="Inactive user")
return current_user
# 再次访问
@app.get("/users/me/", response_model=User)
async def read_users_me(current_user: User = Depends(get_current_active_user)):
return current_user
@app.get("/users/me/items/")
async def read_own_items(current_user: User = Depends(get_current_active_user)):
return [{"item_id": "Foo", "owner": current_user.username}]
if __name__ == "__main__":
import uvicorn
uvicorn.run(app="produce:app",host="127.0.0.1",port=8080,reload=True)
验证结果:
首次登录返回获得token
再次访问利用token访问