API认证和授权

📋 课程目标

了解API认证和授权的基本概念和区别
掌握JWT (JSON Web Token)认证机制和实现
掌握OAuth 2.0授权框架和使用场景
了解API密钥认证和基本认证等传统方法
学习如何在不同框架中实现API认证和授权
掌握API安全最佳实践和常见攻击防护

🎯 适用人群

API开发人员
后端工程师
安全工程师
架构师和技术负责人
对API安全感兴趣的开发人员

1. API认证和授权概述

1.1 基本概念

认证 (Authentication)：验证用户身份，确认"你是谁"
授权 (Authorization)：验证用户权限，确认"你能做什么"
身份验证：验证用户身份的过程
访问控制：基于权限的资源访问控制

1.2 常见认证方式

认证方式	安全性	适用场景	优点	缺点
API密钥	低	内部服务调用	简单易用	易泄露，无过期机制
基本认证	低	内部服务，开发环境	简单	明文传输，不安全
JWT	中高	移动应用，单页应用	无状态，易扩展	令牌可能被窃取
OAuth 2.0	高	第三方应用授权	安全，标准化	实现复杂
OpenID Connect	高	单点登录	基于OAuth 2.0，标准化	实现复杂

1.3 授权模式

基于角色的访问控制 (RBAC)：按角色分配权限
基于属性的访问控制 (ABAC)：基于用户属性和环境条件
基于策略的访问控制 (PBAC)：基于策略规则
最小权限原则：只授予必要的权限

2. JWT (JSON Web Token) 认证

2.1 JWT 基本概念

JWT 是一种基于 JSON 的开放标准 (RFC 7519)，用于在各方之间安全地传输信息。

2.1.1 JWT 结构

Header：包含令牌类型和签名算法
Payload：包含声明（用户信息、过期时间等）
Signature：用于验证令牌的完整性

Header.Payload.Signature

2.1.2 JWT 工作流程

用户登录，提供凭证
服务器验证凭证
服务器生成JWT令牌
服务器返回JWT令牌给客户端
客户端在后续请求中携带JWT令牌
服务器验证JWT令牌
服务器处理请求并返回结果

2.2 JWT 实现

2.2.1 Python 实现 (Flask)

python

from flask import Flask, request, jsonify
import jwt
import datetime

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key'

# 登录接口
@app.route('/login', methods=['POST'])
def login():
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')
    
    # 验证用户凭证
    if username == 'admin' and password == 'password':
        # 生成JWT令牌
        token = jwt.encode({
            'user_id': 1,
            'username': username,
            'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
        }, app.config['SECRET_KEY'], algorithm='HS256')
        
        return jsonify({'token': token})
    
    return jsonify({'message': 'Invalid credentials'}), 401

# 保护的接口
@app.route('/protected', methods=['GET'])
def protected():
    token = request.headers.get('Authorization')
    
    if not token:
        return jsonify({'message': 'Token is missing'}), 401
    
    try:
        # 验证JWT令牌
        data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])
        return jsonify({'message': 'Welcome {}!'.format(data['username'])})
    except jwt.ExpiredSignatureError:
        return jsonify({'message': 'Token has expired'}), 401
    except jwt.InvalidTokenError:
        return jsonify({'message': 'Invalid token'}), 401

if __name__ == '__main__':
    app.run(debug=True)

2.2.2 Go 实现 (Gin)

package main

import (
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt/v5"
)

var secretKey = []byte("your-secret-key")

// 自定义Claims
type Claims struct {
    UserID   int    `json:"user_id"`
    Username string `json:"username"`
    jwt.RegisteredClaims
}

// 登录接口
func login(c *gin.Context) {
    var loginData struct {
        Username string `json:"username"`
        Password string `json:"password"`
    }

    if err := c.ShouldBindJSON(&loginData); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"message": "Invalid request"})
        return
    }

    // 验证用户凭证
    if loginData.Username == "admin" && loginData.Password == "password" {
        // 设置过期时间
        expirationTime := time.Now().Add(1 * time.Hour)
        
        // 创建Claims
        claims := &Claims{
            UserID:   1,
            Username: loginData.Username,
            RegisteredClaims: jwt.RegisteredClaims{
                ExpiresAt: jwt.NewNumericDate(expirationTime),
                IssuedAt:  jwt.NewNumericDate(time.Now()),
            },
        }
        
        // 生成Token
        token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
        tokenString, err := token.SignedString(secretKey)
        
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"message": "Failed to generate token"})
            return
        }
        
        c.JSON(http.StatusOK, gin.H{"token": tokenString})
        return
    }
    
    c.JSON(http.StatusUnauthorized, gin.H{"message": "Invalid credentials"})
}

