Trustline Frontend application

Trustline API and App

The software receives input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could be interpreted as escape, meta, or control character sequences when they are sent to a downstream component.

Improper Neutralization of Escape, Meta, or Control Sequences

The application stores dangerous data in a database, message forum, visitor log, or other trusted data store. At a later time, the dangerous data is subsequently read back into the application and included in dynamic content. From an attackers perspective, the optimal place to inject malicious content is in an area that is displayed to either many users or particularly interesting users. Interesting users typically have elevated privileges in the application or interact with sensitive data that is valuable to the attacker. If one of these users executes malicious content, the attacker may be able to perform privileged operations on behalf of the user or gain access to sensitive data belonging to the user. For example, the attacker might inject XSS into a log message, which might not be handled properly when an administrator views the logs.

Cross-site Scripting (XSS) - Stored

The product does not validate or incorrectly validates input that can affect the control flow or data flow of a program.

Improper Input Validation

Replicating malicious code, including viruses and worms, will attempt to attack other systems once it has successfully compromised the target system or software.

Replicating Malicious Code (Virus or Worm)

The software creates a communication channel to initiate an outgoing request to an actor, but it does not correctly specify the intended destination for that actor.

Incorrectly Specified Destination in a Communication Channel

Wrap around errors occur whenever a value is incremented past the maximum value for its type and therefore \"wraps around\" to a very small, negative, or undefined value.

Wrap-around Error

The software does not follow, or incorrectly follows, the chain of trust for a certificate back to a trusted root certificate, resulting in incorrect trust of any resource that is associated with that certificate.

Improper Following of a Certificates Chain of Trust

The software does not properly anticipate or handle exceptional conditions that rarely occur during normal operation of the software.

Improper Check or Handling of Exceptional Conditions

The web application does not, or can not, sufficiently verify whether a well-formed, valid, consistent request was intentionally provided by the user who submitted the request.

Cross-Site Request Forgery (CSRF)

The software reads data past the end, or before the beginning, of the intended buffer.

Out-of-bounds Read

The software imports, requires, or includes executable functionality (such as a library) from a source that is outside of the intended control sphere.

Inclusion of Functionality from Untrusted Control Sphere

The systems authorization functionality does not prevent one user from gaining access to another users data or record by modifying the key value identifying the data.

Insecure Direct Object Reference (IDOR)

The application does not neutralize or incorrectly neutralizes web scripting syntax in HTTP headers that can be used by web browser components that can process raw headers, such as Flash.

Improper Neutralization of HTTP Headers for Scripting Syntax

When malformed or abnormal HTTP requests are interpreted by one or more entities in the data flow between the user and the web server, such as a proxy or firewall, they can be interpreted inconsistently, allowing the attacker to \"smuggle\" a request to one device without the other device being aware of it.

HTTP Request Smuggling

The software does not properly neutralize special elements that are used in XML, allowing attackers to modify the syntax, content, or commands of the XML before it is processed by an end system.

XML Injection

The application was deployed with active debugging code that can create unintended entry points.

Leftover Debug Code (Backdoor)

The Android application exports a component for use by other applications, but does not properly restrict which applications can launch the component or access the data it contains.

Improper Export of Android Application Components

The software uses XML documents and allows their structure to be defined with a Document Type Definition (DTD), but it does not properly control the number of recursive definitions of entities.

XML Entity Expansion

The product uses a Pseudo-Random Number Generator (PRNG) in a security context, but the PRNG is not cryptographically strong.

Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)

According to WASC, \"Insufficient Session Expiration is when a web site permits an attacker to reuse old session credentials or session IDs for authorization.\"

Insufficient Session Expiration

The program calls a function that can never be guaranteed to work safely.

Use of Inherently Dangerous Function

An information disclosure is the intentional or unintentional disclosure of information to an actor that is not explicitly authorized to have access to that information.

Information Disclosure

The software receives input from an upstream component, but it does not restrict or incorrectly restricts the input before it is used as an identifier for a resource that may be outside the intended sphere of control.

Resource Injection

The software reads from a buffer using buffer access mechanisms such as indexes or pointers that reference memory locations after the targeted buffer.

Buffer Over-read

Authenticating a user, or otherwise establishing a new user session, without invalidating any existing session identifier gives an attacker the opportunity to steal authenticated sessions.

