Python detectors

Showing all detectors for the Python language.

Browse by tags
Browse all detectors by tags.
Browse by severity
Browse all detectors by severity.
Browse by category
Browse all detectors by category.

Browse all detectors

Improper privilege management

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

Resource leak

Allocated resources are not released properly.

Inefficient string concatenation inside loop

Inefficient string concatenation inside loops results in new object creation which adds quadratic runtime cost.

Set SNS Return Subscription ARN

To always return the subscription ARN, set the ReturnSubscriptionArn argument to True.

Module injection

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

Unnecessary iteration

Iteration when only one item is needed from a list is inefficient.

Improper error handling

Improper error handling can enable attacks and lead to unwanted behavior.

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.

Outdated subprocess module API

Using outdated multiprocessing API calls and parameters is not recommended.

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.

Catch and rethrow exception

Catching and re-throwing an exception without further actions is redundant and wasteful.

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.

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.

Catch and swallow exception

Swallowing exceptions, without re-throwing or logging them, is a bad practice.

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.

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.

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.

Use of a deprecated method

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

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.

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.

Mutable objects as default arguments of functions

Default values in Python are created exactly once, when the function is defined. If that object is changed, subsequent calls to the function will refer to the changed object, leading to confusion.

Weak obfuscation of web request

Weak obfuscation while configuring a web request.

Deadlocks caused by improper multiprocessing API usage

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

Insecure cookie

Insecure cookies can lead to unencrypted transmission of sensitive data.

Violation of PEP8 programming recommendations

Violating PEP8 programming recommendations might make code difficult to read and can introduce ambiguity.

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.

Incorrect binding of SNS publish operations

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

Client-side KMS reencryption

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

Untrusted AMI images

Improper filtering of Amazon Machine Images (AMIs) can result in loading an untrusted image, a potential security vulnerability.

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.

Complex code hard to maintain

Complex code can be difficult to read and hard to maintain.

Confusion between equality and identity in conditional expression

Confusion between equality ==, != and identity is in conditional expressions can lead to unintended behavior.

Inefficient new method from hashlib

The constructors for the hashlib module are faster than new()

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.

Dangerous global variables

Global variables can be dangerous and cause bugs because they can be simultaneously accessed from multiple sections of a program.

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.

Enabling and overriding debug feature

The Debug feature should not be enabled or overridden.

Loose file permissions

Weak file permissions can lead to privilege escalation.

Risky use of dict get method

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

Socket close platform compatibility

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

Multiple values in return statement is prone to error

Methods that return multiple values can be difficult to read and prone to error.

Zip bomb attack

Expanding unsanitized archive files taken as input can lead to zip bomb attacks.

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.

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.

Clear text credentials

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

Bad exception handling

Throwing a base or generic exception might cause important error information to be lost. This can make your code difficult to maintain.

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.

Use of an inefficient or incorrect API

Incorrect use of API leads to ambiguity and inconsistency

Multidimensional list initialization using replication is error prone

list replication using replication operator creates references to the existing objects, not copies, which could introduce bugs.

Inefficient polling of AWS resource

Custom polling can be inefficient and prone to error. Consider using AWS waiters instead.

Override of reserved variable names in a Lambda function

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

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.

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.

Insecure connection using unencrypted protocol

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

Direct dict object modification

Directly modifying the dict object might cause undesirable behavior due to symbol table modification.

Incorrect use of Process.terminate API

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

Unauthenticated Amazon SNS unsubscribe requests might succeed

Failing to set the AuthenticateOnUnsubscribe flag to True when confirming an SNS subscription can lead to unauthenticated cancellations.

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.