// JWT中间件
func authMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        tokenString := c.GetHeader("Authorization")
        
        if tokenString == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"message": "Token is missing"})
            c.Abort()
            return
        }
        
        claims := &Claims{}
        
        // 解析Token
        token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
            return secretKey, nil
        })
        
        if err != nil || !token.Valid {
            c.JSON(http.StatusUnauthorized, gin.H{"message": "Invalid token"})
            c.Abort()
            return
        }
        
        // 将用户信息存储到上下文中
        c.Set("user_id", claims.UserID)
        c.Set("username", claims.Username)
        
        c.Next()
    }
}

// 保护的接口
func protected(c *gin.Context) {
    username, _ := c.Get("username")
    c.JSON(http.StatusOK, gin.H{"message": "Welcome " + username.(string) + "!"})
}

func main() {
    r := gin.Default()
    
    r.POST("/login", login)
    r.GET("/protected", authMiddleware(), protected)
    
    r.Run(":8080")
}

2.3 JWT 最佳实践

使用强密钥：使用足够长度和复杂度的密钥
设置合理的过期时间：避免令牌长期有效
使用HTTPS：防止令牌被窃取
实现刷新令牌机制：避免频繁登录
包含必要的声明：只包含必要的用户信息
使用适当的签名算法：RS256比HS256更安全
实现令牌撤销机制：处理令牌泄露情况

3. OAuth 2.0 授权框架

3.1 OAuth 2.0 基本概念

OAuth 2.0 是一个开放标准的授权框架，允许用户授权第三方应用访问其在另一个服务上的资源，而不需要共享密码。

3.1.1 核心角色

资源所有者 (Resource Owner)：用户
客户端 (Client)：第三方应用
授权服务器 (Authorization Server)：验证用户身份并颁发令牌
资源服务器 (Resource Server)：存储用户资源的服务器

3.1.2 授权流程

客户端请求用户授权
用户同意授权
客户端获取授权码
客户端使用授权码请求访问令牌
授权服务器颁发访问令牌
客户端使用访问令牌访问资源
资源服务器验证令牌并返回资源

3.2 OAuth 2.0 授权类型

3.2.1 授权码模式 (Authorization Code Grant)

适用场景：Web应用、移动应用

流程：

客户端重定向用户到授权服务器
用户登录并授权
授权服务器重定向用户到客户端，携带授权码
客户端使用授权码请求访问令牌
授权服务器返回访问令牌和刷新令牌

3.2.2 隐式授权模式 (Implicit Grant)

适用场景：单页应用 (SPA)

流程：

客户端重定向用户到授权服务器
用户登录并授权
授权服务器重定向用户到客户端，直接携带访问令牌

3.2.3 密码模式 (Password Grant)

适用场景：第一方应用、可信客户端

流程：

客户端收集用户用户名和密码
客户端使用用户名和密码请求访问令牌
授权服务器验证凭证并返回访问令牌

3.2.4 客户端凭证模式 (Client Credentials Grant)

适用场景：服务器间通信、后台服务

流程：

客户端使用客户端ID和客户端密钥请求访问令牌
授权服务器验证凭证并返回访问令牌

3.3 OAuth 2.0 实现示例

3.3.1 使用GitHub OAuth 2.0

python

from flask import Flask, redirect, request, jsonify
import requests
import json

app = Flask(__name__)

# GitHub OAuth配置
CLIENT_ID = 'your-client-id'
CLIENT_SECRET = 'your-client-secret'
REDIRECT_URI = 'http://localhost:5000/callback'

@app.route('/')
def home():
    return '<a href="/login">Login with GitHub</a>'

