Entendendo CORS e como lidar com ele em JavaScript

O que é CORS e como lidar com ele?

CORS (Cross-Origin Resource Sharing) é um mecanismo que permite que recursos restritos em uma página da web sejam acessados por outra página de um domínio diferente. Isso é importante para garantir a segurança em aplicações web, limitando quais recursos podem ser acessados por sites externos. O problema de CORS ocorre quando uma página tenta fazer uma requisição a um servidor de um domínio diferente daquele da página, e o servidor não permite o acesso. Sem o CORS habilitado corretamente, o navegador bloqueia a requisição por questões de segurança.

Como funciona o CORS?

Por padrão, os navegadores bloqueiam requisições entre diferentes origens (domínios, protocolos ou portas) para proteger a privacidade e a segurança do usuário. O CORS permite que um servidor declare quais origens (domínios, portas ou protocolos) têm permissão para acessar seus recursos. Quando uma requisição é feita de um domínio diferente, o servidor precisa enviar um cabeçalho Access-Control-Allow-Origin para permitir ou negar o acesso.

Exemplo de cabeçalho CORS:

Access-Control-Allow-Origin: https://meudominio.com

Isso indica que apenas o domínio https://meudominio.com pode acessar os recursos do servidor. Caso contrário, o navegador bloqueará a requisição.

Tipos de requisições CORS

As requisições CORS podem ser divididas em dois tipos:

1. Requisições simples: São aquelas que não envolvem cabeçalhos especiais ou métodos HTTP diferentes de GET, POST e HEAD. Essas requisições são verificadas diretamente pelo navegador sem enviar uma requisição prévia de verificação.

Exemplo de requisição simples:

fetch('https://api.exemplo.com/dados', {
  method: 'GET',
  headers: {
    'Content-Type': 'application/json'
  }
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.log('Erro:', error));

Nesse exemplo, o navegador verifica se o servidor permite o acesso, e se não houver a configuração de CORS adequada, a requisição será bloqueada.

2. Requisições complexas: São requisições que usam métodos HTTP como PUT, DELETE, ou que incluem cabeçalhos personalizados. Para essas requisições, o navegador envia uma requisição preliminar OPTIONS para o servidor, verificando se o CORS está habilitado.

Exemplo de requisição complexa:

fetch('https://api.exemplo.com/dados', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'X-Custom-Header': 'valor'
  },
  body: JSON.stringify({ nome: 'João' })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.log('Erro:', error));

Neste caso, o navegador faz uma requisição OPTIONS antes de enviar a requisição real para verificar se o servidor permite requisições complexas.

Como resolver problemas de CORS?

Se você estiver enfrentando problemas de CORS, a solução geralmente envolve a configuração correta no servidor que está sendo acessado. Aqui estão algumas maneiras de lidar com problemas comuns:

1. Permitir origens específicas: Se você está controlando o servidor, adicione o cabeçalho Access-Control-Allow-Origin para permitir que domínios específicos acessem os recursos do servidor.

Exemplo de configuração do servidor:

res.setHeader('Access-Control-Allow-Origin', 'https://meudominio.com');

Isso permitirá que apenas o domínio https://meudominio.com faça requisições para o servidor.

2. Permitir múltiplas origens: Se você deseja permitir múltiplos domínios, você pode configurar o servidor para verificar a origem da requisição e permitir domínios específicos dinamicamente.

Exemplo de configuração dinâmica no servidor:

const allowedOrigins = ['https://meudominio.com', 'https://outrodominio.com'];

if (allowedOrigins.includes(origin)) {
  res.setHeader('Access-Control-Allow-Origin', origin);
}

3. Usar o cabeçalho Access-Control-Allow-Credentials: Quando você estiver lidando com cookies ou autenticação, será necessário incluir o cabeçalho Access-Control-Allow-Credentials, que permite que as credenciais sejam enviadas junto com a requisição.

Exemplo de configuração:

res.setHeader('Access-Control-Allow-Credentials', 'true');

4. Configurar cabeçalhos permitidos: Se você estiver fazendo requisições que envolvem cabeçalhos personalizados (como X-Custom-Header), será necessário configurar o cabeçalho Access-Control-Allow-Headers para permitir esses cabeçalhos.

Exemplo de configuração:

res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Custom-Header');

5. Usar um proxy: Se o servidor não pode ser configurado para permitir CORS, uma solução alternativa é usar um proxy para redirecionar as requisições para o servidor de destino, contornando as limitações de CORS.

Conclusão

O CORS é uma parte importante da segurança da web, permitindo que o navegador controle quais origens podem acessar recursos de um servidor. Ao configurar corretamente os cabeçalhos CORS no servidor, você pode permitir o compartilhamento seguro de recursos entre diferentes origens e resolver problemas comuns relacionados a requisições entre domínios. Embora possa ser frustrante lidar com problemas de CORS, entender como ele funciona e como configurá-lo corretamente pode melhorar significativamente a segurança e a performance das suas aplicações web.

Como configurar o CORS corretamente para segurança em JavaScript

CORS é uma parte importante da segurança em aplicativos web, pois permite que você controle quais origens podem acessar seus recursos. Ao entender como configurar corretamente o CORS, você pode evitar erros e garantir que suas APIs sejam acessíveis de forma segura, sem comprometer a segurança do seu sistema.

Algumas aplicações:

• Configurar o servidor para permitir que domínios específicos acessem seus recursos, melhorando a segurança da aplicação.
• Resolver erros de CORS em APIs para permitir interações entre diferentes domínios.
• Usar CORS de forma controlada para permitir apenas as origens confiáveis que podem acessar os dados.

Dicas para quem está começando

• Certifique-se de que seu servidor esteja configurado corretamente para permitir o acesso de origens específicas.
• Use ferramentas de depuração no navegador para verificar os cabeçalhos CORS e identificar erros em requisições.
• Quando possível, evite permitir qualquer origem com Access-Control-Allow-Origin: * para garantir que apenas origens confiáveis possam acessar seus recursos.
• Se estiver usando cookies ou autenticação, não se esqueça de configurar Access-Control-Allow-Credentials corretamente.

Contribuições de

Patrícia Amaral

Desenvolvedora focada em JavaScript, Node.js e otimização de queries SQL.

Mais sobre o autor

Compartilhe este tutorial