Como criar uma API GraphQL segura com Node.js

O GraphQL oferece recursos de segurança integrados, como validação e verificação de tipos. No entanto, ele não resolve totalmente as questões de segurança relacionadas às APIs. Neste artigo, vamos aprender a proteger APIs GraphQL criando uma aplicação simples em Node.js com Fastify e GraphQL.

De acordo com a documentação oficial, GraphQL é uma linguagem de consulta para grafos para APIs e um runtime que executa essas consultas com nossos dados. O GraphQL descreve com clareza os dados da nossa API e permite criar APIs rápidas e flexíveis, dando aos clientes controle total para especificar os dados de que precisam. Assim como o REST, o GraphQL funciona sobre HTTP, é independente de banco de dados e pode ser usado com qualquer linguagem de back-end ou cliente.

Fastify é um framework para Node.js baseado em plugins, altamente eficiente e com excelente desempenho, ideal para criar servidores HTTP rápidos. Inspirado em Hapi e Express, o Fastify é uma alternativa mais amigável para desenvolvedores e com melhor desempenho, além de ter baixo overhead.

O Fastify oferece suporte ao GraphQL por meio do plugin Mercurius. O plugin Mercurius é um adaptador GraphQL configurável para Fastify, e vamos conhecê-lo melhor nas próximas seções.

Vamos começar pelos pré-requisitos.

Pré-requisitos

Estes são os pré-requisitos para acompanhar este artigo:

• Node.js versão 12 ou superior

• Conhecimentos básicos de JavaScript

• Conhecimentos básicos de GraphQL

Primeiros passos

Para começar, precisamos criar um servidor básico em Node.js.

Crie uma pasta para o projeto e, dentro dela, execute o código abaixo na interface de linha de comando (CLI). Isso vai configurar nossa aplicação e instalar as dependências necessárias.

1// bootstrap npm project
2npm init -y
3
4// install dependencies
5npm i fastify nodemon fastify-plugin mercurius-auth jsonwebtoken

Este projeto usa uma versão específica do Mercurius. Para instalá-la, execute o seguinte comando:

1npm i mercurius@7.9.1

Em seguida, habilitamos os módulos ES6 para usar o sistema padrão de módulos JavaScript em vez do commonJS. Para isso, adicionamos "type": "module" ao arquivo package.json.

Depois, atualizamos os scripts do NPM com um comando para iniciar o servidor Node.js. Para isso, abrimos o arquivo package.json e editamos a seção de scripts da seguinte forma:

1"scripts": {
2    // start the Node.js server in production
3    "start": "node --es-module-specifier-resolution=node ./src/index.js",
4    // use nodemon to restart development server when code is compiled
5    "dev": "nodemon --es-module-specifier-resolution=node ./src/index.js"
6}

Observe que o trecho --es-module-specifier-resolution=node é necessário para habilitar a interoperabilidade entre os módulos ES e os módulos commonJS do Node.

Agora, crie um diretório src no diretório raiz. Dentro dele, crie uma pasta graphql com os arquivos schema.js e resolvers.js. Adicione o código a seguir ao arquivo schema.js:

1const schema =`
2  type Query {
3    users: [User]!
4  }
5
6  type User {
7    id: ID!
8  }
9  `;
10  export default schema;

Agora, adicione o código a seguir ao arquivo resolvers.js:

1const resolvers = {};
2export default resolvers;

Na próxima seção, vamos atualizar o schema.js e adicionar o arquivo resolvers.js. Mas precisamos criá-los agora com algum código básico, pois eles são necessários para que nosso servidor funcione corretamente.

No diretório src, crie um arquivo index.js com o seguinte código:

1import fastify from 'fastify';
2import mercurius from 'mercurius';
3import jwt from 'jsonwebtoken';
4import mercuriusAuth from 'mercurius-auth';
5import schema from './graphql/schema.js'; 
6import resolvers from './graphql/resolvers.js';
7
8const port = process.env.PORT || 4500;
9const app = fastify({ logger: true });
10
11// Activate plugins below:
12app.register(
13  mercurius, { 
14      schema, 
15      resolvers, 
16      graphiql: 'playground', 
17      queryDepth: 7 
18});
19
20// register auth policy
21
22// create server
23const start = async () => {
24  try {
25    await app.listen(port);
26  } catch (err) {
27    app.log.error(err);
28    process.exit(1);
29  }
30};
31start();

O código acima cria um servidor Fastify principal e registra o plugin Mercurius com as opções: schema, resolvers, graphiql e queryDepth.