@app.route('/login')
def login():
    # 重定向到GitHub授权页面
    github_auth_url = f"https://github.com/login/oauth/authorize?client_id={CLIENT_ID}&redirect_uri={REDIRECT_URI}&scope=user"
    return redirect(github_auth_url)

@app.route('/callback')
def callback():
    # 获取授权码
    code = request.args.get('code')
    
    # 使用授权码请求访问令牌
    token_url = 'https://github.com/login/oauth/access_token'
    headers = {'Accept': 'application/json'}
    data = {
        'client_id': CLIENT_ID,
        'client_secret': CLIENT_SECRET,
        'code': code,
        'redirect_uri': REDIRECT_URI
    }
    
    response = requests.post(token_url, headers=headers, data=data)
    token_info = response.json()
    
    # 使用访问令牌获取用户信息
    if 'access_token' in token_info:
        access_token = token_info['access_token']
        user_url = 'https://api.github.com/user'
        user_headers = {'Authorization': f'token {access_token}'}
        user_response = requests.get(user_url, headers=user_headers)
        user_info = user_response.json()
        
        return jsonify(user_info)
    
    return jsonify({'error': 'Failed to get access token'})

if __name__ == '__main__':
    app.run(debug=True)

3.4 OpenID Connect (OIDC)

OpenID Connect 是基于 OAuth 2.0 的身份认证层，提供了标准化的方式来验证用户身份并获取用户信息。

3.4.1 核心概念

ID令牌 (ID Token)：包含用户身份信息的JWT
用户信息端点 (UserInfo Endpoint)：提供详细的用户信息
发现文档 (Discovery Document)：包含OIDC提供商的配置信息

3.4.2 使用场景

单点登录 (SSO)
第三方应用身份验证
跨域身份验证

4. 传统认证方法

4.1 API密钥认证

实现方式：

在请求头中传递API密钥
在URL参数中传递API密钥
在请求体中传递API密钥

示例：

python

# API密钥认证中间件
@app.before_request
def api_key_authentication():
    api_key = request.headers.get('X-API-Key')
    
    if not api_key:
        return jsonify({'message': 'API key is missing'}), 401
    
    # 验证API密钥
    if api_key != 'valid-api-key':
        return jsonify({'message': 'Invalid API key'}), 401

4.2 基本认证 (Basic Authentication)

实现方式：

使用Base64编码的用户名和密码
在Authorization头中传递

示例：

python

from base64 import b64decode

# 基本认证中间件
@app.before_request
def basic_authentication():
    auth_header = request.headers.get('Authorization')
    
    if not auth_header or not auth_header.startswith('Basic '):
        return jsonify({'message': 'Authentication required'}), 401
    
    # 解码认证信息
    encoded_credentials = auth_header.split(' ')[1]
    decoded_credentials = b64decode(encoded_credentials).decode('utf-8')
    username, password = decoded_credentials.split(':', 1)
    
    # 验证凭证
    if username != 'admin' or password != 'password':
        return jsonify({'message': 'Invalid credentials'}), 401

4.3 摘要认证 (Digest Authentication)

实现方式：

使用哈希算法保护密码
避免明文传输密码

优点：

比基本认证更安全
不需要HTTPS也能提供一定安全性

缺点：

实现复杂
性能开销较大

5. API认证和授权最佳实践

5.1 安全最佳实践

使用HTTPS：防止中间人攻击
实现速率限制：防止暴力破解
使用强密码策略：复杂密码，定期更换
实现账户锁定：防止多次登录失败
使用安全的随机数：生成令牌和密钥
定期轮换密钥：减少密钥泄露风险
实施CORS策略：限制跨域请求
使用内容安全策略 (CSP)：防止XSS攻击

5.2 常见攻击和防护

5.2.1 令牌窃取

防护措施：

使用HTTPS
设置合理的令牌过期时间
实现令牌撤销机制
使用刷新令牌

5.2.2 暴力破解

防护措施：

实施速率限制
账户锁定
验证码
复杂密码策略

5.2.3 跨站请求伪造 (CSRF)

防护措施：

使用CSRF令牌
验证Origin和Referer头
实现SameSite cookie属性

5.2.4 跨站脚本 (XSS)

防护措施：

输入验证和转义
使用内容安全策略
实施HTTP-only cookie

