资讯

历史

科技

环境与自然

成长

游戏

财经

文学与艺术

美食

健康

家居

文化

情感

汽车

三农

军事

旅行

运动

教育

生活

星座命理

一次完整的OAuth 2.0授权之旅

创作时间:

作者:

@小白创作中心

一次完整的OAuth 2.0授权之旅

引用

来源

https://www.cnblogs.com/LexLuc/p/18665033

OAuth 2.0是现代企业级应用中广泛使用的API认证授权机制。本文将通过详细的原理讲解和代码示例，帮助读者深入理解OAuth 2.0的工作流程，并掌握其实践应用的关键要点。

OAuth 2.0的核心概念

想象在一座图书馆。作为一位访客，您需要先在前台办理借书证。这个场景完美映射了OAuth 2.0中的各个角色：

访客（Resource Owner）= 用户
前台（Authorization Server）= 授权服务器
借书证（Access Token）= 访问令牌
会员卡（Refresh Token）= 刷新令牌
图书（Protected Resource）= 受保护的API资源

详细的授权流程实现

1. 应用注册

首先，第三方应用需要在授权服务器进行注册。这个过程会获得客户端凭证：

// 应用的注册信息
const clientCredentials = {
    client_id: "awesome_app_72910",
    client_secret: "8a7b4c2e9f3d6h5j8k1m",
    redirect_uri: "https://myawesomeapp.com/redirect",
    scope: "product.model.read"
};

2. 构建授权请求

当用户需要访问受保护资源时，我们需要构建授权请求URL：

class AuthorizationManager {
    constructor(credentials) {
        this.credentials = credentials;
        this.authEndpoint = 'https://auth.example.com/oauth/authorize';
    }
    generateAuthUrl() {
        const state = crypto.randomBytes(16).toString('hex');
        
        const params = new URLSearchParams({
            response_type: 'code',
            client_id: this.credentials.client_id,
            redirect_uri: this.credentials.redirect_uri,
            scope: this.credentials.scope,
            state: state
        });
        return `${this.authEndpoint}?${params.toString()}`;
    }
}

3. 处理授权回调

当用户同意授权后，授权服务器会将用户重定向回应用，并附带授权码：

app.get('/redirect', async (req, res) => {
    try {
        // 验证state参数，防止CSRF攻击
        if (req.query.state !== req.session.oauthState) {
            throw new Error('State参数不匹配，可能存在CSRF攻击');
        }
        // 使用授权码换取访问令牌
        const tokenResponse = await fetch('https://auth.example.com/oauth/token', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Authorization': 'Basic ' + Buffer.from(
                    `${clientCredentials.client_id}:${clientCredentials.client_secret}`
                ).toString('base64')
            },
            body: new URLSearchParams({
                grant_type: 'authorization_code',
                code: req.query.code,
                redirect_uri: clientCredentials.redirect_uri
            })
        });
        const tokens = await tokenResponse.json();
        
        // 保存令牌
        await sessionManager.saveAuthTokens(req.session, tokens);
        
        // 重定向到原始页面
        res.redirect(req.session.returnTo || '/');
    } catch (error) {
        console.error('授权回调处理失败:', error);
        res.redirect('/error');
    }
});

令牌生命周期管理

令牌的存储

使用Redis存储会话信息，确保系统的可扩展性：

const session = require('express-session');
const RedisStore = require('connect-redis').default;
const Redis = require('ioredis');
// 创建Redis客户端
const redis = new Redis({
    host: 'localhost',
    port: 6379,
    password: process.env.REDIS_PASSWORD,
    tls: process.env.NODE_ENV === 'production' ? {} : undefined
});
// 配置session中间件
app.use(session({
    store: new RedisStore({ client: redis }),
    secret: process.env.SESSION_SECRET,
    cookie: {
        secure: process.env.NODE_ENV === 'production',
        httpOnly: true,
        maxAge: 24 * 60 * 60 * 1000
    },
    resave: false,
    saveUninitialized: false
}));

令牌刷新机制

当访问令牌即将过期时，使用刷新令牌获取新的访问令牌：

class TokenManager {
    async refreshAccessToken(refreshToken) {
        try {
            const response = await fetch(this.tokenEndpoint, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded',
                    'Authorization': 'Basic ' + Buffer.from(
                        `${this.clientId}:${this.clientSecret}`
                    ).toString('base64')
                },
                body: new URLSearchParams({
                    grant_type: 'refresh_token',
                    refresh_token: refreshToken
                })
            });
            if (!response.ok) {
                const error = await response.json();
                
                if (
                    error.error === 'invalid_grant' || 
                    error.error === 'invalid_token'
                ) {
                    throw new RefreshTokenExpiredError('令牌已过期');
                }
                
                throw new Error('令牌刷新失败');
            }
            return await response.json();
            
        } catch (error) {
            throw error;
        }
    }
}

使用访问令牌访问资源

使用访问令牌调用受保护的API：

async function fetchProducts(accessToken) {
    const response = await fetch('https://api.example.com/products', {
        headers: {
            'Authorization': `Bearer ${accessToken}`,
            'Accept': 'application/json'
        }
    });
    if (!response.ok) {
        if (response.status === 401) {
            throw new TokenExpiredError('访问令牌已过期');
        }
        throw new Error('API请求失败');
    }
    return await response.json();
}

安全性考虑

CSRF防护

通过state参数防止跨站请求伪造：

function generateState() {
    return crypto.randomBytes(32).toString('hex');
}
// 在发起授权请求时
const state = generateState();
req.session.oauthState = state;
// 在回调时验证
if (req.query.state !== req.session.oauthState) {
    throw new Error('State不匹配，可能是CSRF攻击');
}

令牌安全存储

确保令牌只在服务器端处理，避免在前端暴露：

class SessionManager {
    async saveAuthTokens(session, tokens) {
        // 在Redis中安全存储令牌
        session.accessToken = tokens.access_token;
        session.refreshToken = tokens.refresh_token;
        session.expiresAt = Date.now() + (tokens.expires_in * 1000);
        
        // 加密存储
        await this.redis.set(
            `tokens:${session.id}`,
            this.encrypt(JSON.stringify(tokens)),
            'EX',
            tokens.expires_in
        );
    }
}