Session Fixation

The software generates an error message that includes sensitive information about its environment, users, or associated data.

Information Exposure Through an Error Message

Nonces should be used for the present occasion and only once.

Reusing a Nonce, Key Pair in Encryption

The accidental exposure of sensitive information through sent data refers to the transmission of data which are either sensitive in and of itself or useful in the further exploitation of the system through standard data channels.

Information Exposure Through Sent Data

The product does not properly control the amount of recursion that takes place, which consumes excessive resources, such as allocated memory or the program stack.

Uncontrolled Recursion

The server reads data directly from the HTTP request and reflects it back in the HTTP response. Reflected XSS exploits occur when an attacker causes a victim to supply dangerous content to a vulnerable web application, which is then reflected back to the victim and executed by the web browser. The most common mechanism for delivering malicious content is to include it as a parameter in a URL that is posted publicly or e-mailed directly to the victim. URLs constructed in this manner constitute the core of many phishing schemes, whereby an attacker convinces a victim to visit a URL that refers to a vulnerable site. After the site reflects the attackers content back to the victim, the content is executed by the victims browser.

Cross-site Scripting (XSS) - Reflected

The software allocates a reusable resource or group of resources on behalf of an actor without imposing any restrictions on how many resources can be allocated, in violation of the intended security policy for that actor.

Allocation of Resources Without Limits or Throttling

When an actor claims to have a given identity, the software does not prove or insufficiently proves that the claim is correct.

Improper Authentication - Generic

The product uses a cryptographic key or password past its expiration date, which diminishes its safety significantly by increasing the timing window for cracking attacks against that key.

Use of a Key Past its Expiration Date

The application does not handle or incorrectly handles when it has insufficient privileges to access resources or functionality as specified by their permissions. This may cause it to follow unexpected code paths that may leave the application in an invalid state.

Improper Handling of Insufficient Permissions or Privileges

The software performs reverse DNS resolution on an IP address to obtain the hostname and make a security decision, but it does not properly ensure that the IP address is truly associated with the hostname.

Reliance on Reverse DNS Resolution for a Security-Critical Action

The software constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component.

OS Command Injection

The product uses a hashing algorithm that produces a hash value that can be used to determine the original input, or to find an input that can produce the same hash, more efficiently than brute force techniques.

Reversible One-Way Hash

The product subtracts one value from another, such that the result is less than the minimum allowable integer value, which produces a value that is not equal to the correct result.

Integer Underflow

The product stores sensitive information in files or directories that are accessible to actors outside of the intended control sphere.

File and Directory Information Exposure

The web server receives a URL or similar request from an upstream component and retrieves the contents of this URL, but it does not sufficiently ensure that the request is being sent to the expected destination.

Server-Side Request Forgery (SSRF)

The software reads from a buffer using buffer access mechanisms such as indexes or pointers that reference memory locations prior to the targeted buffer.

Buffer Under-read

Creating and using insecure temporary files can leave application and system data vulnerable to attack.

Insecure Temporary File

The software does not implement a required step in a cryptographic algorithm, resulting in weaker encryption than advertised by that algorithm.

Missing Required Cryptographic Step

Security based on event locations are insecure and can be spoofed.

Trust of System Event Data

The storage of passwords in a recoverable format makes them subject to password reuse attacks by malicious users. In fact, it should be noted that recoverable encrypted passwords provide no significant benefit over plaintext passwords since they are subject not only to reuse by malicious attackers but also by malicious insiders. If a system administrator can recover a password directly, or use a brute force search on the available information, the administrator can use the password on other accounts.

Storing Passwords in a Recoverable Format

Weaknesses in this category identify some of the underlying problems that commonly allow attackers to manipulate the business logic of an application.

Business Logic Errors

The program allocates or initializes a resource such as a pointer, object, or variable using one type, but it later accesses that resource using a type that is incompatible with the original type.

Type Confusion

An adversary exploits a weakness enabling them to elevate their privilege and perform an action that they are not supposed to be authorized to perform.

Privilege Escalation

The software compares two entities in a security-relevant context, but the comparison is incorrect, which may lead to resultant weaknesses.

Incorrect Comparison

The application contains debugging code that can expose sensitive information to untrusted parties.