5.3 监控和审计

日志记录：记录所有认证和授权事件
异常检测：识别异常登录和访问模式
审计跟踪：跟踪用户操作和权限变更
安全监控：实时监控安全事件

6. 框架中的API认证实现

6.1 Flask 中的实现

python

from flask import Flask, request, jsonify, g
from flask_httpauth import HTTPTokenAuth
import jwt
import datetime

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key'
auth = HTTPTokenAuth(scheme='Bearer')

# 模拟用户数据库
users = {
    'admin': {'password': 'password', 'id': 1, 'role': 'admin'},
    'user': {'password': 'password', 'id': 2, 'role': 'user'}
}

# 验证令牌
@auth.verify_token
def verify_token(token):
    try:
        data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])
        username = data['username']
        if username in users:
            g.user = users[username]
            return True
    except:
        pass
    return False

# 登录接口
@app.route('/login', methods=['POST'])
def login():
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')
    
    if username in users and users[username]['password'] == password:
        token = jwt.encode({
            'username': username,
            'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
        }, app.config['SECRET_KEY'], algorithm='HS256')
        return jsonify({'token': token})
    
    return jsonify({'message': 'Invalid credentials'}), 401

# 需要认证的接口
@app.route('/protected')
@auth.login_required
def protected():
    return jsonify({'message': f'Welcome {g.user.get("role")} user!'})

# 基于角色的授权
@app.route('/admin-only')
@auth.login_required
def admin_only():
    if g.user.get('role') != 'admin':
        return jsonify({'message': 'Admin access required'}), 403
    return jsonify({'message': 'Welcome admin!'})

if __name__ == '__main__':
    app.run(debug=True)

6.2 Django 中的实现

python

# 使用Django REST Framework
from rest_framework_simplejwt.views import TokenObtainPairView, TokenRefreshView
from rest_framework.permissions import IsAuthenticated, IsAdminUser
from rest_framework.views import APIView
from rest_framework.response import Response

# urls.py
urlpatterns = [
    path('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
    path('api/protected/', ProtectedView.as_view(), name='protected'),
    path('api/admin-only/', AdminOnlyView.as_view(), name='admin_only'),
]

# views.py
class ProtectedView(APIView):
    permission_classes = [IsAuthenticated]
    
    def get(self, request):
        return Response({'message': f'Welcome {request.user.username}!'})

class AdminOnlyView(APIView):
    permission_classes = [IsAuthenticated, IsAdminUser]
    
    def get(self, request):
        return Response({'message': 'Welcome admin!'})

6.3 Gin 中的实现

package main

import (
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt/v5"
)

var secretKey = []byte("your-secret-key")

// 自定义Claims
type Claims struct {
    UserID   int    `json:"user_id"`
    Username string `json:"username"`
    Role     string `json:"role"`
    jwt.RegisteredClaims
}

// 登录接口
func login(c *gin.Context) {
    var loginData struct {
        Username string `json:"username"`
        Password string `json:"password"`
    }

    if err := c.ShouldBindJSON(&loginData); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"message": "Invalid request"})
        return
    }

    // 模拟用户验证
    var userID int
    var role string
    
    if loginData.Username == "admin" && loginData.Password == "password" {
        userID = 1
        role = "admin"
    } else if loginData.Username == "user" && loginData.Password == "password" {
        userID = 2
        role = "user"
    } else {
        c.JSON(http.StatusUnauthorized, gin.H{"message": "Invalid credentials"})
        return
    }

    // 生成Token
    expirationTime := time.Now().Add(1 * time.Hour)
    claims := &Claims{
        UserID:   userID,
        Username: loginData.Username,
        Role:     role,
        RegisteredClaims: jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(expirationTime),
            IssuedAt:  jwt.NewNumericDate(time.Now()),
        },
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    tokenString, err := token.SignedString(secretKey)

    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"message": "Failed to generate token"})
        return
    }

    c.JSON(http.StatusOK, gin.H{"token": tokenString})
}

