d0rb/cve-2024-4323Vulnérabilité critique de débordement de tampon de tas dans les fonctions handle_trace_request et parse_trace_request du serveur HTTP Fluent Bit.
Nous exigeons le retour en toute sécurité de tous les citoyens pris en otage par le groupe terroriste Hamas. Nous ne nous reposerons pas tant que chaque otage ne sera pas libéré et ne sera pas rentré chez lui en sécurité. Vous pouvez contribuer à les ramener. https://stories.bringthemhomenow.net/
Les fonctions handle_trace_request et parse_trace_request dans l'implémentation du serveur HTTP de Fluent Bit ont été identifiées comme la source d'une vulnérabilité critique, CVE-2024-4323. Cette vulnérabilité est due à des vérifications de limites et une validation des entrées insuffisantes, conduisant à un potentiel débordement de tampon sur le tas. Cette revue met en évidence la nature de la vulnérabilité, son impact potentiel et les mesures nécessaires pour l'atténuer.
handle_trace_requestCette fonction gère les requêtes HTTP de trace entrantes, en effectuant l'allocation du tampon et la copie des données de la requête.
Code vulnérable :
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_requestCette fonction analyse les données de la requête de trace.
Code vulnérable :
void parse_trace_request(char *buffer, size_t size, struct mk_http_request *request)
{
if (size > MAX_SIZE) {
// Gérer l'erreur
return;
}
// Logique d'analyse
}
Débordement de tampon sur le tas :
Allocation et copie du tampon : la fonction `handle_trace_request` utilise directement la taille des données de la requête entrante pour allouer un tampon et copier les données sans validation appropriée. Cela peut conduire à un débordement de tampon sur le tas si la taille dépasse la mémoire allouée.
Absence de vérification des limites : la fonction `parse_trace_request` effectue une vérification rudimentaire de la taille mais ne s'assure pas que la taille du tampon se trouve dans des limites sûres avant l'analyse.
Validation des entrées :
Validation des entrées inadéquate : les fonctions ne valident pas suffisamment les données de la requête entrante, ce qui les rend vulnérables à des charges malveillantes conçues pour exploiter le débordement de tampon.
Déni de service (DoS) : un attaquant peut concocter une requête qui provoque le plantage de l'application en débordant le tampon du tas, entraînant un déni de service.
Exécution de code à distance (RCE) : dans le pire des cas, un attaquant pourrait exploiter le débordement pour exécuter du code arbitraire sur le serveur, prenant potentiellement le contrôle du système.
Correctif suggéré
Le correctif suivant introduit des vérifications de limites et une validation des entrées pour atténuer la vulnérabilité :
#define MAX_ALLOWED_SIZE 1024 * 1024 // Définir une taille maximale raisonnable
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) {
// Journaliser l'erreur et retourner
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) {
// Gérer l'erreur
return;
}
// Logique d'analyse
// ...
}
Vérification des limites : ajout d'une vérification pour s'assurer que la taille des données entrantes ne dépasse pas une taille maximale définie avant d'allouer le tampon.
Validation des entrées : garantie que les données d'entrée sont validées pour empêcher des requêtes surdimensionnées ou mal formées de provoquer un débordement de tampon.
La vulnérabilité dans les fonctions handle_trace_request et parse_trace_request est un problème critique pouvant entraîner des risques de sécurité graves, notamment un déni de service et une exécution de code à distance. Le correctif proposé atténue efficacement ces risques en introduisant des vérifications de limites robustes et une validation des entrées. Il est impératif d'appliquer ce correctif rapidement et de procéder à des audits de code réguliers pour garantir la sécurité et l'intégrité de l'application Fluent Bit.