CWE

Common Weakness Enumeration

A Community-Developed List of Software Weakness Types

CWE/SANS Top 25 Most Dangerous Software Errors
Home > CWE List > CWE- Individual Dictionary Definition (2.10)  
ID

CWE VIEW: Weaknesses Addressed by the CERT C Secure Coding Standard

Mapping-Friendly:
View ID: 734
Structure: Graph
Status: Incomplete
Presentation Filter:
+ View Data

View Objective

CWE entries in this view (graph) are fully or partially eliminated by following the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this view is incomplete.

+ View Audience
StakeholderDescription
Developers

By following the CERT C Secure Coding Standard, developers will be able to fully or partially prevent the weaknesses that are identified in this view. In addition, developers can use a CWE coverage graph to determine which weaknesses are not directly addressed by the standard, which will help identify and resolve remaining gaps in training, tool acquisition, or other approaches for reducing weaknesses.

Software_Customers

If a software developer claims to be following the CERT C Secure Coding standard, then customers can search for the weaknesses in this view in order to formulate independent evidence of that claim.

Educators

Educators can use this view in multiple ways. For example, if there is a focus on teaching weaknesses, the educator could link them to the relevant Secure Coding Standard.

+ Relationships
734 - Weaknesses Addressed by the CERT C Secure Coding Standard
+CategoryCategoryCERT C Secure Coding Section 01 - Preprocessor (PRE) - (735)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 735 (CERT C Secure Coding Section 01 - Preprocessor (PRE))
Weaknesses in this category are related to rules in the preprocessor section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness BaseWeakness BaseIncorrect Provision of Specified Functionality - (684)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 735 (CERT C Secure Coding Section 01 - Preprocessor (PRE)) > 684 (Incorrect Provision of Specified Functionality)
The code does not function according to its published specifications, potentially leading to incorrect usage.
+CategoryCategoryCERT C Secure Coding Section 02 - Declarations and Initialization (DCL) - (736)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 736 (CERT C Secure Coding Section 02 - Declarations and Initialization (DCL))
Weaknesses in this category are related to rules in the declarations and initialization section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness VariantWeakness VariantFunction Call With Incorrect Argument Type - (686)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 736 (CERT C Secure Coding Section 02 - Declarations and Initialization (DCL)) > 686 (Function Call With Incorrect Argument Type)
The software calls a function, procedure, or routine, but the caller specifies an argument that is the wrong data type, which may lead to resultant weaknesses.
*Weakness BaseWeakness BaseFunction Call with Incorrectly Specified Arguments - (628)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 736 (CERT C Secure Coding Section 02 - Declarations and Initialization (DCL)) > 628 (Function Call with Incorrectly Specified Arguments)
The product calls a function, procedure, or routine with arguments that are not correctly specified, leading to always-incorrect behavior and resultant weaknesses.
*Weakness VariantWeakness VariantUse of Hard-coded, Security-relevant Constants - (547)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 736 (CERT C Secure Coding Section 02 - Declarations and Initialization (DCL)) > 547 (Use of Hard-coded, Security-relevant Constants)
The program uses hard-coded constants instead of symbolic names for security-critical values, which increases the likelihood of mistakes during code maintenance or security policy change.
+CategoryCategoryCERT C Secure Coding Section 03 - Expressions (EXP) - (737)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 737 (CERT C Secure Coding Section 03 - Expressions (EXP))
Weaknesses in this category are related to rules in the expressions section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness BaseWeakness BaseIncorrect Pointer Scaling - (468)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 737 (CERT C Secure Coding Section 03 - Expressions (EXP)) > 468 (Incorrect Pointer Scaling)
In C and C++, one may often accidentally refer to the wrong memory due to the semantics of when math operations are implicitly scaled.
*Weakness ClassWeakness ClassIncorrect Type Conversion or Cast - (704)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 737 (CERT C Secure Coding Section 03 - Expressions (EXP)) > 704 (Incorrect Type Conversion or Cast)
The software does not correctly convert an object, resource or structure from one type to a different type.
*Weakness BaseWeakness BaseNULL Pointer Dereference - (476)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 737 (CERT C Secure Coding Section 03 - Expressions (EXP)) > 476 (NULL Pointer Dereference)
A NULL pointer dereference occurs when the application dereferences a pointer that it expects to be valid, but is NULL, typically causing a crash or exit.
*Weakness VariantWeakness VariantOperator Precedence Logic Error - (783)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 737 (CERT C Secure Coding Section 03 - Expressions (EXP)) > 783 (Operator Precedence Logic Error)
The program uses an expression in which operator precedence causes incorrect logic to be used.
*Weakness VariantWeakness VariantUse of sizeof() on a Pointer Type - (467)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 737 (CERT C Secure Coding Section 03 - Expressions (EXP)) > 467 (Use of sizeof() on a Pointer Type)
The code calls sizeof() on a malloced pointer type, which always returns the wordsize/8. This can produce an unexpected result if the programmer intended to determine how much memory has been allocated.
*Weakness BaseWeakness BaseFunction Call with Incorrectly Specified Arguments - (628)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 737 (CERT C Secure Coding Section 03 - Expressions (EXP)) > 628 (Function Call with Incorrectly Specified Arguments)
The product calls a function, procedure, or routine with arguments that are not correctly specified, leading to always-incorrect behavior and resultant weaknesses.
+CategoryCategoryCERT C Secure Coding Section 04 - Integers (INT) - (738)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT))
Weaknesses in this category are related to rules in the integers section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness BaseWeakness BaseAssignment of a Fixed Address to a Pointer - (587)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 587 (Assignment of a Fixed Address to a Pointer)
The software sets a pointer to a specific address other than NULL or 0.
*Weakness BaseWeakness BaseDivide By Zero - (369)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 369 (Divide By Zero)
The product divides a value by zero.
*Weakness ClassWeakness ClassImproper Input Validation - (20)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 20 (Improper Input Validation)
The product does not validate or incorrectly validates input that can affect the control flow or data flow of a program.
*Weakness BaseWeakness BaseImproper Validation of Array Index - (129)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 129 (Improper Validation of Array Index)
The product uses untrusted input when calculating or using an array index, but the product does not validate or incorrectly validates the index to ensure the index references a valid position within the array. out-of-bounds array indexindex-out-of-rangearray index underflow
*Weakness ClassWeakness ClassIncorrect Calculation - (682)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 682 (Incorrect Calculation)
The software performs a calculation that generates incorrect or unintended results that are later used in security-critical decisions or resource management.
*Weakness BaseWeakness BaseIncorrect Conversion between Numeric Types - (681)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 681 (Incorrect Conversion between Numeric Types)
When converting from one data type to another, such as long to integer, data can be omitted or translated in a way that produces unexpected values. If the resulting values are used in a sensitive context, then dangerous behaviors may occur.
*CategoryCategoryInteger Coercion Error - (192)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 192 (Integer Coercion Error)
Integer coercion refers to a set of flaws pertaining to the type casting, extension, or truncation of primitive data types.
*Weakness BaseWeakness BaseInteger Overflow or Wraparound - (190)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 190 (Integer Overflow or Wraparound)
The software performs a calculation that can produce an integer overflow or wraparound, when the logic assumes that the resulting value will always be larger than the original value. This can introduce other weaknesses when the calculation is used for resource management or execution control.
*Weakness BaseWeakness BaseNumeric Truncation Error - (197)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 197 (Numeric Truncation Error)
Truncation errors occur when a primitive is cast to a primitive of a smaller size and data is lost in the conversion.
*Weakness BaseWeakness BaseReturn of Pointer Value Outside of Expected Range - (466)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 466 (Return of Pointer Value Outside of Expected Range)
A function can return a pointer to memory that is outside of the buffer that the pointer is expected to reference.
*Weakness BaseWeakness BaseUnchecked Input for Loop Condition - (606)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 606 (Unchecked Input for Loop Condition)
The product does not properly check inputs that are used for loop conditions, potentially leading to a denial of service because of excessive looping.
*Weakness BaseWeakness BaseUse of Potentially Dangerous Function - (676)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 738 (CERT C Secure Coding Section 04 - Integers (INT)) > 676 (Use of Potentially Dangerous Function)
The program invokes a potentially dangerous function that could introduce a vulnerability if it is used incorrectly, but the function can also be used safely.
+CategoryCategoryCERT C Secure Coding Section 05 - Floating Point (FLP) - (739)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 739 (CERT C Secure Coding Section 05 - Floating Point (FLP))
Weaknesses in this category are related to rules in the floating point section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness BaseWeakness BaseDivide By Zero - (369)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 739 (CERT C Secure Coding Section 05 - Floating Point (FLP)) > 369 (Divide By Zero)
The product divides a value by zero.
*Weakness VariantWeakness VariantFunction Call With Incorrect Argument Type - (686)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 739 (CERT C Secure Coding Section 05 - Floating Point (FLP)) > 686 (Function Call With Incorrect Argument Type)
The software calls a function, procedure, or routine, but the caller specifies an argument that is the wrong data type, which may lead to resultant weaknesses.
*Weakness ClassWeakness ClassIncorrect Calculation - (682)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 739 (CERT C Secure Coding Section 05 - Floating Point (FLP)) > 682 (Incorrect Calculation)
The software performs a calculation that generates incorrect or unintended results that are later used in security-critical decisions or resource management.
*Weakness BaseWeakness BaseIncorrect Conversion between Numeric Types - (681)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 739 (CERT C Secure Coding Section 05 - Floating Point (FLP)) > 681 (Incorrect Conversion between Numeric Types)
When converting from one data type to another, such as long to integer, data can be omitted or translated in a way that produces unexpected values. If the resulting values are used in a sensitive context, then dangerous behaviors may occur.
+CategoryCategoryCERT C Secure Coding Section 06 - Arrays (ARR) - (740)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 740 (CERT C Secure Coding Section 06 - Arrays (ARR))
Weaknesses in this category are related to rules in the arrays section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness BaseWeakness BaseBuffer Access with Incorrect Length Value - (805)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 740 (CERT C Secure Coding Section 06 - Arrays (ARR)) > 805 (Buffer Access with Incorrect Length Value)
The software uses a sequential operation to read or write a buffer, but it uses an incorrect length value that causes it to access memory that is outside of the bounds of the buffer.
*Weakness ClassWeakness ClassImproper Initialization - (665)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 740 (CERT C Secure Coding Section 06 - Arrays (ARR)) > 665 (Improper Initialization)
The software does not initialize or incorrectly initializes a resource, which might leave the resource in an unexpected state when it is accessed or used.
*Weakness ClassWeakness ClassImproper Restriction of Operations within the Bounds of a Memory Buffer - (119)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 740 (CERT C Secure Coding Section 06 - Arrays (ARR)) > 119 (Improper Restriction of Operations within the Bounds of a Memory Buffer)
The software performs operations on a memory buffer, but it can read from or write to a memory location that is outside of the intended boundary of the buffer.Memory Corruption
*Weakness BaseWeakness BaseUse of Pointer Subtraction to Determine Size - (469)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 740 (CERT C Secure Coding Section 06 - Arrays (ARR)) > 469 (Use of Pointer Subtraction to Determine Size)
The application subtracts one pointer from another in order to determine size, but this calculation can be incorrect if the pointers do not exist in the same memory chunk.
*Weakness BaseWeakness BaseImproper Validation of Array Index - (129)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 740 (CERT C Secure Coding Section 06 - Arrays (ARR)) > 129 (Improper Validation of Array Index)
The product uses untrusted input when calculating or using an array index, but the product does not validate or incorrectly validates the index to ensure the index references a valid position within the array. out-of-bounds array indexindex-out-of-rangearray index underflow
*Weakness VariantWeakness VariantUse of sizeof() on a Pointer Type - (467)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 740 (CERT C Secure Coding Section 06 - Arrays (ARR)) > 467 (Use of sizeof() on a Pointer Type)
The code calls sizeof() on a malloced pointer type, which always returns the wordsize/8. This can produce an unexpected result if the programmer intended to determine how much memory has been allocated.
+CategoryCategoryCERT C Secure Coding Section 07 - Characters and Strings (STR) - (741)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR))
Weaknesses in this category are related to rules in the characters and strings section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness BaseWeakness BaseAddition of Data Structure Sentinel - (464)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR)) > 464 (Addition of Data Structure Sentinel)
The accidental addition of a data-structure sentinel can cause serious programming logic problems.
*Weakness BaseWeakness BaseArgument Injection or Modification - (88)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR)) > 88 (Argument Injection or Modification)
The software does not sufficiently delimit the arguments being passed to a component in another control sphere, allowing alternate arguments to be provided, leading to potentially security-relevant changes.
*Weakness BaseWeakness BaseBuffer Copy without Checking Size of Input ('Classic Buffer Overflow') - (120)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR)) > 120 (Buffer Copy without Checking Size of Input ('Classic Buffer Overflow'))
The program copies an input buffer to an output buffer without verifying that the size of the input buffer is less than the size of the output buffer, leading to a buffer overflow.buffer overrunUnbounded Transfer
*Weakness BaseWeakness BaseImproper Neutralization of Special Elements used in an OS Command ('OS Command Injection') - (78)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR)) > 78 (Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'))
The software constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component.Shell injectionShell metacharacters
*Weakness BaseWeakness BaseImproper Null Termination - (170)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR)) > 170 (Improper Null Termination)
The software does not terminate or incorrectly terminates a string or array with a null character or equivalent terminator.
*Weakness BaseWeakness BaseIncorrect Calculation of Multi-Byte String Length - (135)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR)) > 135 (Incorrect Calculation of Multi-Byte String Length)
The software does not correctly calculate the length of strings that can contain wide or multi-byte characters.
*Weakness BaseWeakness BaseOff-by-one Error - (193)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR)) > 193 (Off-by-one Error)
A product calculates or uses an incorrect maximum or minimum value that is 1 more, or 1 less, than the correct value.off-by-five
*Weakness VariantWeakness VariantFunction Call With Incorrect Argument Type - (686)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR)) > 686 (Function Call With Incorrect Argument Type)
The software calls a function, procedure, or routine, but the caller specifies an argument that is the wrong data type, which may lead to resultant weaknesses.
*Weakness ClassWeakness ClassImproper Restriction of Operations within the Bounds of a Memory Buffer - (119)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR)) > 119 (Improper Restriction of Operations within the Bounds of a Memory Buffer)
The software performs operations on a memory buffer, but it can read from or write to a memory location that is outside of the intended boundary of the buffer.Memory Corruption
*Weakness ClassWeakness ClassIncorrect Type Conversion or Cast - (704)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 741 (CERT C Secure Coding Section 07 - Characters and Strings (STR)) > 704 (Incorrect Type Conversion or Cast)
The software does not correctly convert an object, resource or structure from one type to a different type.
+CategoryCategoryCERT C Secure Coding Section 08 - Memory Management (MEM) - (742)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM))
Weaknesses in this category are related to rules in the memory management section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness VariantWeakness VariantDouble Free - (415)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 415 (Double Free)
The product calls free() twice on the same memory address, potentially leading to modification of unexpected memory locations.Double-free
*Weakness VariantWeakness VariantExposure of Core Dump File to an Unauthorized Control Sphere - (528)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 528 (Exposure of Core Dump File to an Unauthorized Control Sphere)
The product generates a core dump file in a directory that is accessible to actors outside of the intended control sphere.
*Weakness VariantWeakness VariantFree of Memory not on the Heap - (590)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 590 (Free of Memory not on the Heap)
The application calls free() on a pointer to memory that was not allocated using associated heap allocation functions such as malloc(), calloc(), or realloc().
*Weakness VariantWeakness VariantFunction Call With Incorrectly Specified Argument Value - (687)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 687 (Function Call With Incorrectly Specified Argument Value)
The software calls a function, procedure, or routine, but the caller specifies an argument that contains the wrong value, which may lead to resultant weaknesses.
*Weakness ClassWeakness ClassImproper Check for Unusual or Exceptional Conditions - (754)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 754 (Improper Check for Unusual or Exceptional Conditions)
The software does not check or improperly checks for unusual or exceptional conditions that are not expected to occur frequently during day to day operation of the software.
*Weakness VariantWeakness VariantImproper Clearing of Heap Memory Before Release ('Heap Inspection') - (244)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 244 (Improper Clearing of Heap Memory Before Release ('Heap Inspection'))
Using realloc() to resize buffers that store sensitive information can leave the sensitive information exposed to attack, because it is not removed from memory.
*Weakness BaseWeakness BaseIncorrect Calculation of Buffer Size - (131)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 131 (Incorrect Calculation of Buffer Size)
The software does not correctly calculate the size to be used when allocating a buffer, which could lead to a buffer overflow.
*Weakness VariantWeakness VariantSensitive Data Storage in Improperly Locked Memory - (591)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 591 (Sensitive Data Storage in Improperly Locked Memory)
The application stores sensitive data in memory that is not locked, or that has been incorrectly locked, which might cause the memory to be written to swap files on disk by the virtual memory manager. This can make the data more accessible to external actors.
*Weakness BaseWeakness BaseSensitive Information Uncleared Before Release - (226)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 226 (Sensitive Information Uncleared Before Release)
The software does not fully clear previously used information in a data structure, file, or other resource, before making that resource available to a party in another control sphere.
*Weakness BaseWeakness BaseUnchecked Return Value - (252)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 252 (Unchecked Return Value)
The software does not check the return value from a method or function, which can prevent it from detecting unexpected states and conditions.
*Weakness BaseWeakness BaseUse After Free - (416)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 416 (Use After Free)
Referencing memory after it has been freed can cause a program to crash, use unexpected values, or execute code.Dangling pointerUse-After-Free
*Weakness BaseWeakness BaseWrap-around Error - (128)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 128 (Wrap-around Error)
Wrap around errors occur whenever a value is incremented past the maximum value for its type and therefore "wraps around" to a very small, negative, or undefined value.
*Weakness BaseWeakness BaseFunction Call with Incorrectly Specified Arguments - (628)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 628 (Function Call with Incorrectly Specified Arguments)
The product calls a function, procedure, or routine with arguments that are not correctly specified, leading to always-incorrect behavior and resultant weaknesses.
*Weakness ClassWeakness ClassImproper Initialization - (665)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 665 (Improper Initialization)
The software does not initialize or incorrectly initializes a resource, which might leave the resource in an unexpected state when it is accessed or used.
*Weakness ClassWeakness ClassImproper Input Validation - (20)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 20 (Improper Input Validation)
The product does not validate or incorrectly validates input that can affect the control flow or data flow of a program.
*Weakness ClassWeakness ClassImproper Restriction of Operations within the Bounds of a Memory Buffer - (119)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 119 (Improper Restriction of Operations within the Bounds of a Memory Buffer)
The software performs operations on a memory buffer, but it can read from or write to a memory location that is outside of the intended boundary of the buffer.Memory Corruption
*Weakness BaseWeakness BaseInteger Overflow or Wraparound - (190)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 190 (Integer Overflow or Wraparound)
The software performs a calculation that can produce an integer overflow or wraparound, when the logic assumes that the resulting value will always be larger than the original value. This can introduce other weaknesses when the calculation is used for resource management or execution control.
*Weakness BaseWeakness BaseNULL Pointer Dereference - (476)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 742 (CERT C Secure Coding Section 08 - Memory Management (MEM)) > 476 (NULL Pointer Dereference)
A NULL pointer dereference occurs when the application dereferences a pointer that it expects to be valid, but is NULL, typically causing a crash or exit.
+CategoryCategoryCERT C Secure Coding Section 09 - Input Output (FIO) - (743)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO))
Weaknesses in this category are related to rules in the input/output section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness ClassWeakness ClassConcurrent Execution using Shared Resource with Improper Synchronization ('Race Condition') - (362)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 362 (Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition'))
The program contains a code sequence that can run concurrently with other code, and the code sequence requires temporary, exclusive access to a shared resource, but a timing window exists in which the shared resource can be modified by another code sequence that is operating concurrently.
*Weakness BaseWeakness BaseCreation of Temporary File in Directory with Incorrect Permissions - (379)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 379 (Creation of Temporary File in Directory with Incorrect Permissions)
The software creates a temporary file in a directory whose permissions allow unintended actors to determine the file's existence or otherwise access that file.
*Weakness ClassWeakness ClassDuplicate Operations on Resource - (675)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 675 (Duplicate Operations on Resource)
The product performs the same operation on a resource two or more times, when the operation should only be applied once.
*Weakness BaseWeakness BaseExposure of File Descriptor to Unintended Control Sphere ('File Descriptor Leak') - (403)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 403 (Exposure of File Descriptor to Unintended Control Sphere ('File Descriptor Leak'))
A process does not close sensitive file descriptors before invoking a child process, which allows the child to perform unauthorized I/O operations using those descriptors.File descriptor leak
*Weakness BaseWeakness BaseFiles or Directories Accessible to External Parties - (552)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 552 (Files or Directories Accessible to External Parties)
Files or directories are accessible in the environment that should not be.
*Weakness BaseWeakness BaseImproper Handling of Unexpected Data Type - (241)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 241 (Improper Handling of Unexpected Data Type)
The software does not handle or incorrectly handles when a particular element is not the expected type, e.g. it expects a digit (0-9) but is provided with a letter (A-Z).
*Weakness VariantWeakness VariantImproper Handling of Windows Device Names - (67)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 67 (Improper Handling of Windows Device Names)
The software constructs pathnames from user input, but it does not handle or incorrectly handles a pathname containing a Windows device name such as AUX or CON. This typically leads to denial of service or an information exposure when the application attempts to process the pathname as a regular file.
*Weakness ClassWeakness ClassImproper Limitation of a Pathname to a Restricted Directory ('Path Traversal') - (22)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 22 (Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'))
The software uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the software does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory.Directory traversalPath traversal
*Weakness BaseWeakness BaseImproper Link Resolution Before File Access ('Link Following') - (59)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 59 (Improper Link Resolution Before File Access ('Link Following'))
The software attempts to access a file based on the filename, but it does not properly prevent that filename from identifying a link or shortcut that resolves to an unintended resource.insecure temporary file
*Weakness BaseWeakness BaseImproper Resolution of Path Equivalence - (41)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 41 (Improper Resolution of Path Equivalence)
The system or application is vulnerable to file system contents disclosure through path equivalence. Path equivalence involves the use of special characters in file and directory names. The associated manipulations are intended to generate multiple names for the same object.
*Weakness BaseWeakness BaseImproper Resource Shutdown or Release - (404)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 404 (Improper Resource Shutdown or Release)
The program does not release or incorrectly releases a resource before it is made available for re-use.
*Weakness VariantWeakness VariantIncorrect Default Permissions - (276)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 276 (Incorrect Default Permissions)
The software, upon installation, sets incorrect permissions for an object that exposes it to an unintended actor.
*Weakness VariantWeakness VariantIncorrect Execution-Assigned Permissions - (279)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 279 (Incorrect Execution-Assigned Permissions)
While it is executing, the software sets the permissions of an object in a way that violates the intended permissions that have been specified by the user.
*Weakness ClassWeakness ClassIncorrect Permission Assignment for Critical Resource - (732)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 732 (Incorrect Permission Assignment for Critical Resource)
The software specifies permissions for a security-critical resource in a way that allows that resource to be read or modified by unintended actors.
*Weakness VariantWeakness VariantPath Traversal: '/absolute/pathname/here' - (37)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 37 (Path Traversal: '/absolute/pathname/here')
A software system that accepts input in the form of a slash absolute path ('/absolute/pathname/here') without appropriate validation can allow an attacker to traverse the file system to unintended locations or access arbitrary files.
*Weakness VariantWeakness VariantPath Traversal: 'C:dirname' - (39)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 39 (Path Traversal: 'C:dirname')
An attacker can inject a drive letter or Windows volume letter ('C:dirname') into a software system to potentially redirect access to an unintended location or arbitrary file.
*Weakness VariantWeakness VariantPath Traversal: '\absolute\pathname\here' - (38)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 38 (Path Traversal: '\absolute\pathname\here')
A software system that accepts input in the form of a backslash absolute path ('\absolute\pathname\here') without appropriate validation can allow an attacker to traverse the file system to unintended locations or access arbitrary files.
*Weakness BaseWeakness BaseTime-of-check Time-of-use (TOCTOU) Race Condition - (367)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 367 (Time-of-check Time-of-use (TOCTOU) Race Condition)
The software checks the state of a resource before using that resource, but the resource's state can change between the check and the use in a way that invalidates the results of the check. This can cause the software to perform invalid actions when the resource is in an unexpected state.TOCTTOUTOCCTOU
*Weakness VariantWeakness VariantUNIX Hard Link - (62)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 62 (UNIX Hard Link)
The software, when opening a file or directory, does not sufficiently account for when the name is associated with a hard link to a target that is outside of the intended control sphere. This could allow an attacker to cause the software to operate on unauthorized files.
*Weakness BaseWeakness BaseUnchecked Error Condition - (391)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 391 (Unchecked Error Condition)
Ignoring exceptions and other error conditions may allow an attacker to induce unexpected behavior unnoticed.
*Weakness BaseWeakness BaseUse of Externally-Controlled Format String - (134)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 134 (Use of Externally-Controlled Format String)
The software uses a function that accepts a format string as an argument, but the format string originates from an external source.
*Weakness VariantWeakness VariantWindows Hard Link - (65)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 65 (Windows Hard Link)
The software, when opening a file or directory, does not sufficiently handle when the name is associated with a hard link to a target that is outside of the intended control sphere. This could allow an attacker to cause the software to operate on unauthorized files.
*Weakness VariantWeakness VariantWindows Shortcut Following (.LNK) - (64)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 64 (Windows Shortcut Following (.LNK))
The software, when opening a file or directory, does not sufficiently handle when the file is a Windows shortcut (.LNK) whose target is outside of the intended control sphere. This could allow an attacker to cause the software to operate on unauthorized files.Windows symbolic link followingsymlink
*Weakness VariantWeakness VariantFunction Call With Incorrect Argument Type - (686)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 686 (Function Call With Incorrect Argument Type)
The software calls a function, procedure, or routine, but the caller specifies an argument that is the wrong data type, which may lead to resultant weaknesses.
*Weakness ClassWeakness ClassImproper Restriction of Operations within the Bounds of a Memory Buffer - (119)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 119 (Improper Restriction of Operations within the Bounds of a Memory Buffer)
The software performs operations on a memory buffer, but it can read from or write to a memory location that is outside of the intended boundary of the buffer.Memory Corruption
*Weakness BaseWeakness BaseUse of Potentially Dangerous Function - (676)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 743 (CERT C Secure Coding Section 09 - Input Output (FIO)) > 676 (Use of Potentially Dangerous Function)
The program invokes a potentially dangerous function that could introduce a vulnerability if it is used incorrectly, but the function can also be used safely.
+CategoryCategoryCERT C Secure Coding Section 10 - Environment (ENV) - (744)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 744 (CERT C Secure Coding Section 10 - Environment (ENV))
Weaknesses in this category are related to rules in the environment section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness BaseWeakness BaseDuplicate Key in Associative List (Alist) - (462)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 744 (CERT C Secure Coding Section 10 - Environment (ENV)) > 462 (Duplicate Key in Associative List (Alist))
Duplicate keys in associative lists can lead to non-unique keys being mistaken for an error.
*Weakness ClassWeakness ClassIncorrect Control Flow Scoping - (705)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 744 (CERT C Secure Coding Section 10 - Environment (ENV)) > 705 (Incorrect Control Flow Scoping)
The software does not properly return control flow to the proper location after it has completed a task or detected an unusual condition.
+Compound Element: CompositeCompound Element: CompositeUntrusted Search Path - (426)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 744 (CERT C Secure Coding Section 10 - Environment (ENV)) > 426 (Untrusted Search Path)
The application searches for critical resources using an externally-supplied search path that can point to resources that are not under the application's direct control.Untrusted Path
*Weakness ClassWeakness ClassContainment Errors (Container Errors) - (216)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 744 (CERT C Secure Coding Section 10 - Environment (ENV)) > 426 (Untrusted Search Path) > 216 (Containment Errors (Container Errors))
This tries to cover various problems in which improper data are included within a "container."
*Weakness BaseWeakness BaseModification of Assumed-Immutable Data (MAID) - (471)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 744 (CERT C Secure Coding Section 10 - Environment (ENV)) > 426 (Untrusted Search Path) > 471 (Modification of Assumed-Immutable Data (MAID))
The software does not properly protect an assumed-immutable element from being modified by an attacker.
*CategoryCategoryPermission Issues - (275)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 744 (CERT C Secure Coding Section 10 - Environment (ENV)) > 426 (Untrusted Search Path) > 275 (Permission Issues)
Weaknesses in this category are related to improper assignment or handling of permissions.
*Weakness BaseWeakness BaseArgument Injection or Modification - (88)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 744 (CERT C Secure Coding Section 10 - Environment (ENV)) > 88 (Argument Injection or Modification)
The software does not sufficiently delimit the arguments being passed to a component in another control sphere, allowing alternate arguments to be provided, leading to potentially security-relevant changes.
*Weakness BaseWeakness BaseImproper Neutralization of Special Elements used in an OS Command ('OS Command Injection') - (78)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 744 (CERT C Secure Coding Section 10 - Environment (ENV)) > 78 (Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'))
The software constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component.Shell injectionShell metacharacters
*Weakness ClassWeakness ClassImproper Restriction of Operations within the Bounds of a Memory Buffer - (119)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 744 (CERT C Secure Coding Section 10 - Environment (ENV)) > 119 (Improper Restriction of Operations within the Bounds of a Memory Buffer)
The software performs operations on a memory buffer, but it can read from or write to a memory location that is outside of the intended boundary of the buffer.Memory Corruption
+CategoryCategoryCERT C Secure Coding Section 11 - Signals (SIG) - (745)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 745 (CERT C Secure Coding Section 11 - Signals (SIG))
Weaknesses in this category are related to rules in the signals section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness BaseWeakness BaseImproper Synchronization - (662)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 745 (CERT C Secure Coding Section 11 - Signals (SIG)) > 662 (Improper Synchronization)
The software attempts to use a shared resource in an exclusive manner, but does not prevent or incorrectly prevents use of the resource by another thread or process.
*Weakness VariantWeakness VariantSignal Handler Use of a Non-reentrant Function - (479)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 745 (CERT C Secure Coding Section 11 - Signals (SIG)) > 479 (Signal Handler Use of a Non-reentrant Function)
The program defines a signal handler that calls a non-reentrant function.
+CategoryCategoryCERT C Secure Coding Section 12 - Error Handling (ERR) - (746)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 746 (CERT C Secure Coding Section 12 - Error Handling (ERR))
Weaknesses in this category are related to rules in the error handling section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness BaseWeakness BaseMissing Standardized Error Handling Mechanism - (544)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 746 (CERT C Secure Coding Section 12 - Error Handling (ERR)) > 544 (Missing Standardized Error Handling Mechanism)
The software does not use a standardized method for handling errors throughout the code, which might introduce inconsistent error handling and resultant weaknesses.
*Weakness ClassWeakness ClassImproper Input Validation - (20)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 746 (CERT C Secure Coding Section 12 - Error Handling (ERR)) > 20 (Improper Input Validation)
The product does not validate or incorrectly validates input that can affect the control flow or data flow of a program.
*Weakness ClassWeakness ClassIncorrect Control Flow Scoping - (705)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 746 (CERT C Secure Coding Section 12 - Error Handling (ERR)) > 705 (Incorrect Control Flow Scoping)
The software does not properly return control flow to the proper location after it has completed a task or detected an unusual condition.
*Weakness BaseWeakness BaseUnchecked Error Condition - (391)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 746 (CERT C Secure Coding Section 12 - Error Handling (ERR)) > 391 (Unchecked Error Condition)
Ignoring exceptions and other error conditions may allow an attacker to induce unexpected behavior unnoticed.
*Weakness BaseWeakness BaseUse of Potentially Dangerous Function - (676)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 746 (CERT C Secure Coding Section 12 - Error Handling (ERR)) > 676 (Use of Potentially Dangerous Function)
The program invokes a potentially dangerous function that could introduce a vulnerability if it is used incorrectly, but the function can also be used safely.
+CategoryCategoryCERT C Secure Coding Section 49 - Miscellaneous (MSC) - (747)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC))
Weaknesses in this category are related to rules in the miscellaneous section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness VariantWeakness VariantAssignment to Variable without Use ('Unused Variable') - (563)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 563 (Assignment to Variable without Use ('Unused Variable'))
The variable's value is assigned but never used, making it a dead store.
*Weakness VariantWeakness VariantComparing instead of Assigning - (482)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 482 (Comparing instead of Assigning)
The code uses an operator for comparison when the intention was to perform an assignment.
*Weakness BaseWeakness BaseCompiler Removal of Code to Clear Buffers - (14)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 14 (Compiler Removal of Code to Clear Buffers)
Sensitive memory is cleared according to the source code, but compiler optimizations leave the memory untouched when it is not read from again, aka "dead store removal."
*Weakness VariantWeakness VariantDead Code - (561)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 561 (Dead Code)
The software contains dead code, which can never be executed.
*Weakness VariantWeakness VariantExpression is Always False - (570)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 570 (Expression is Always False)
The software contains an expression that will always evaluate to false.
*Weakness VariantWeakness VariantExpression is Always True - (571)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 571 (Expression is Always True)
The software contains an expression that will always evaluate to true.
*Weakness VariantWeakness VariantImproper Handling of Unicode Encoding - (176)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 176 (Improper Handling of Unicode Encoding)
The software does not properly handle when an input contains Unicode encoding.
*Weakness ClassWeakness ClassInsufficient Comparison - (697)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 697 (Insufficient Comparison)
The software compares two entities in a security-relevant context, but the comparison is insufficient, which may lead to resultant weaknesses.
*Weakness BaseWeakness BaseUse of Incorrect Operator - (480)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 480 (Use of Incorrect Operator)
The programmer accidentally uses the wrong operator, which changes the application logic in security-relevant ways.
*Weakness ClassWeakness ClassUse of Insufficiently Random Values - (330)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 330 (Use of Insufficiently Random Values)
The software may use insufficiently random numbers or values in a security context that depends on unpredictable numbers.
*Weakness ClassWeakness ClassImproper Input Validation - (20)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 20 (Improper Input Validation)
The product does not validate or incorrectly validates input that can affect the control flow or data flow of a program.
*Weakness ClassWeakness ClassIncorrect Type Conversion or Cast - (704)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 747 (CERT C Secure Coding Section 49 - Miscellaneous (MSC)) > 704 (Incorrect Type Conversion or Cast)
The software does not correctly convert an object, resource or structure from one type to a different type.
+CategoryCategoryCERT C Secure Coding Section 50 - POSIX (POS) - (748)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS))
Weaknesses in this category are related to rules in the POSIX section of the CERT C Secure Coding Standard. Since not all rules map to specific weaknesses, this category may be incomplete.
*Weakness BaseWeakness BaseImproper Check for Dropped Privileges - (273)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 273 (Improper Check for Dropped Privileges)
The software attempts to drop privileges but does not check or incorrectly checks to see if the drop succeeded.
*Weakness BaseWeakness BaseImproper Locking - (667)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 667 (Improper Locking)
The software does not properly acquire a lock on a resource, or it does not properly release a lock on a resource, leading to unexpected resource state changes and behaviors.
*Weakness ClassWeakness ClassIncorrect Behavior Order - (696)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 696 (Incorrect Behavior Order)
The software performs multiple related behaviors, but the behaviors are performed in the wrong order in ways which may produce resultant weaknesses.
*Weakness BaseWeakness BaseLeast Privilege Violation - (272)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 272 (Least Privilege Violation)
The elevated privilege level required to perform operations such as chroot() should be dropped immediately after the operation is performed.
*Weakness BaseWeakness BaseRace Condition Enabling Link Following - (363)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 363 (Race Condition Enabling Link Following)
The software checks the status of a file or directory before accessing it, which produces a race condition in which the file can be replaced with a link before the access is performed, causing the software to access the wrong file.
*Weakness BaseWeakness BaseRace Condition in Switch - (365)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 365 (Race Condition in Switch)
The code contains a switch statement in which the switched variable can be modified while the switch is still executing, resulting in unexpected behavior.
*Weakness BaseWeakness BaseRace Condition within a Thread - (366)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 366 (Race Condition within a Thread)
If two threads of execution use a resource simultaneously, there exists the possibility that resources may be used while invalid, in turn making the state of execution undefined.
*Weakness BaseWeakness BaseReturn of Stack Variable Address - (562)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 562 (Return of Stack Variable Address)
A function returns the address of a stack variable, which will cause unintended program behavior, typically in the form of a crash.
*Weakness BaseWeakness BaseUse of Inherently Dangerous Function - (242)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 242 (Use of Inherently Dangerous Function)
The program calls a function that can never be guaranteed to work safely.
*Weakness VariantWeakness VariantFunction Call With Incorrect Argument Type - (686)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 686 (Function Call With Incorrect Argument Type)
The software calls a function, procedure, or routine, but the caller specifies an argument that is the wrong data type, which may lead to resultant weaknesses.
*Weakness BaseWeakness BaseImproper Link Resolution Before File Access ('Link Following') - (59)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 59 (Improper Link Resolution Before File Access ('Link Following'))
The software attempts to access a file based on the filename, but it does not properly prevent that filename from identifying a link or shortcut that resolves to an unintended resource.insecure temporary file
*Weakness BaseWeakness BaseImproper Null Termination - (170)
734 (Weaknesses Addressed by the CERT C Secure Coding Standard) > 748 (CERT C Secure Coding Section 50 - POSIX (POS)) > 170 (Improper Null Termination)
The software does not terminate or incorrectly terminates a string or array with a null character or equivalent terminator.
+ Relationship Notes

The relationships in this view were determined based on specific statements within the rules from the standard. Not all rules have direct relationships to individual weaknesses, although they likely have chaining relationships in specific circumstances.

+ References
"The CERT C Secure Coding Standard". Addison-Wesley Professional. 2008-10-14.
+ Content History
Submissions
Submission DateSubmitterOrganizationSource
2008-11-24Internal CWE Team
+ View Metrics
CWEs in this viewTotal CWEs
Total106out of1005
Views0out of33
Categories15out of244
Weaknesses90out of720
Compound_Elements1out of8

More information is available — Please select a different filter.
Page Last Updated: January 18, 2017