// JWT中间件
func authMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        tokenString := c.GetHeader("Authorization")

        if tokenString == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"message": "Token is missing"})
            c.Abort()
            return
        }

        claims := &Claims{}
        token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
            return secretKey, nil
        })

        if err != nil || !token.Valid {
            c.JSON(http.StatusUnauthorized, gin.H{"message": "Invalid token"})
            c.Abort()
            return
        }

        c.Set("user_id", claims.UserID)
        c.Set("username", claims.Username)
        c.Set("role", claims.Role)

        c.Next()
    }
}

// 角色验证中间件
func roleMiddleware(requiredRole string) gin.HandlerFunc {
    return func(c *gin.Context) {
        role, exists := c.Get("role")
        if !exists || role != requiredRole {
            c.JSON(http.StatusForbidden, gin.H{"message": "Insufficient permissions"})
            c.Abort()
            return
        }
        c.Next()
    }
}

// 保护的接口
func protected(c *gin.Context) {
    username, _ := c.Get("username")
    c.JSON(http.StatusOK, gin.H{"message": "Welcome " + username.(string) + "!"})
}

// 管理员接口
func adminOnly(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"message": "Welcome admin!"})
}

func main() {
    r := gin.Default()

    r.POST("/login", login)
    r.GET("/protected", authMiddleware(), protected)
    r.GET("/admin-only", authMiddleware(), roleMiddleware("admin"), adminOnly)

    r.Run(":8080")
}

6. API认证和授权总结

6.1 认证方式选择

场景	推荐认证方式	原因
Web应用	OAuth 2.0 授权码模式	安全，支持刷新令牌
单页应用	OAuth 2.0 授权码模式 (PKCE)	防止授权码拦截
移动应用	OAuth 2.0 授权码模式 (PKCE)	安全，用户体验好
服务器间通信	OAuth 2.0 客户端凭证模式	无用户交互，安全
内部服务	API密钥或JWT	简单，高效
第三方集成	OAuth 2.0	标准化，安全

6.2 授权策略设计

基于角色的访问控制 (RBAC)：适合大多数应用场景
基于属性的访问控制 (ABAC)：适合复杂的权限需求
基于策略的访问控制 (PBAC)：适合细粒度的权限管理
最小权限原则：只授予必要的权限
权限继承：简化权限管理

6.3 安全性评估

定期安全审计：检查认证和授权机制
渗透测试：识别安全漏洞
安全扫描：检测常见安全问题
合规性检查：符合行业标准和法规

📁 课程资料

参考文档

工具推荐

JWT调试工具：JWT.io
OAuth 2.0 测试工具：OAuth Tools
API安全扫描：OWASP ZAP
认证库：
- Python: PyJWT, Flask-JWT-Extended
- Go: golang-jwt/jwt
- Node.js: jsonwebtoken

代码示例

🎯 学习总结

API认证和授权是保护API安全的关键组成部分：

认证：验证用户身份，确保只有合法用户能够访问API
授权：验证用户权限，确保用户只能访问其有权限的资源
JWT：无状态认证，适合分布式系统
OAuth 2.0：标准化的授权框架，适合第三方应用集成
安全最佳实践：使用HTTPS、实施速率限制、定期轮换密钥等

通过本课程的学习，你应该能够：

选择合适的认证方式
实现安全的API认证和授权机制
防护常见的安全攻击
设计合理的授权策略

📝 课后作业

实践任务：
- 实现一个基于JWT的认证系统
- 集成GitHub OAuth 2.0登录
- 设计并实现基于角色的访问控制
思考问题：
- 如何处理JWT令牌泄露的情况？
- OAuth 2.0的授权码模式和隐式授权模式有什么区别？
- 如何在微服务架构中实现统一的认证和授权？
案例分析：
- 分析一个实际API的认证和授权机制
- 识别潜在的安全问题并提出改进方案

🔗 相关课程

[171-RESTful API设计规范](./171-RESTful API设计规范.md)
[173-GraphQL API开发](./173-GraphQL API开发.md)
177-API性能优化
178-API网关和服务编排

📞 技术支持

如有任何问题或建议，欢迎通过以下方式联系：

📧 邮箱：your-email@example.com
💬 微信：your-wechat-id
🌐 网站：https://your-website.com

📜 版权声明

本课程内容基于 MIT 许可发布，欢迎学习和分享。

API认证和授权 ​

📋 课程目标 ​

🎯 适用人群 ​

