Out-of-bounds write vulnerability occurs when software attempts to write data beyond the allocated memory bounds, potentially leading to memory corruption and security risks.

Thread safety violation

A thread safety violation might indicate a data race which can put the system into an inconsistent state.

Incorrect Pointer Subtraction

Pointer subtraction allows unintended behavior.

File System Access

Concurrent execution using shared resource with improper synchronization.

Insecure Buffer Access

Use of insecure functions can lead to buffer overflow.

Incorrect Use of Sizeof

Use of sizeof on a malloced pointer type is incorrect.

Incorrect Pointer Scaling

Instances of incorrect pointer scaling detected, potentially leading to unexpected behavior and vulnerabilities.

Loose File Permissions

Weak file permissions can lead to privilege escalation.

Sensitive information leak

Sensitive information should not be exposed through log files or stack traces.

Missing Authorization

Missing authorization checks can lead to unauthorized access to a resource or performance of an action.

Return Stack Address

A function returns the address of a stack variable will cause unintended program behavior, typically in the form of a crash.

OS Command Injection

Improper neutralization of special elements used in an OS command ('OS Command Injection')

Use After Free

Using memory after it has been freed can lead to unexpected behavior or exploitation.

Incorrect Comparison

Secure comparison type safety recommendation.

off by one error

Off-by-one errors occur when a loop or array index is incorrectly incremented or decremented by one, leading to unintended behavior.

Path traversal

Creating file paths from untrusted input might give a malicious actor access to sensitive files.

Insecure temporary file or directory

Insecure ways of creating temporary files and directories can lead to race conditions, privilege escalation, and other security vulnerabilities.

Insecure Cryptography

Use of insecure cryptography.

Insecure connection using unencrypted protocol

Connections that use insecure protocols transmit data in cleartext, which can leak sensitive information.

Unchecked Null Dereference

Dereferencing an unchecked value without verification, leading to potential runtime errors or undefined behavior.

SQL injection

Use of untrusted inputs in SQL database query can enable attackers to read, modify, or delete sensitive data in the database.

Missing check on method output

Missing checks might cause silent failures that are harder to debug.

Improper Restriction on Memory Buffer

Improper restriction of operations within the bounds of a memory buffer.

Multiple Locks

Repeatedly locking critical resources in a concurrent environment can lead to varied consequences.

Improper Input Validation

Improper input validation can enable attacks and lead to unwanted behavior.

Null Pointer Dereference

Dereferencing a null pointer can lead to unexpected null pointer exceptions.

Use Of Redundant Code

Redundant data copying operations in the code lead to performance and memory inefficiencies.

Improper Certificate Validation

Improper certificate validation might allow an attacker to spoof a trusted entity by interfering in the communication path between the host and client.

Improper Authentication

Improper authentication from insufficient identity verification.