CVE-2025-54483: Stack-Based Buffer Overflow Vulnerability in The Biosig Project libbiosig 3.9.0

Overview

CVE-2025-54483 is a severe cybersecurity vulnerability that affects The Biosig Project libbiosig version 3.9.0 and the Master Branch (35a819fa). The vulnerability lies in the MFER parsing functionality, more specifically, a stack-based buffer overflow vulnerability exists that can lead to arbitrary code execution. Given the ubiquity of this software in the field of biomedical signal processing, this vulnerability could potentially compromise a large number of systems, leading to data leakage and unauthorized system access.
This vulnerability is of particular concern due to its severity score of 9.8 out of 10 on the CVSS scale, implying that it is extremely dangerous. Exploitation of this vulnerability could lead to the execution of malicious code, potentially compromising the integrity, confidentiality, and availability of affected systems.

Vulnerability Summary

CVE ID: CVE-2025-54483
Severity: Critical (9.8 CVSS Score)
Attack Vector: Network
Privileges Required: None
User Interaction: None
Impact: System compromise and potential data leakage

Affected Products

Product | Affected Versions

The Biosig Project libbiosig | 3.9.0
The Biosig Project Master Branch | 35a819fa

How the Exploit Works

The vulnerability arises due to insufficient bounds checking when parsing MFER files. When the tag of the parsed file is ‘5’, signifying the number of channels, a malicious actor could craft an MFER file with a length greater than 4. This triggers a buffer overflow, allowing the attacker to overwrite the stack with arbitrary code. This code could then be executed, potentially allowing the attacker to take control of the system or exfiltrate sensitive data.

Conceptual Example Code

While the exact method of exploitation would depend on the specifics of the attacker’s environment and the targeted system, a conceptual example might look something like this:

#include <stdio.h>
#include <string.h>
void malicious_func() {
// Malicious code here
printf("System Compromised!\n");
}
void vulnerable_func(char *input) {
char buffer[4];
strcpy(buffer, input);  // No bounds checking
}
int main(int argc, char **argv) {
char exploit[8];
// Fill exploit with address of malicious_func
for (int i=0; i<8; i++)
exploit[i] = (char)((int)(&malicious_func) >> (i*8));
vulnerable_func(exploit);
return 0;
}

In this example, if the crafted MFER file is provided as input, the `vulnerable_func` function would overflow its buffer and overwrite the return address with the address of `malicious_func`, resulting in the execution of the malicious function.