1. API认证和授权概述 ​

1.1 基本概念 ​

1.2 常见认证方式 ​

1.3 授权模式 ​

2. JWT (JSON Web Token) 认证 ​

2.1 JWT 基本概念 ​

2.1.1 JWT 结构 ​

2.1.2 JWT 工作流程 ​

2.2 JWT 实现 ​

2.2.1 Python 实现 (Flask) ​

2.2.2 Go 实现 (Gin) ​

2.3 JWT 最佳实践 ​

3. OAuth 2.0 授权框架 ​

3.1 OAuth 2.0 基本概念 ​

3.1.1 核心角色 ​

3.1.2 授权流程 ​

3.2 OAuth 2.0 授权类型 ​

3.2.1 授权码模式 (Authorization Code Grant) ​

3.2.2 隐式授权模式 (Implicit Grant) ​

3.2.3 密码模式 (Password Grant) ​

3.2.4 客户端凭证模式 (Client Credentials Grant) ​

3.3 OAuth 2.0 实现示例 ​

3.3.1 使用GitHub OAuth 2.0 ​

3.4 OpenID Connect (OIDC) ​

3.4.1 核心概念 ​

3.4.2 使用场景 ​

4. 传统认证方法 ​

4.1 API密钥认证 ​

4.2 基本认证 (Basic Authentication) ​

4.3 摘要认证 (Digest Authentication) ​

5. API认证和授权最佳实践 ​

5.1 安全最佳实践 ​

5.2 常见攻击和防护 ​

5.2.1 令牌窃取 ​

5.2.2 暴力破解 ​

5.2.3 跨站请求伪造 (CSRF) ​

5.2.4 跨站脚本 (XSS) ​

5.3 监控和审计 ​

6. 框架中的API认证实现 ​

6.1 Flask 中的实现 ​

6.2 Django 中的实现 ​

6.3 Gin 中的实现 ​

6. API认证和授权总结 ​

6.1 认证方式选择 ​

6.2 授权策略设计 ​

6.3 安全性评估 ​

📁 课程资料 ​

参考文档 ​

工具推荐 ​

代码示例 ​

🎯 学习总结 ​

📝 课后作业 ​

🔗 相关课程 ​

📞 技术支持 ​

📜 版权声明 ​

评论区

API认证和授权

📋 课程目标

🎯 适用人群

1. API认证和授权概述

1.1 基本概念

1.2 常见认证方式

1.3 授权模式

2. JWT (JSON Web Token) 认证

2.1 JWT 基本概念

2.1.1 JWT 结构

2.1.2 JWT 工作流程

2.2 JWT 实现

2.2.1 Python 实现 (Flask)

2.2.2 Go 实现 (Gin)

2.3 JWT 最佳实践

3. OAuth 2.0 授权框架

3.1 OAuth 2.0 基本概念

3.1.1 核心角色

3.1.2 授权流程

3.2 OAuth 2.0 授权类型

3.2.1 授权码模式 (Authorization Code Grant)

3.2.2 隐式授权模式 (Implicit Grant)

3.2.3 密码模式 (Password Grant)

3.2.4 客户端凭证模式 (Client Credentials Grant)

3.3 OAuth 2.0 实现示例

3.3.1 使用GitHub OAuth 2.0

3.4 OpenID Connect (OIDC)

3.4.1 核心概念

3.4.2 使用场景

4. 传统认证方法

4.1 API密钥认证

4.2 基本认证 (Basic Authentication)

4.3 摘要认证 (Digest Authentication)

5. API认证和授权最佳实践

5.1 安全最佳实践

5.2 常见攻击和防护

5.2.1 令牌窃取

5.2.2 暴力破解

5.2.3 跨站请求伪造 (CSRF)

5.2.4 跨站脚本 (XSS)

5.3 监控和审计

6. 框架中的API认证实现

6.1 Flask 中的实现

6.2 Django 中的实现

6.3 Gin 中的实现

6. API认证和授权总结

6.1 认证方式选择

6.2 授权策略设计

6.3 安全性评估

📁 课程资料

参考文档

工具推荐

代码示例

🎯 学习总结

📝 课后作业

🔗 相关课程

📞 技术支持

📜 版权声明