d0rb/cve-2024-4323Vulnerabilidade crítica de estouro de buffer no heap nas funções handle_trace_request e parse_trace_request do servidor HTTP do Fluent Bit.
Exigimos o regresso seguro de todos os cidadãos que foram feitos reféns pelo grupo terrorista Hamas. Não descansaremos até que todos os reféns sejam libertados e voltem para casa em segurança. Pode ajudar a trazê-los de volta. https://stories.bringthemhomenow.net/
As funções handle_trace_request e parse_trace_request na implementação do servidor HTTP do Fluent Bit foram identificadas como a origem de uma vulnerabilidade crítica, a CVE-2024-4323. Esta vulnerabilidade surge devido a uma verificação insuficiente de limites e validação de entrada, levando a um potencial overflow de buffer na heap. Esta análise destaca a natureza da vulnerabilidade, o seu impacto potencial e as medidas necessárias para a mitigar.
handle_trace_requestEsta função trata pedidos HTTP trace recebidos, realizando a alocação de buffer e a cópia dos dados do pedido.
Código Vulnerável:
static int handle_trace_request(struct flb_hs *hs, struct mk_http_session *session, struct mk_http_request *request)
{
char *buffer;
size_t size;
int ret;
flb_sds_t input_name;
input_name = get_input_name(request);
if (input_name == NULL) {
return -1;
}
size = request->data.len;
buffer = malloc(size);
if (!buffer) {
flb_sds_destroy(input_name);
return -1;
}
memcpy(buffer, request->data.data, size);
ret = parse_trace_request(buffer, size, request);
free(buffer);
flb_sds_destroy(input_name);
return ret;
}
parse_trace_requestEsta função analisa os dados do pedido trace.
Código Vulnerável:
void parse_trace_request(char *buffer, size_t size, struct mk_http_request *request)
{
if (size > MAX_SIZE) {
// Handle error
return;
}
// Parsing logic
}
Heap Buffer Overflow:
Alocação e Cópia do Buffer: A função handle_trace_request utiliza diretamente o tamanho dos dados do pedido recebido para alocar um buffer e copiar os dados, sem a devida validação. Isto pode levar a um overflow de buffer na heap se o tamanho exceder a memória alocada.
Falta de Verificação de Limites: A função parse_trace_request realiza uma verificação rudimentar do tamanho, mas não garante que o tamanho do buffer esteja dentro de limites seguros antes da análise.
Validação de Entrada:
Validação de Entrada Insuficiente: As funções não validam adequadamente os dados do pedido recebido, tornando-as suscetíveis a payloads maliciosos concebidos para explorar o overflow de buffer.
Negação de Serviço (DoS): Um atacante pode criar um pedido que cause o crash da aplicação ao overflow do buffer da heap, levando a uma negação de serviço.
Execução Remota de Código (RCE): No pior cenário, um atacante poderia explorar o overflow para executar código arbitrário no servidor, potencialmente ganhando controlo sobre o sistema.
Correção Sugerida
O seguinte patch introduz verificação de limites e validação de entrada para mitigar a vulnerabilidade:
#define MAX_ALLOWED_SIZE 1024 * 1024 // Define um tamanho máximo razoável
static int handle_trace_request(struct flb_hs *hs, struct mk_http_session *session, struct mk_http_request *request)
{
char *buffer;
size_t size;
int ret;
flb_sds_t input_name;
input_name = get_input_name(request);
if (input_name == NULL) {
return -1;
}
size = request->data.len;
if (size > MAX_ALLOWED_SIZE) {
// Log error and return
flb_sds_destroy(input_name);
return -1;
}
buffer = malloc(size);
if (!buffer) {
flb_sds_destroy(input_name);
return -1;
}
memcpy(buffer, request->data.data, size);
ret = parse_trace_request(buffer, size, request);
free(buffer);
flb_sds_destroy(input_name);
return ret;
}
void parse_trace_request(char *buffer, size_t size, struct mk_http_request *request)
{
if (size > MAX_ALLOWED_SIZE) {
// Handle error
return;
}
// Parsing logic
// ...
}
Verificação de Limites: Adicionada uma verificação para garantir que o tamanho dos dados recebidos não excede um tamanho máximo permitido definido antes de alocar o buffer.
Validação de Entrada: Garantido que os dados de entrada são validados para evitar que pedidos de tamanho excessivo ou malformados causem um overflow de buffer.
A vulnerabilidade nas funções handle_trace_request e parse_trace_request é um problema crítico que pode levar a riscos de segurança graves, incluindo negação de serviço e execução remota de código. O patch proposto mitiga eficazmente estes riscos ao introduzir uma verificação robusta de limites e validação de entrada. É imperativo aplicar este patch prontamente e realizar auditorias regulares ao código para garantir a segurança e integridade da aplicação Fluent Bit.