Information Exposure Through Debug Information

The user interface (UI) does not properly represent critical information to the user, allowing the information - or its source - to be obscured or spoofed. This is often a component in phishing attacks.

User Interface (UI) Misrepresentation of Critical Information

The software constructs all or part of a command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended command when it is sent to a downstream component.

Command Injection - Generic

The software does not properly prevent private data (such as credit card numbers) from being accessed by actors who either (1) are not explicitly authorized to access the data or (2) do not have the implicit consent of the people to which the data is related.

Privacy Violation

The software does not properly assign, modify, track, or check privileges for an actor, creating an unintended sphere of control for that actor.

Improper Privilege Management

The product uses untrusted input when calculating or using an array index, but the product does not validate or incorrectly validates the index to ensure the index references a valid position within the array.

Array Index Underflow

The software performs an operation at a privilege level that is higher than the minimum level required, which creates new weaknesses or amplifies the consequences of other weaknesses.

Execution with Unnecessary Privileges

The software receives input from an upstream component, but it does not neutralize or incorrectly neutralizes special characters such as \"<\", \">\", and \"&\" that could be interpreted as web-scripting elements when they are sent to a downstream component that processes web pages.

Improper Neutralization of Script-Related HTML Tags in a Web Page (Basic XSS)

A lack of binary protections within a mobile app exposes the application and itâs owner to a large variety of technical and business risks if the underlying application is insecure or exposes sensitive intellectual property. A lack of binary protections results in a mobile app that can be analyzed, reverse-engineered, and modified by an adversary in rapid fashion. An adversary will use an automated tool to reverse engineer the code and modify it using malware to perform some hidden functionality.

Lack of Binary Hardening

The software processes an XML document that can contain XML entities with URIs that resolve to documents outside of the intended sphere of control, causing the product to embed incorrect documents into its output.

XML External Entities (XXE)

The software does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users.

Cross-site Scripting (XSS) - Generic

The software uses a name or reference to access a resource, but the name/reference resolves to a resource that is outside of the intended control sphere.

Use of Incorrectly-Resolved Name or Reference

The software uses a protection mechanism whose strength depends heavily on its obscurity, such that knowledge of its algorithms or key data is sufficient to defeat the mechanism.

Security Through Obscurity

The software uses a function that accepts a format string as an argument, but the format string originates from an external source.

Use of Externally-Controlled Format String

The software contains a hard-coded password, which it uses for its own inbound authentication or for outbound communication to external components.

Use of Hard-coded Password

This weakness occurs when the application transmits or stores authentication credentials and uses an insecure method that is susceptible to unauthorized interception and/or retrieval.

Insufficiently Protected Credentials

A stack-based buffer overflow condition is a condition where the buffer being overwritten is allocated on the stack (i.e., is a local variable or, rarely, a parameter to a function).

Stack Overflow

The application contains code that appears to be malicious in nature.

Embedded Malicious Code

The application stores sensitive information in cleartext within a resource that might be accessible to another control sphere.

Cleartext Storage of Sensitive Information

The product behaves differently or sends different responses in a way that exposes security-relevant information about the state of the product, such as whether a particular operation was successful or not.

Information Exposure Through Discrepancy

The software performs a calculation that can produce an integer overflow or wraparound, when the logic assumes that the resulting value will always be larger than the original value. This can introduce other weaknesses when the calculation is used for resource management or execution control.

Integer Overflow

The software does not restrict or incorrectly restricts access to a resource from an unauthorized actor.

Improper Access Control - Generic

Referencing memory after it has been freed can cause a program to crash, use unexpected values, or execute code.

Use After Free

The application deserializes untrusted data without sufficiently verifying that the resulting data will be valid.

Deserialization of Untrusted Data

The software uses external input to construct a pathname that should be within a restricted directory, but it does not properly neutralize .../...// (doubled triple dot slash) sequences that can resolve to a location that is outside of that directory.

Path Traversal: .../...//

The software does not properly handle when all or part of an input has been URL encoded.

Improper Handling of URL Encoding (Hex Encoding)

An application uses a \"blacklist\" of prohibited values, but the blacklist is incomplete.

Incomplete Blacklist

The software writes to a buffer using an index or pointer that references a memory location prior to the beginning of the buffer.

