CodeGuru ReviewerDetector Library Sign in to CodeGuru Reviewer

CodeGuru Reviewer

Detector Library

Python detectors (80/80)

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

Tag: security-context

Garbage collection prevention in multiprocessing

Passing a parent process object in a child process can prevent its garbage collection.

Integer overflow

An integer overflow might might cause security issues when it is used for resource management or execution control.

Mutually exclusive call

Calls to mutually exclusive methods were found in the code.

Time zone aware datetimes

Using naive datetime objects might cause time zone related issues.

Missing none check on response metadata

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

Missing pagination

Missing pagination on a paginated call can lead to inaccurate results.

Semaphore overflow prevention

When you process and remove an item from the JoinableQueue without calling JoinableQueue.task_done(), a semaphore overflow exception might be thrown.

Deadlocks caused by improper multiprocessing API usage

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

Incorrect binding of SNS publish operations

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

AWS client not reused in a Lambda function

Recreating AWS clients in each Lambda function invocation is expensive.

Socket connection timeout

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

Leaky subprocess timeout

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

Usage of an API that is not recommended

APIs that are not recommended were found.

Error prone sequence modification

Sequence modification while iterating over it might cause unexpected bugs.

Batch request with unchecked failures

Not checking which items have failed can lead to loss of data.

Override of reserved variable names in a Lambda function

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

Hardcoded IP address

Hardcoding an IP address can cause security problems.

Missing S3 bucket owner condition

Not setting the S3 bucket owner condition might introduce a risk of accidentally using a wrong bucket.