Como superar desafios de segurança com Snyk Code e IA simbólica

Qual é a eficácia da IA simbólica como sistema especialista automatizado para analisar caminhos de código e detectar vulnerabilidades de segurança? O Snyk Code foi testado e demonstra os benefícios de sistemas algorítmicos baseados em regras.

O que é o mecanismo de segurança de IA simbólica da Snyk?

O mecanismo de SAST da Snyk, que realiza análise estática de segurança em bases de código, é baseado em um sistema de IA simbólica, oferecendo mais precisão e execução mais rápida. Ele também aproveita profundamente a experiência de pesquisadores de segurança para fornecer um sistema especialista em segurança fundamentado em regras de vulnerabilidade.

Essas características do Snyk Code conferem superioridade tecnológica em relação à correspondência tradicional de padrões (buscas por expressões regulares semelhantes ao grep) para detectar vulnerabilidades no seu código.

SAST vence desafios de segurança de código

Florin Walter é profissional de segurança e testador de invasão que, nos últimos meses, compartilhou desafios de segurança e publicações de quizzes sobre código seguro no LinkedIn.

Eu queria saber se o Snyk detectaria vulnerabilidades em códigos escritos em diferentes linguagens, então importei o repositório de código de Florin. Vamos analisar os resultados ao longo do restante deste artigo.

Redirecionamento aberto em uma aplicação Flask com Python

Flask é um framework popular para aplicações web em Python. O código Python a seguir usa diferentes rotas para renderizar uma página inicial e uma página de login.

from flask import Flask, request, redirect, url_for
import logging

app = Flask(__name__)

logging.basicConfig(level=logging.INFO)

def is_authenticated_user():
    # This function checks if the user is authenticated and is omitted for brevity
   pass

@app.route('/')
def home():
    if not is_authenticated_user():
        logging.info('Unauthorized access attempt.')
        return redirect(url_for('login'))

    redirect_url = request.args.get('redirect_url')
    if redirect_url:
        logging.info(f'Redirecting to: {redirect_url}')
        return redirect(redirect_url)

    return 'Welcome to the home page!'

@app.route('/login')
def login():
    # Simulated login page
    return 'Login Page - User authentication goes here.'

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

Infelizmente, permitir que usuários e sistemas externos especifiquem uma URL de redirecionamento também traz uma vulnerabilidade inerente de redirecionamento aberto.

Como desenvolvedor, talvez você não tenha percebido isso por precisar se concentrar principalmente nas tarefas relacionadas ao produto, definidas no backlog. Ainda assim, o Snyk executa um teste estático de segurança de aplicações para analisar este código Python e detectar a vulnerabilidade de redirecionamento aberto:

O Snyk vai além de apenas detectar código inseguro. Graças ao mecanismo de machine learning da Snyk, que analisa falhas de segurança e suas correções na comunidade de código aberto, ele consegue deduzir e sugerir a correção de segurança que os desenvolvedores podem aplicar ao código para corrigir essa vulnerabilidade de redirecionamento aberto.

A seguir, uma captura de tela de uma das três correções de código sugeridas pelo Snyk, acompanhada das melhores práticas de prevenção e de informações contextuais sobre esse tipo de vulnerabilidade de segurança:

SSRF e XSS em código JavaScript para uma aplicação Node.js

O próximo desafio de segurança foi escrito em JavaScript e se baseia em uma aplicação web Node.js do lado do servidor, criada com Express:

const express = require('express');
const axios = require('axios');

const app = express();

app.get('/profile', (req, res) => {
    console.log('Received request for /profile');

    // Simulated profile data
    const profileData = {
        name: 'John Doe',
        role: 'Developer'
    };

    res.json(profileData);
    console.log('Sent profile data response');
});

app.get('/fetch-data', async (req, res) => {
    const url = req.query.url;
    console.log(`Received request for /fetch-data with URL: ${url}`);

    try {
        const response = await axios.get(url);
        res.send(response.data);
        console.log(`Data fetched and sent for URL: ${url}`);
    } catch (error) {
        console.error(`Error fetching data from URL: ${url}`, error);
        res.status(500).send('Error fetching data');
    }
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});

Dedique um instante para analisar o código e identificar as vulnerabilidades de segurança.

Também importei esse desafio para o Snyk. Veja algumas das descobertas feitas pela ferramenta.

Falsificação de solicitação do lado do servidor (SSRF) com Axios

O Snyk detectou que uma entrada não sanitizada de um parâmetro HTTP (req.query.url) é passada para a biblioteca cliente HTTP axios na linha 24. A variável url especifica o endereço remoto para o qual uma solicitação HTTP será enviada.

Como o usuário pode controlar a URL inteira, ele pode abusar disso e especificar um endereço interno, como http://localhost, ou outros endereços IP internos e reservados para coletar dados e extrair informações.

O Snyk identificou este código inseguro da seguinte forma, mostrando todos os caminhos de código e as linhas relevantes afetadas pela vulnerabilidade:

Vulnerabilidade de cross-site scripting na resposta HTTP do Express

Dando continuidade ao código acima, vulnerável a SSRF devido a uma solicitação HTTP feita com uma variável controlada que contém uma URL completa, o Snyk detectou mais uma vulnerabilidade.

Esta próxima vulnerabilidade é sutil: não se trata apenas de um problema de segurança SSRF. Se você observar com atenção o código destacado na linha 25 pela análise do Snyk, verá que a resposta HTTP está sendo enviada ao navegador sem alterações:

1res.send(response.data)

Por padrão, o Express define os cabeçalhos da resposta HTTP como application/html. Isso significa que, se o invasor controlar o servidor remoto, poderá inserir código JavaScript malicioso para disparar um XSS no lado do cliente, fazendo com que o navegador interprete a resposta HTML completa.

Outra descoberta de código inseguro feita pelo Snyk é uma possível injeção CRLF. Veja este trecho do código da aplicação web Express mostrado acima:

    try {
        const response = await axios.get(url);
        res.send(response.data);
        console.log(`Data fetched and sent for URL: ${url}`);
    } catch (error) {
        console.error(`Error fetching data from URL: ${url}`, error);
        res.status(500).send('Error fetching data');
    }

O SAST da Snyk identifica facilmente essa possível injeção CRLF entre as vulnerabilidades encontradas:

Como o Snyk pode proteger meu código contra vulnerabilidades de segurança?

A ferramenta de teste estático de segurança de aplicações da Snyk, chamada Snyk Code, ajuda desenvolvedores a encontrar vulnerabilidades no código em tempo real, exibindo os problemas de código inseguro diretamente na IDE.

Comece de graça: instale a extensão Snyk para VS Code e acabe com esses bugs de segurança!