Buffer Underflow

A NULL pointer dereference occurs when the application dereferences a pointer that it expects to be valid, but is NULL, typically causing a crash or exit.

NULL Pointer Dereference

The software constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the syntax or behavior of the intended code segment.

Code Injection

The application uses a protection mechanism that relies on the existence or values of an input, but the input can be modified by an untrusted actor in a way that bypasses the protection mechanism.

Reliance on Untrusted Inputs in a Security Decision

Phishing is a social engineering technique where an attacker masquerades as a legitimate entity with which the victim might do business in order to prompt the user to reveal some confidential information (very frequently authentication credentials) that can later be used by an attacker. Phishing is essentially a form of information gathering or \"fishing\" for information.

Phishing

The software does not perform any authentication for functionality that requires a provable user identity or consumes a significant amount of resources.

Missing Authentication for Critical Function

Two separate operations in a product require different amounts of time to complete, in a way that is observable to an actor and reveals security-relevant information about the state of the product, such as whether a particular operation was successful or not.

Information Exposure Through Timing Discrepancy

The software contains a mechanism for users to recover or change their passwords without knowing the original password, but the mechanism is weak.

Weak Password Recovery Mechanism for Forgotten Password

The product does not adequately verify the identity of actors at both ends of a communication channel, or does not adequately ensure the integrity of the channel, in a way that allows the channel to be accessed or influenced by an actor that is not an endpoint.

Man-in-the-Middle

The software is composed of a server that relies on the client to implement a mechanism that is intended to protect the server.

Client-Side Enforcement of Server-Side Security

A heap overflow condition is a buffer overflow, where the buffer that can be overwritten is allocated in the heap portion of memory, generally meaning that the buffer was allocated using a routine such as malloc().

Heap Overflow

The software does not encrypt sensitive or critical information before storage or transmission.

Missing Encryption of Sensitive Data

The software specifies permissions for a security-critical resource in a way that allows that resource to be read or modified by unintended actors.

Incorrect Permission Assignment for Critical Resource

The software does not handle or incorrectly handles a compressed input with a very high compression ratio that produces a large output.

Improper Handling of Highly Compressed Data (Data Amplification)

The software contains hard-coded credentials, such as a password or cryptographic key, which it uses for its own inbound authentication, outbound communication to external components, or encryption of internal data.

Use of Hard-coded Credentials

The software does not properly protect an assumed-immutable element from being modified by an attacker.

Modification of Assumed-Immutable Data (MAID)

The software performs an authorization check when an actor attempts to access a resource or perform an action, but it does not correctly perform the check. This allows attackers to bypass intended access restrictions.

Incorrect Authorization

In DOM-based XSS, the client performs the injection of XSS into the page; in the other types, the server performs the injection. DOM-based XSS generally involves server-controlled, trusted script that is sent to the client, such as Javascript that performs sanity checks on a form before the user submits it. If the server-supplied script processes user-supplied data and then injects it back into the web page (such as with dynamic HTML), then DOM-based XSS is possible.

Cross-site Scripting (XSS) - DOM

The software does not correctly calculate the size to be used when allocating a buffer, which could lead to a buffer overflow.

Incorrect Calculation of Buffer Size

The use of a hard-coded cryptographic key significantly increases the possibility that encrypted data may be recovered.

Use of Hard-coded Cryptographic Key

A product calculates or uses an incorrect maximum or minimum value that is 1 more, or 1 less, than the correct value.

Off-by-one Error

Login pages not using adequate measures to protect the user name and password while they are in transit from the client to the server.

Unprotected Transport of Credentials

The software does not implement sufficient measures to prevent multiple failed authentication attempts within in a short time frame, making it more susceptible to brute force attacks.

Brute Force

Use of components with known vulnerabilities and lack of version upgrades or other mitigations in place. This is an unusual category. CWE does not cover the limitations of human processes and procedures that cannot be described in terms of a specific technical weakness as resident in the code, architecture, or configuration of the software. Since known vulnerabilities can arise from any kind of weakness, it is not possible to map this OWASP category to other CWE entries, since it would effectively require mapping this category to ALL weaknesses.

TrustlineVulnerabilityDisclosureProgram

by Trustline

reporterData

reportTitle*

vulnerabilityType*

proofOfConcept