Amazon CodeGuruDetector Library Sign in to CodeGuru Reviewer

CodeGuru

Detector Library

Python detectors (86/86)

Improper privilege management Resource leak Inefficient string concatenation inside loop Spawning a process without main module Improper sanitization of wildcards or matching symbols Improper certificate validation URL redirection to untrusted site Integer overflow Mutually exclusive call Time zone aware datetimes Catch and swallow exception Insecure hashing Stack trace exposure Using AutoAddPolicy or WarningPolicy Use of a deprecated method Log injection Weak obfuscation of web request Deadlocks caused by improper multiprocessing API usage OS command injection Unauthenticated LDAP requests Low maintainability with low class cohesion Untrusted AMI images Confusion between equality and identity in conditional expression Path traversal AWS credentials logged Loose file permissions Socket close platform compatibility Zip bomb attack Unsanitized input is run as code Sensitive data stored unencrypted due to partial encryption Synchronous publication of AWS Lambda metrics Error prone sequence modification Batch request with unchecked failures Bad exception handling Unrestricted upload of dangerous file type Inefficient polling of AWS resource Hardcoded IP address Insecure connection using unencrypted protocol Incorrect use of Process.terminate API Unauthenticated Amazon SNS unsubscribe requests might succeed Hardcoded credentials Insecure Socket Bind XML External Entity Insecure CORS policy Cross-site request forgery Set SNS Return Subscription ARN Do not pass generic exception rule Unnecessary iteration Insecure cryptography Outdated subprocess module API Garbage collection prevention in multiprocessing Catch and rethrow exception Improper input validation Improper authentication Cross-site scripting Missing none check on response metadata Missing pagination Semaphore overflow prevention Mutable objects as default arguments of functions Insecure cookie Violation of PEP8 programming recommendations Insecure temporary file or directory Incorrect binding of SNS publish operations Client-side KMS reencryption Socket connection timeout AWS client not reused in a Lambda function Complex code hard to maintain Inefficient new method from hashlib Leaky subprocess timeout Usage of an API that is not recommended Dangerous global variables Enabling and overriding debug feature Risky use of dict get method Multiple values in return statement is prone to error LDAP injection XPath injection Clear text credentials Deserialization of untrusted object Use of an inefficient or incorrect API Multidimensional list initialization using replication is error prone Override of reserved variable names in a Lambda function SQL injection Docker arbitrary container run Missing S3 bucket owner condition Direct dict object modification Catastrophic backtracking regex

Tag: availability

Resource leak

Allocated resources are not released properly.

Spawning a process without main module

Using the spawn or forkserver start method without importing the main module might lead to unexpected behavior (for example, it might cause a RuntimeError).

Time zone aware datetimes

Using naive datetime objects might cause time zone related issues.

Use of a deprecated method

This code uses deprecated methods, which suggests that it has not been recently reviewed or maintained.

Deadlocks caused by improper multiprocessing API usage

Improper multiprocessing API usage with wrong parameters might lead to deadlocks.

Socket close platform compatibility

The os.close() does not work on some platforms.

Error prone sequence modification

Sequence modification while iterating over it might cause unexpected bugs.

Incorrect use of Process.terminate API

The Process.terminate API might cause data corruption of shared resources.

Missing none check on response metadata

Response metadata was not checked to verify that it is not None.

Insecure temporary file or directory

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

Incorrect binding of SNS publish operations

Incorrect binding of SNS publish operations with the subscribe or create_topic operations might lead to latency issues.

Socket connection timeout

Not setting the connection timeout parameter can cause a blocking socket connection.

AWS client not reused in a Lambda function

Recreating AWS clients in each Lambda function invocation is expensive.

Leaky subprocess timeout

Failure to end a child process that doesn't terminate before its timeout expires can result in leaked resources.

Risky use of dict get method

Using the get method from the dict class without default values can cause runtime exceptions.

Override of reserved variable names in a Lambda function

Overriding environment variables that are reserved by AWS Lambda might lead to unexpected behavior.