Ejecuta análisis estático (SAST) sobre el código buscando el patrón inseguro en el flujo de datos.
CWE-663 Base Borrador
Use of a Non-reentrant Function in a Concurrent Context
This vulnerability occurs when a program uses a function that is not safe for reentrancy within a concurrent environment, such as multi-threaded code or signal handlers. If another thread or signal…
Definición
What is CWE-663?
This vulnerability occurs when a program uses a function that is not safe for reentrancy within a concurrent environment, such as multi-threaded code or signal handlers. If another thread or signal handler interrupts and calls the same function, it can corrupt shared data, cause crashes, or create unpredictable behavior.
Non-reentrant functions rely on or modify shared global or static data, making them unsafe when multiple execution flows can interrupt each other. In a concurrent context—like a multi-threaded application or a program using signal handlers—if one thread is inside such a function and another thread or signal handler calls the same function, the shared state can be corrupted. This leads to race conditions, memory corruption, or incorrect program outputs, often manifesting as intermittent, hard-to-debug failures.
To prevent this, developers should identify functions not designed for concurrency (like many traditional C library functions) and protect their use with proper synchronization mechanisms, such as mutexes or semaphores. Alternatively, replace them with thread-safe, reentrant equivalents (often denoted with '_r' suffixes in C). Always audit code for global/static variable usage within functions that may be accessed by multiple threads or signal handlers, and design concurrent systems with clear ownership of shared resources.
Impacto en el mundo real
Real-world CVEs caused by CWE-663
-
unsafe calls to library functions from signal handler
-
SIGCHLD signal to FTP server can cause crash under heavy load while executing non-reentrant functions like malloc/free.
Cómo lo explotan los atacantes
Ruta del atacante paso a paso
- 1
Identifica una ruta de código que maneje entrada no confiable sin validación.
- 2
Crea un payload que ejercite el comportamiento inseguro — inyección, traversal, overflow o abuso de lógica.
- 3
Envía el payload a través de una solicitud normal y observa la reacción de la aplicación.
- 4
Itera hasta que la respuesta filtre datos, ejecute código del atacante o escale privilegios.
Ejemplo de código vulnerable
Vulnerable C
In this example, a signal handler uses syslog() to log a message:
char *message;
void sh(int dummy) {
syslog(LOG_NOTICE,"%s\n",message);
sleep(10);
exit(0);
}
int main(int argc,char* argv[]) {
...
signal(SIGHUP,sh);
signal(SIGTERM,sh);
sleep(10);
exit(0);
}
If the execution of the first call to the signal handler is suspended after invoking syslog(), and the signal handler is called a second time, the memory allocated by syslog() enters an undefined, and possibly, exploitable state. Ejemplo de código seguro
Secure pseudo
// Validate, sanitize, or use a safe API before reaching the sink.
function handleRequest(input) {
const safe = validateAndEscape(input);
return executeWithGuards(safe);
} What changed: the unsafe sink is replaced (or the input is validated/escaped) so the same payload no longer triggers the weakness.
Lista de prevención
How to prevent CWE-663
- Implementation Use reentrant functions if available.
- Implementation Add synchronization to your non-reentrant function.
- Implementation In Java, use the ReentrantLock Class.
Señales de detección
How to detect CWE-663
Ejecuta pruebas dinámicas de seguridad de aplicaciones (DAST) contra el endpoint en vivo.
Vigila los logs en tiempo de ejecución para detectar trazas de excepción inusuales, entradas malformadas o intentos de bypass de autorización.
Revisión de código: marca cualquier código nuevo que maneje entrada desde esta superficie sin usar los helpers validados del framework.
CWE-663
Don't catalog this weakness. Prove it's reachable.
Plexicus turns CWE catalogs into evidence: every CWE-pattern is matched against your real code graph, reach is proven on a sandbox clone, and verified findings ship as reviewed PRs.
Preguntas frecuentes ¿Qué es CWE-663?
¿Qué gravedad tiene CWE-663?
¿Qué lenguajes o plataformas se ven afectados por CWE-663?
¿Cómo puedo prevenir CWE-663?
¿Cómo detecta y corrige Plexicus CWE-663?
¿Dónde puedo aprender más sobre CWE-663?
Frequently asked questions
¿Qué es CWE-663?
This vulnerability occurs when a program uses a function that is not safe for reentrancy within a concurrent environment, such as multi-threaded code or signal handlers. If another thread or signal handler interrupts and calls the same function, it can corrupt shared data, cause crashes, or create unpredictable behavior.
¿Qué gravedad tiene CWE-663?
MITRE no ha publicado una calificación de probabilidad de explotación para esta debilidad. Trátala como de impacto medio hasta que tu modelo de amenazas demuestre lo contrario.
¿Qué lenguajes o plataformas se ven afectados por CWE-663?
MITRE no ha especificado plataformas afectadas para esta CWE — puede aplicar a la mayoría de los stacks de aplicaciones.
¿Cómo puedo prevenir CWE-663?
Use reentrant functions if available. Add synchronization to your non-reentrant function.
¿Cómo detecta y corrige Plexicus CWE-663?
El motor SAST de Plexicus detecta la firma de flujo de datos para CWE-663 en cada commit. Cuando hay coincidencia, nuestro agente Codex Remedium abre un PR de corrección con el código corregido, las pruebas y un resumen de una línea para el revisor.
¿Dónde puedo aprender más sobre CWE-663?
MITRE publica la definición canónica en https://cwe.mitre.org/data/definitions/663.html. También puedes consultar la documentación de OWASP y NIST para guías relacionadas.
Debilidades relacionadas
Weaknesses related to CWE-663
CWE-662 Padre
Improper Synchronization
This vulnerability occurs when a multi-threaded or multi-process application allows shared resources to be accessed by multiple threads or…
CWE-1058 Hermano
Invokable Control Element in Multi-Thread Context with non-Final Static Storable or Member Element
This happens when a method or function, designed to run in a multi-threaded environment, accesses or modifies a non-final static variable…
CWE-1096 Hermano
Singleton Class Instance Creation without Proper Locking or Synchronization
This flaw occurs when a Singleton class is implemented without proper thread-safe controls, allowing multiple instances to be created in…
CWE-366 Hermano
Race Condition within a Thread
This vulnerability occurs when two or more threads within the same application access and manipulate a shared resource (like a variable,…
CWE-543 Hermano
Use of Singleton Pattern Without Synchronization in a Multithreaded Context
This vulnerability occurs when a singleton pattern is implemented in a multithreaded application without proper synchronization,…
CWE-567 Hermano
Unsynchronized Access to Shared Data in a Multithreaded Context
This vulnerability occurs when multiple threads in an application can read and modify shared data, like static variables, without proper…
CWE-667 Hermano
Improper Locking
This vulnerability occurs when a program fails to correctly acquire or release a lock on a shared resource, such as a file, database…
CWE-764 Hermano
Multiple Locks of a Critical Resource
This vulnerability occurs when a critical resource, such as a file, data structure, or connection, is locked more times than the software…
CWE-820 Hermano
Missing Synchronization
This vulnerability occurs when multiple parts of your application (like threads or processes) use the same resource—such as a variable,…
¿Listo para validar lo que importa?
Listo para validar lo que importa.
Plexicus es Proof-Driven AppSec: hallazgos validados, comprensión contextual y remediación revisada — anclada en evidencia, acotada contigo.