Introdução:

Os ataques de injeção de JavaScript são uma ameaça significativa à segurança dos aplicativos da web. Esses ataques podem levar a violações de dados, ações não autorizadas e vários outros problemas de segurança. Vou guiá-lo através de técnicas avançadas para detectar e prevenir ataques de injeção de JavaScript. Este blog incluirá código de exemplo do mundo real para ajudá-lo a compreender e implementar essas técnicas de forma eficaz.

O que é injeção de JavaScript?

A injeção de JavaScript ocorre quando um invasor consegue injetar código malicioso em um aplicativo da web. Isso pode acontecer por vários meios, como campos de entrada, parâmetros de URL ou até mesmo cookies. Uma vez injetado, o código malicioso pode ser executado no contexto da aplicação web, levando potencialmente ao roubo de dados, ações não autorizadas e outras consequências prejudiciais.

Tipos comuns de ataques de injeção de JavaScript:

1. Cross-Site Scripting (XSS): Injeção de scripts maliciosos em páginas da web visualizadas por outros usuários.
2. XSS baseado em DOM: Manipulação do ambiente DOM para executar JavaScript malicioso.
3. Injeção de SQL: Injeção de comandos SQL que podem executar consultas arbitrárias no banco de dados.

Detectando ataques de injeção de JavaScript:

1. Validação de entrada:

• Valide todas as entradas do usuário tanto no cliente quanto no servidor.
• Use expressões regulares para garantir que as entradas atendam aos formatos esperados.

function validateInput(input) {
    const regex = /^[a-zA-Z0-9_]*$/; // Example regex for alphanumeric and underscore
    return regex.test(input);
}

const userInput = document.getElementById('user-input').value;
if (!validateInput(userInput)) {
    alert('Invalid input');
}

2. Política de Segurança de Conteúdo (CSP):

Implemente CSP para controlar as fontes das quais o JavaScript pode ser carregado e executado.

3.Escapando da entrada do usuário:

Escape de todas as entradas do usuário para evitar a execução de scripts maliciosos.

function escapeHTML(input) {
    const div = document.createElement('div');
    div.appendChild(document.createTextNode(input));
    return div.innerHTML;
}

const safeInput = escapeHTML(userInput);
document.getElementById('output').innerHTML = safeInput;

Prevenindo ataques de injeção de JavaScript:

1. Use declarações preparadas:

Para consultas SQL, use instruções preparadas para evitar injeção de SQL.

const query = 'SELECT * FROM users WHERE username = ?';
db.execute(query, [username], (err, results) => {
    // Handle results
});

2. Limpe as entradas do usuário:

Use bibliotecas como DOMPurify para limpar HTML e evitar ataques XSS.

const cleanInput = DOMPurify.sanitize(userInput);
document.getElementById('output').innerHTML = cleanInput;

Cookies somente HTTP:

Use cookies somente HTTP para impedir o acesso a cookies via JavaScript.

document.cookie = "sessionId=abc123; HttpOnly";

4. Limite os recursos de JavaScript:

Use recursos como Subresource Integrity (SRI) para garantir que apenas scripts confiáveis ​​sejam executados.

Exemplo:

Considere um formulário de login simples que pode ser suscetível à injeção de JavaScript. Veja como você pode protegê-lo:

HTML:

JavaScript:

document.getElementById('login-form').addEventListener('submit', function(event) {
    const username = document.getElementById('username').value;
    const password = document.getElementById('password').value;

    if (!validateInput(username) || !validateInput(password)) {
        alert('Invalid input');
        event.preventDefault();
    }
});

function validateInput(input) {
    const regex = /^[a-zA-Z0-9_]*$/;
    return regex.test(input);
}

Lado do servidor (exemplo Node.js):

const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const mysql = require('mysql');

const db = mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: '',
    database: 'test'
});

app.use(bodyParser.urlencoded({ extended: true }));

app.post('/login', (req, res) => {
    const username = req.body.username;
    const password = req.body.password;

    const query = 'SELECT * FROM users WHERE username = ? AND password = ?';
    db.execute(query, [username, password], (err, results) => {
        if (err) throw err;
        if (results.length > 0) {
            res.send('Login successful');
        } else {
            res.send('Invalid credentials');
        }
    });
});

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

Conclusão:

Detectar e prevenir ataques de injeção de JavaScript é crucial para manter a segurança de seus aplicativos web. Ao implementar as técnicas discutidas neste blog, você pode reduzir significativamente o risco de tais ataques. Lembre-se de validar e limpar todas as entradas do usuário, usar CSP, cookies somente HTTP e limitar os recursos de JavaScript usando SRI.

Fique ligado em mais blogs sobre tópicos avançados de JavaScript e segurança na web. Sinta-se à vontade para compartilhar suas idéias e experiências nos comentários abaixo. Juntos, podemos construir aplicações web mais seguras!