Amazon QDetector Library Sign in to Amazon Q

Q

Detector Library

Python detectors (131/131)

Improper privilege management Spawning a process without main module Integer overflow Catch and swallow exception Insufficient Logging CDK Unauthenticated LDAP requests Path traversal Loose file permissions Exposure of Sensitive Information CDK File injection Incorrect use of Process.terminate API XML External Entity Pytorch use nondeterministic algoritm Set SNS Return Subscription ARN Tensorflow enable ops determinism Outdated subprocess module API Improper input validation Improper authentication Missing pagination Semaphore overflow prevention Insecure cookie Usage of an API that is not recommended - Low Severity Socket connection timeout AWS client not reused in a Lambda function Pytorch assign in place mod Leaky subprocess timeout Pytorch disable gradient calculation Risky use of dict get method XPath injection Missing authorization Multidimensional list initialization using replication is error prone SQL injection Pytorch miss call to eval AWS AppConfig Improper certificate validation URL redirection to untrusted site Mutually exclusive call Notebook best practice violation Stack trace exposure Use of a deprecated method AWS api logging disabled cdk OS command injection AWS credentials logged Missing Authorization CDK Zip bomb attack Sensitive data stored unencrypted due to partial encryption Synchronous publication of AWS Lambda metrics Unrestricted upload of dangerous file type Pytorch redundant softmax Insecure connection using unencrypted protocol Unauthenticated Amazon SNS unsubscribe requests might succeed Insecure Socket Bind Insecure CORS policy Cross-site request forgery Garbage collection prevention in multiprocessing Catch and rethrow exception Weak algorithm used for Password Hashing Missing none check on response metadata Sensitive information leak Client-side KMS reencryption Override of reserved variable names in a Lambda function Docker arbitrary container run Direct dict object modification Catastrophic backtracking regex Resource management errors cdk Resource leak Tensorflow redundant softmax AWS insecure transmission CDK Public method parameter validation Improper error handling Time zone aware datetimes Pytorch control sources of randomness Deadlocks caused by improper multiprocessing API usage Low maintainability with low class cohesion Untrusted AMI images Notebook invalid execution order Confusion between equality and identity in conditional expression Pytorch sigmoid before bceloss Pytorch data loader with multiple workers Pytorch avoid softmax with nllloss Pytorch miss call to zero grad Error prone sequence modification AWS missing encryption of sensitive data cdk Bad exception handling Use of Default Credentials CDK Notebook variable redefinition Do not pass generic exception rule Usage of an API that is not recommended - High Severity Insecure cryptography S3 partial encrypt CDK Cross-site scripting Mutable objects as default arguments of functions Improper Access Control CDK Violation of PEP8 programming recommendations Insecure temporary file or directory Complex code hard to maintain aws kmskey encryption cdk Usage of an API that is not recommended Enabling and overriding debug feature Deserialization of untrusted object Use of an inefficient or incorrect API Avoid using nondeterministic Tensorflow API Inefficient string concatenation inside loop Improper sanitization of wildcards or matching symbols Insecure hashing Using AutoAddPolicy or WarningPolicy Log injection Weak obfuscation of web request Socket close platform compatibility Unsanitized input is run as code Batch request with unchecked failures Inefficient polling of AWS resource Hardcoded interface binding Hardcoded IP address Hardcoded credentials Server-side request forgery Module injection Unnecessary iteration Tensorflow control sources of randomness Missing Authentication for Critical Function CDK Usage of an API that is not recommended - Medium Severity Unsafe Cloudpickle Load Incorrect binding of SNS publish operations PyTorch create tensors directly on device Inefficient new method from hashlib Dangerous global variables Multiple values in return statement is prone to error LDAP injection Clear text credentials Missing S3 bucket owner condition AWS missing encryption CDK

Tag: top25-cwes

Improper privilege management

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

Integer overflow

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

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.

XML External Entity

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

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.

Missing authorization

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

SQL injection

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

URL redirection to untrusted site

User-controlled input that specifies a link to an external site could lead to phishing attacks and allow user credentials to be stolen.

OS command injection

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

Unrestricted upload of dangerous file type

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

Insecure Socket Bind

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

Cross-site request forgery

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

Sensitive information leak

Exposure of sensitive information can lead to an unauthorized actor having access to the information.

Docker arbitrary container run

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

Resource leak

Allocated resources are not released properly.

Public method parameter validation

Public method parameters should be validated for nullness, unexpected values, and malicious values.

Cross-site scripting

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

Deserialization of untrusted object

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

Weak obfuscation of web request

Weak obfuscation while configuring a web request.

Unsanitized input is run as code

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

Hardcoded credentials

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

Server-side request forgery

Insufficient sanitization of potentially untrusted URLs on the server side can allow server requests to unwanted destinations.

Unsafe Cloudpickle Load

Pickling issues on Cloudpickle Load.