CWE-1341: Multiple Releases of Same Resource or Handle

How it's found

Multiple Releases of Same Resource or Handle is typically found by tracing untrusted input from where it enters the system to the point where it is used without the check or neutralization this weakness describes, combining manual code review with dynamic testing.

Code typically requires "opening" handles or references to resources such as memory, files, devices, socket connections, services, etc. When the code is finished with using the resource, it is typically expected to "close" or "release" the resource, which indicates to the environment (such as the OS) that the resource can be re-assigned or reused by unrelated processes or actors - or in some cases, within the same process. API functions or other abstractions are often used to perform this release, such as free() or delete() within C/C++, or file-handle close() operations that are used in many languages. Unfortunately, the implementation or design of such APIs might expect the developer to be responsible for ensuring that such APIs are only called once per release of the resource. If the developer attempts to release the same resource/handle more than once, then the API's expectations are not met, resulting in undefined and/or insecure behavior. This could lead to consequences such as memory corruption, data corruption, execution path corruption, or other consequences. Note that while the implementation for most (if not all) resource reservation allocations involve a unique identifier/pointer/symbolic reference, then if this identifier is reused, checking the identifier for resource closure may result in a false state of openness and closing of the wrong resource. For this reason, reuse of identifiers is discouraged.

Vulnerable vs. safe

b[0] = 0;fread(b, 1, sizeof(b) - 1, f);printf("%s\n'", b);int r1 = fclose(f);printf("\n-----------------\n1 close done '%d'\n", r1);int r2 = fclose(f); // Double closeprintf("2 close done '%d'\n", r2);char b[2000];FILE *f = fopen("dbl_cls.c", "r");if (f){}

b[0] = 0;fread(b, 1, sizeof(b) - 1, f);printf("%s\n'", b);int r = fclose(f);printf("\n-----------------\n1 close done '%d'\n", r);char b[2000];FILE *f = fopen("dbl_cls.c", "r");if (f){}

Consequences

• DoS: Crash, Exit, or Restart

Mitigations

• Implementation: Change the code's logic so that the resource is only closed once. This might require simplifying or refactoring. This fix can be simple to do in small code blocks, but more difficult when multiple closes are buried within complex conditionals.
• Implementation: It can be effective to implement a flag that is (1) set when the resource is opened, (2) cleared when it is closed, and (3) checked before closing. This approach can be useful when there are disparate cases in which closes must be performed. However, flag-tracking can increase code complexity and requires diligent compliance by the programmer.
• Implementation: When closing a resource, set the resource's associated variable to NULL or equivalent value for the given language. Some APIs will ignore this null value without causing errors. For other APIs, this can lead to application crashes or exceptions, which may still be preferable to corrupting an unintended resource such as memory or data.

Where this fits in a TurboPentest engagement

This weakness is not covered by the automated black-box pentest. IntegSec pentesters cover it in a manual engagement.

Frequently asked questions

Related CWEs

• Class weakness
  CWE-675: Multiple Operations on Resource in Single-Operation Context