基于角色的身份验证系统快速

Question

我目前正在从事一个快速项目，在该项目中，我使用fastify-jwt为用户创建了持票人令牌。

在路线中，我可以通过以下方式进行操作：

fastify.get(
    "/test",
    {
        preValidation: [fastify.authenticate],
    },
    Collection.functionX
);

因此，只需“正常”用户无法访问某些路线，仅适用于“ admin”用户。通常，此信息在令牌内。我可以通过直接访问该路线访问该功能中的管理员。因此，它直接称为“不允许”。

我找到了Fastify Guard，但它不起作用。

Answer 1

我刚刚在实施中工作，我想在这里离开我的方法，以防其他人觉得这很有用。

Fastify具有出色的插件可以实现，身份验证和授权。授权是验证您是您说的是谁，并且授权是您可以根据自己的身份来访问资源的验证。

我发现最可扩展和可维护的方法是使用插件。我使用的插件是：

1. https://wwwww.npmjs.coms.coms.com/package/ppackage/ppackage/@astfastify/ auth
2. https://www.npmjs.coms.com/package/ppackage/ppackage/ppackage/ppackage/ppackage/ppackage/@fastify/jwtify/jwtify/jwwt

对于使用JWT进行身份验证，您可以创建一个这样的插件：

import fastifyPlugin from 'fastify-plugin';
import fastifyJwt, { FastifyJWTOptions } from '@fastify/jwt';
import { FastifyRequest, FastifyReply } from 'fastify';

export default fastifyPlugin<FastifyJWTOptions>(async (fastify) => {
    fastify.register(fastifyJwt, {
        secret: '',
        decode: { complete: true },
        sign: { algorithm: 'RS256', expiresIn: '1h' },
        decoratorName: 'jwtUser',
    });

    fastify.decorate(
        'authenticate',
        async (request: FastifyRequest, reply: FastifyReply) => {
            try {
                await request.jwtVerify();
            } catch (error) {
                throw fastify.httpErrors.unauthorized();
            }
        }
    );
});

然后，对于授权，您将创建一个这样的插件：

import fastifyPlugin from 'fastify-plugin';
import auth, { FastifyAuthPluginOptions } from '@fastify/auth';
import { FastifyRequest, FastifyReply, FastifyInstance } from 'fastify';

export default fastifyPlugin<FastifyAuthPluginOptions>(
    async (fastify: FastifyInstance) => {
        fastify.register(auth);

        fastify.decorate(
            'authorize',
            async (request: FastifyRequest, reply: FastifyReply) => {

                const allowedRoles = request.routeOptions.config.allowedRoles;

                if (allowedRoles && request.jwtUser.payload.user) {
                    const userRoles = request.jwtUser.payload.user
                        ? request.jwtUser.payload.user.roles
                        : [];

                    if (!allowedRoles.some((role: any) => userRoles.includes(role))) {
                        throw fastify.httpErrors.unauthorized();
                    }
                }
            }
        );
    }
);

您会从需要它们的路线中调用它们：

import { FastifyPluginAsync } from 'fastify';

const root: FastifyPluginAsync = async (fastify, opts): Promise<void> => {
    fastify.get(
        '/',
        {
            schema: {},
            onRequest: [fastify.authenticate],
            config: { allowedRoles: ['admin'] },
            preHandler: fastify.auth([fastify.authorize]),
        },
        (request, reply) => {
            return reply.code(200).send('Welcome!')
        }
    );
};

export default root;

从fastify文档中，身份验证更好在生命周期较早进行以防止DOS攻击。授权可以在稍后进行，就像在汉将步骤中一样。角色的值将通过options.config传递。路由您需要像上面示例一样检查的授权。

对于添加授权和身份验证的装饰器，您可能需要扩展快速类型。您可以这样做：

import 'fastify';
import { FastifyRequest, FastifyReply } from 'fastify';
declare module 'fastify' {

    /**
     * Type function to extend FastifyInstance to work with hook authentication
     * onRequest: [fastify.authenticate] defined at src\plugins\jwtVerification.ts
     */
    type Authenticate = (
        request: FastifyRequest,
        reply: FastifyReply
    ) => Promise<void>;

    /**
     * Type function to extend FastifyInstance to work with hook authentorization
     * preHandler: fastify.auth([fastify.authorize]) defined at src\plugins\roleBasedAutorization.ts
     */
    type Authorize = (
        request: FastifyRequest,
        reply: FastifyReply
    ) => Promise<void>;

    /** Apply the extension */
    interface FastifyInstance {
        authenticate: Authenticate;
        authorize: Authorize;
    }

    /**
     * Interface to extend FastifyContextConfig, so the allowedRoles property can be added to
     * the options.config object in routes using authorization
     */
    interface FastifyContextConfig {
        allowedRoles?: string[];
    }
}

此示例是一般的，并且涵盖了所选路由的授权和身份验证检查。

Answer 2

我知道这个问题已经存在很长时间了。但我将把我的解决方案留在这里：

//import { FastifyRequest, FastifyReply } from 'fastify';
//import { findOneUser } from '../services/userService';

const checkRole = (roles: string[]) => async (
    request: FastifyRequest,
    reply: FastifyReply,
    next: () => void
): Promise<void> => {

    const userId = request.user.id;
    const user = await findOneUser({ id: userId });

    if (!user)
        return reply.status(401)
            .send({ success: false, error: 'Unauthorized' });

    const roleExists = roles.some(role => role === user['role']);

    if (!roleExists) 
        return reply.status(401)
            .send({ success: false, error: 'Unauthorized' });
    
    return next();
};

导入 checkRole 函数并在您想要的路由中使用它（将其包含在 preHandler 中）。

Answer 3

您可以使用firebase身份验证或任何身份验证，并将用户放入具有属性“角色”的架构的数据库中，然后在中间件中检查此角色，例如，如果角色== 0其管理员等等。