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: owasp-top10

Improper privilege management

Privilege escalation happens when a malicious user gains elevated access to resources that should be unavailable to them.

Module injection

Untrusted user imports in the importlib.import_module() function allow attacks.

Insecure cryptography

Weak, broken, or misconfigured cryptography can lead to security vulnerabilities.

Improper certificate validation

Lack of validation of a security certificate can lead to host impersonation and sensitive data leaks.

Improper input validation

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

Improper authentication

Your code doesn't sufficiently authenticate identities provided by its users.

Insecure hashing

Obsolete, broken, or weak hashing algorithms can lead to security vulnerabilities.

Cross-site scripting

Relying on potentially untrusted user inputs when constructing web application outputs can lead to cross-site scripting vulnerabilities.

Using AutoAddPolicy or WarningPolicy

Using AutoAddPolicy or WarningPolicy can allow a malicious server to impersonate a trusted server.

Stack trace exposure

Stack traces can be hard to use for debugging.

Log injection

Using untrusted inputs in a log statement can enable attackers to break the log's format, forge log entries, and bypass log monitors.

Weak obfuscation of web request

Weak obfuscation while configuring a web request.

Insecure cookie

Insecure cookies can lead to unencrypted transmission of sensitive data.

Insecure temporary file or directory

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

OS command injection

Constructing operating system or shell commands with unsanitized user input can lead to inadvertently running malicious code.

Unauthenticated LDAP requests

Unauthenticated LDAP requests can allow untrusted access to LDAP servers.

Client-side KMS reencryption

Client-side decryption followed by reencryption is inefficient and can lead to sensitive data leaks.

AWS credentials logged

Logging unencrypted AWS credentials can expose them to an attacker.

Path traversal

Constructing path names with unsanitized user input can lead to path traversal attacks (for example, ../../..) that allow an attacker access to file system resources.

Loose file permissions

Weak file permissions can lead to privilege escalation.

Unsanitized input is run as code

Scripts generated from unsanitized inputs can lead to malicious behavior and inadvertently running code remotely.

LDAP injection

LDAP queries that rely on potentially untrusted inputs can allow attackers to read or modify sensitive data, run code, and perform other unwanted actions.

XPath injection

Potentially unsanitized user input in XPath queries can allow an attacker to control the query in unwanted or insecure ways.

Clear text credentials

Credentials that are stored in clear text can be intercepted by a malicious actor.

Unrestricted upload of dangerous file type

Insufficiently restrictive file uploads can lead to inadvertently running malicious code.

Deserialization of untrusted object

Deserialization of untrusted objects can lead to security vulnerabilities such as inadvertently running remote code.

SQL injection

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

Docker arbitrary container run

Passing an unsanitized user argument to a function call makes your code insecure.

Insecure connection using unencrypted protocol

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

Hardcoded credentials

Credentials, such as passwords and access keys, should not be hardcoded in source code.

Insecure Socket Bind

Binding the socket with an empty IP address can introduce security risks.

Insecure CORS policy

Cross-Origin Resource Sharing policies that are too permissive may lead to security vulnerabilities.

Cross-site request forgery

Insecure configuration can lead to a cross-site request forgery (CRSF) vulnerability.

XML External Entity

Objects that parse or handle XML can lead to XML External Entity (XXE) attacks when misconfigured.