Agora podemos iniciar o servidor executando npm run dev. A saída será:

1{"level":30,"time":1620202591072,"pid":11775,"hostname":"pc-name","msg":"Server listening at http://127.0.0.1:4500"}

Agora podemos ver que nosso servidor está funcionando. Na próxima seção, vamos começar a criar nossas APIs de blog com GraphQL.

Como criar uma API de blog segura com Fastify e GraphQL

Há várias estratégias para proteger uma API. Entre elas estão:

• Autenticação e autorização: A autenticação confirma se uma pessoa é quem diz ser, enquanto a autorização trata das permissões. A autenticação determina se alguém pode fazer login e, em seguida, mantém essa pessoa identificada. Já a autorização determina quais permissões são atribuídas a uma pessoa identificada e controla se ela pode realizar operações como criar, ler, atualizar ou excluir.

• Ocultação de erros: Não revelar informações exatas sobre um erro do servidor evita que detalhes que possam expor vulnerabilidades sejam fornecidos ao cliente sem intenção.

• Limite de profundidade das consultas: Definir uma profundidade máxima para as consultas GraphQL. Consultas muito aninhadas são perigosas porque exigem muitos recursos e têm um alto custo de processamento. Como consequência, podem derrubar nossas APIs.

• Sanitização e validação de entradas: Usar técnicas padrão de segurança para a Web para impedir que usuários enviem dados maliciosos. Vamos aproveitar a validação integrada do GraphQL na nossa aplicação.

Neste artigo, vamos criar e proteger nossas APIs usando as estratégias acima, com o Mercurius e o plugin Mercurius Auth.

Para o que precisamos, o plugin Mercurius Auth tem dois recursos principais. Primeiro, ele permite definir diretivas de autenticação personalizadas para campos do nosso schema. Essas diretivas são strings usadas como identificadores para os campos protegidos no schema.

Além disso, ele permite aplicar políticas de autenticação personalizadas a esses campos protegidos ao fazer uma solicitação GraphQL.

Vamos começar criando dados simulados. No diretório src, crie uma pasta data com um arquivo index.js que contenha o código abaixo:

1export default {
2    users: [
3        { id: 1, username: 'JohnDoe', email: 'John_doe@gmail.com', password: '12345', role: 'admin' },
4        { id: 2, username: 'JaneDoe', email: 'Jane_doe@gmail.com', password: '12345', role: 'user' },
5        { id: 3, username: 'JoeDoe', email: 'Joe_doe@gmail.com', password: '12345', role: 'user' }
6    ]
7};

Em seguida, configuramos o schema substituindo o código básico do arquivo schema.js pelo código a seguir:

1const schema = `
2
3directive @auth(
4    requires: Role = ADMIN,
5  ) on OBJECT | FIELD_DEFINITION
6
7  enum Role {
8    ADMIN
9    USER
10  }
11
12type Query {
13    user(id: ID!): User! @auth(requires: ADMIN)
14    users: [User]! @auth(requires: ADMIN)
15    login(username:String!, password:String!): String
16}
17
18type User {
19    id: ID!
20    username: String!
21    email: String!
22    password: String!
23    role: String!
24}
25`;
26
27export default schema;

No código acima, criamos nosso schema GraphQL e definimos diretivas de autenticação para os campos user e users. Em seguida, vamos aplicar políticas personalizadas a esses campos protegidos.

Agora, adicionamos nossos resolvers substituindo o código básico do arquivo resolvers.js pelo código a seguir:

1import jwt from 'jsonwebtoken';
2import Data from '../data';
3
4const resolvers = {
5    Query: {
6        users: async (_, obj) => Data.users,
7
8        user: async (_, { id }) => {
9            let user = Data.users.find((user) => user.id == id);
10            if (!user) {
11                throw new Error('unknown user');
12            }
13            return user;
14        },
15
16        login: async (_, { username, password }) => {
17            let user = Data.users.find((user) => user.username === username && user.password === password);
18            if (!user) {
19                throw new Error('unknown user!');
20            }
21
22            const token = jwt.sign({ username: user.username, password: user.password, role: user.role }, 'mysecrete');
23            return token;
24        }
25    }
26};
27
28export default resolvers;

O código acima contém resolvers para lidar com as consultas user, users e login.

Por fim, precisamos adicionar uma política de autenticação personalizada registrando o plugin Mercurius Auth. Para isso, no arquivo index.js do diretório src, adicionamos o código a seguir abaixo do comentário register auth policy, que está na linha 19:

1app.register(mercuriusAuth, {
2    authContext(context) {
3        return { identity: context.reply.request.headers['x-user'] };
4    },
5    async applyPolicy(authDirectiveAST, parent, args, context, info) {
6        const token = context.auth.identity;
7        try {
8            const claim = jwt.verify(token, 'mysecrete');
9        } catch (error) {
10            throw new Error(`An error occurred. Try again!`);
11        }
12
13        return true;
14    },
15    authDirective: 'auth'
16});

Na política personalizada acima, o método authContext recupera o token do usuário nos cabeçalhos, enquanto o método applyPolicy contém políticas personalizadas de autenticação e autorização.

Além disso, quando a autenticação ou autorização de um usuário falha, geramos um erro com uma mensagem genérica, como “Ocorreu um erro. Tente novamente!”. Essa mensagem é exibida no lugar de uma mensagem detalhada de erro do servidor, que poderia expor vulnerabilidades existentes.

Com isso, concluímos nosso trabalho. Na próxima seção, vamos testar nossas APIs.

Como testar a API

Primeiro, iniciamos o servidor executando npm run dev no diretório raiz. Em seguida, acessamos o GraphQL Playground em http://localhost:4500/playground.

Agora, ao consultar qualquer API protegida, como users ou user, recebemos um erro, como mostrado abaixo:

Para que nossa consulta seja bem-sucedida, precisamos nos autenticar. Vamos fazer login para obter um token.

Para fazer login, abra uma nova aba no Playground e execute a seguinte consulta:

1query {
2  login(username: "JohnDoe", password: "12345")
3}

Se a consulta for bem-sucedida, um token será gerado e retornado, como mostrado na imagem abaixo.

Observe que os dados do usuário usados para fazer login já estão no arquivo index.js, no diretório data.

Uma tentativa de fazer login com dados de usuário que não estão nesse arquivo (como o nome de usuário “John1Doe”) resulta em um erro, como mostrado abaixo:

Agora, passando nosso token nos cabeçalhos como x-user, podemos consultar nossas APIs protegidas com sucesso, como mostrado abaixo. Copie o token recebido na consulta de login e use-o como valor de x-user.

Consulta users

Veja um exemplo de consulta users:

1query {
2  users {
3    id
4    username
5    password
6    email
7    role
8  }
9}

Adicione seu token como valor do parâmetro do cabeçalho HTTP x-user, como mostrado abaixo:

1{
2  "x-user": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6IkpvaG5Eb2UiLCJwYXNzd29yZCI6IjEyMzQ1Iiwicm9sZSI6ImFkbWluIiwiaWF0IjoxNjQ0NTA3MDE5fQ.faslGjI6x-ODO2LGYOaTHClGs2MXCBOoMlWPYnwoH18"
3}

O resultado será:

Consulta user

Veja um exemplo de consulta de user:

1query {
2  user(id: "1") {
3    id
4    username
5    email
6    password
7    role
8  }
9}

Adicione seu token como valor do parâmetro do cabeçalho HTTP x-user, como mostrado abaixo:

1{
2  "x-user": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6IkpvaG5Eb2UiLCJwYXNzd29yZCI6IjEyMzQ1Iiwicm9sZSI6ImFkbWluIiwiaWF0IjoxNjQ0NTA3MDE5fQ.faslGjI6x-ODO2LGYOaTHClGs2MXCBOoMlWPYnwoH18"
3}

O resultado será:

Conclusão

Neste artigo, vimos como é fácil proteger APIs GraphQL usando Fastify e GraphQL para criar uma aplicação simples em Node.js.

Como vimos, o GraphQL conta com alguns recursos de segurança integrados, como validação e verificação de tipos. No entanto, a flexibilidade e o poder que permitem aos usuários solicitar dados sob demanda fazem da segurança uma preocupação fundamental.

Este artigo também abordou algumas estratégias para proteger APIs GraphQL: autenticação e autorização, limite de profundidade das consultas, ocultação de erros e sanitização e validação de entradas.

Essas estratégias de segurança são muito eficazes, mas podemos reforçar a proteção com outros métodos, como limites de tempo para consultas e limites de taxa, que definem a frequência com que um cliente pode consultar uma API em cada período.

Experimente nossa ferramenta gratuita on-line de verificação de código JavaScript para ver como o Snyk Code analisa seu código em busca de problemas de segurança e qualidade.