Tag: owasp-top10
The software does not restrict or incorrectly restrict access to a resource from an unauthorized actor.
Encryption that is dependent on conditional logic, such as an if...then
clause, might cause unencrypted sensitive data to be stored.
Using pseudorandom number generators (PRNGs) is security-sensitive.
Constructing operating system or shell commands with unsanitized user input can lead to inadvertently running malicious code.
User-controlled input that specifies a link to an external site could lead to phishing attacks and allow user credentials to be stolen.
Passing an unsanitized user argument to a function call makes your code insecure.
Objects that parse or handle XML can lead to XML external entity (XXE) attacks when they are misconfigured.
Insufficient sanitization of potentially untrusted URLs on the server side can allow server requests to unwanted destinations.
Use of new Function()
can be dangerous if used to evaluate dynamic content.
Stack traces can be hard to use for debugging.
Hardcoded credentials can be intercepted by malicious actors.
Insecure cookies can lead to unencrypted transmission of sensitive data.
Relying on potentially untrusted user inputs when constructing web application outputs can lead to cross-site scripting vulnerabilities.
Logging unencrypted AWS credentials can expose them to an attacker.
Potentially unsanitized user input in XPath queries can allow an attacker to control the query in unwanted or insecure ways.
Creating file paths from untrusted input might give a malicious actor access to sensitive files.
Allocated resources are not released properly.
An object attribute constructed from a user-provided input should not be passed directly to a method.
Connections that use insecure protocols transmit data in cleartext, which can leak sensitive information.
Insecure configuration can lead to a cross-site request forgery (CRSF) vulnerability.
Allowing hidden files while serving files from a given root directory can cause information leakage.
Obsolete, broken, or weak hashing algorithms can lead to security vulnerabilities.
Client-side decryption followed by encryption is inefficient and can lead to sensitive data leaks.
LDAP queries that rely on potentially untrusted inputs can allow attackers to read or modify sensitive data, run code, and perform other unwanted actions.
Insufficient key sizes can lead to brute force attacks.
Unverified hostnames lead to security vulnerabilities.
Unverified origins of messages and identities in cross-origin communications can lead to security vulnerabilities.
Weak file permissions can lead to privilege escalation.
Scripts generated from unsanitized inputs can lead to malicious behavior and inadvertently running code remotely.
Lack of validation of a security certificate can lead to host impersonation and sensitive data leaks.
Cross-origin resource sharing policies that are too permissive could lead to security vulnerabilities.
Deserialization of untrusted objects can lead to security vulnerabilities such as, inadvertently running remote code.
Exposure of sensitive information can lead to an unauthorized actor having access to the information.
Weak obfuscation of web requests makes your application vulnerable.
The logging of sensitive information can expose the information to potential attackers.
Significant content length can lead to denial of service.
Using untrusted inputs in a log statement can enable attackers to break the log's format, forge log entries, and bypass log monitors.
The application incorrectly restricts frame objects or UI layers that belong to another application or domain.
Weak, broken, or misconfigured cryptography can lead to security vulnerabilities.
Updating object attributes obtained from external sources is security sensitive.
Session fixation might allow an attacker to steal authenticated session IDs.
Improper input validation can enable attacks and lead to unwanted behavior.
Disabling the HTML autoescape mechanism exposes your web applications to attacks.
Expanding unverified archive files without controlling the size of the expanded data can lead to zip bomb attacks.
Writing unsanitized user data to a file is unsafe.
The software allows user input to control or influence paths or file names that are used in file system operations.
The use of untrusted inputs in a SQL database query can enable attackers to read, modify, or delete sensitive data in the database.
Constructing HTTP response headers from user-controlled data is unsafe.
Insecure ways of creating temporary files and directories can lead to race conditions, privilege escalation, and other security vulnerabilities.