Black-box assessment of a lab e-commerce app: 10 findings (4 Critical, 4 High, 2 Moderate) from recon to full database and admin compromise.
Important (Authorized lab environment)
This is the final project of a Red Team bootcamp run by Dibimbing. The target, Dibimbing-Shop (bimbycart.duckdns.org), was an intentionally vulnerable e-commerce application provided by Dibimbing as an isolated, authorized test target, and Dibimbing approved publishing this write-up. The target’s own identifiers (application name, host, IP) are shown as-is. What is not shown, because testing authorization does not extend to republishing it, is redacted: credentials and passwords, session cookies/IDs, customer personal data, and third-party identities such as the exposed repository’s owner (written as <REDACTED>).
Executive summary
Dibimbing-Shop is a PHP e-commerce application that stores customer PII (names, emails, phone numbers, addresses) and payment records. I assessed it black box, with no source code or credentials at the start, and reached full compromise within the test window.
The assessment produced 10 findings: 4 Critical, 4 High, 2 Moderate — 8 of 10 at Critical/High, meaning the application in its tested state does not adequately protect customer or transaction data.
The core problems:
Input validation and authorization are not enforced server-side. A SQL injection in the coupon field exposes the entire database; IDORs in the admin panel and the order flow let users reach data that isn’t theirs; price is trusted from the client at checkout.
Credential and session handling is weak. Passwords are stored in plaintext, the password reset doesn’t verify account ownership, and sessions are never invalidated on logout.
Sensitive information is exposed. A public .git directory leaks the full source and a database backup.
Transport is unprotected. The app serves plain HTTP, so credentials and session cookies travel in cleartext.
Combined, these allow leakage of customer PII and payment data, direct financial loss through price manipulation, and account takeover of both customers and administrators.
Scope & methodology
Target
Dibimbing-Shop, a PHP e-commerce app (storefront + /admin_area/)
Roles tested
Unauthenticated guest, customer, admin (user/admin access obtained through exploitation, not provided)
Test type
Black box — no source code or credentials given at the start
Methodology
OWASP Web Security Testing Guide (WSTG), CVSS 3.1 scoring
Active scanning, manual exploitation, proof of concept
Not allowed (RoE)
Denial of service, permanent data destruction, defacement
Test window
2–11 November 2026
Severity ratings
Findings are scored with CVSS 3.1 and grouped as follows (used throughout this report):
Severity
CVSS range
Meaning
Critical
9.0–10.0
Straightforward exploitation, usually full compromise. Patch immediately.
High
7.0–8.9
Harder to exploit but can elevate privilege or lose data. Patch as soon as possible.
Moderate
4.0–6.9
Exploitable only with extra steps or conditions. Patch after high-priority items.
Low
0.1–3.9
Not directly exploitable; reduces attack surface. Patch in the next window.
Findings summary
All 10 findings, ordered from Critical to Moderate. Full write-ups, each with description, CVSS, evidence and remediation, are on the Findings page in the same order.
#
Finding
Category
Severity
CVSS
1
Improper session expiration — session hijacking via cookie replay
Session management
Critical
9.1
2
SQL injection in the coupon code parameter — full database compromise
Injection
Critical
9.8
3
IDOR in admin user_profile — admin-to-admin takeover & password disclosure
Access control
Critical
9.6
4
Account takeover via insecure password reset
Authentication
Critical
9.1
5
Information disclosure — exposed .git repository
Information disclosure
High
7.5
6
Stored XSS in the profile name field
XSS
High
7.6
7
IDOR in confirm.php — access & confirm other users’ orders
Access control
High
8.1
8
Insecure password storage (plaintext)
Cryptographic failure
High
7.5
9
Parameter tampering on add-to-cart / checkout price
Business logic
Moderate
6.5
10
Missing HTTPS — cleartext transmission of credentials
Insecure transport
Moderate
6.5
Report contents
Introduction (this page): executive summary, scope, methodology, severity ratings and the findings summary.
Reconnaissance & Scanning: OSINT, technology, open ports, content discovery and application mapping.
Findings: all 10 findings in severity order, each with description, CVSS, evidence and remediation.
Conclusion: root causes, how the findings chain together, and the overall business impact.
OSINT, technology fingerprinting, port scanning and content discovery that mapped Dibimbing-Shop's attack surface before any exploitation.
The goal of this phase was to understand what Dibimbing-Shop is made of and where it might be weak, without exploiting anything yet. Each step answers one question, and the answer decides what to look at next.
Note (On the data shown)
The target is an authorized Dibimbing lab, so its real host (bimbycart.duckdns.org) and IP (188.166.209.84) are shown. Credentials, session values, personal data and third-party identities are redacted. Results are summarized from the original scan output and notes.
1. Hosting and ownership (OSINT)
Terminal window
nslookupbimbycart.duckdns.org
whois188.166.209.84
The hostname resolves through a dynamic DNS service rather than a conventional registrar, and WHOIS on the IP points to a cloud VPS provider (Singapore region). WHOIS gives no real owner details, because the cloud provider fronts them.
Why it matters: this is a single cloud VM, not a corporate network. The attack surface is whatever that one VM exposes, so port and content discovery matter more than hunting for sibling hosts.
2. Technology fingerprinting
Terminal window
whatwebhttp://bimbycart.duckdns.org
curl-sIhttp://bimbycart.duckdns.org
Component
Observation
Web server
Apache (Server header)
Backend
PHP (PHPSESSID cookie)
Frontend
Bootstrap, HTML5
Contact email
A real-looking contact address exposed in page source (useful for phishing pretexts in a real engagement)
Cache headers
Cache-Control: no-store, no-cache, must-revalidate with Expires in 1981 — the PHP session default, so there are session-backed pages
Session cookie
PHPSESSIDwithout the HttpOnly flag
Why it matters: PHP with a hand-rolled storefront suggests string-built SQL queries, raising the priority of injection testing. A session cookie without HttpOnly means any XSS can read the session — this pair predicted Findings 2, 6 and 1.
3. Open ports
Terminal window
nmap-sVbimbycart.duckdns.org
Port
Service
Notes
22
SSH
OpenSSH 8.9p1 (Ubuntu)
80
HTTP
Apache, the shop itself
443
HTTP(S)
Default nginx welcome page, no real TLS site
888
HTTP
Apache, non-standard port
7800
HTTP
nginx, non-standard port
Why it matters: the shop runs only on plain HTTP (port 80), so credentials travel unencrypted (Finding 10). Ports 888 and 7800 are non-standard web ports often used for control panels; I noted them but they were out of scope and the main path didn’t need them.
4. Content discovery
Two brute-force tools, so each validates the other. Gobuster surfaced hidden files; dirb recursed deeper into /admin_area/.
Terminal window
gobusterdir-uhttp://bimbycart.duckdns.org-wcommon.txt# 4,613-entry common-words list
Redirect parameter mirrors the directory name, hinting at dynamic file inclusion
/.git/HEAD
200
The Git repository is publicly readable (Finding 5)
/.svn/, /.htaccess, /.htpasswd
403
Exist but blocked
/server-status, /server-info
403
Apache status modules enabled but blocked
The /.git/HEAD result stood out: a readable .git directory usually means the full source, and often secrets, can be recovered from the server.
5. Application mapping
With Burp Suite proxying the browser, I used the app as a customer and as an admin and logged every endpoint and parameter. The ones worth testing:
Area
Endpoint
Parameters
Why it’s interesting
Login
POST /login.php
c_email, c_pass
Credentials over cleartext?
Session
PHPSESSID cookie
–
Still valid after logout?
Cart
POST /cart.php
code, quantity-<id>, apply_coupon
Coupon looked up in the database
Product
POST /<product-slug>
product_price, product_qty
Price sent from the client
Checkout
GET/POST /customer/confirm.php
order_id, due_amount, invoice_no
Sequential order IDs
Account
POST /customer/my_account.php?edit_account
c_name, …
Stored user input
Reset
POST /functions/fetch_password.php
email
Ownership verified?
Admin
/admin_area/index.php?user_profile=<id>
admin_id, admin_pass, …
Sequential admin IDs, password field in the form
Three patterns stood out and drove the findings: sequential integer IDs (order_id, user_profile, edit_coupon, …) that invite IDOR; client-supplied values the server should own (product_price, due_amount); and a password-reset endpoint that takes only an email.
All 10 findings in severity order (Critical to Moderate), each with description, CVSS 3.1 vector, sanitized evidence and remediation.
The 10 findings below are ordered by severity (Critical → Moderate), matching the report card. Each lists its category, CVSS 3.1 vector, affected endpoint, description, evidence and remediation. The original report numbers findings differently (by section); that number is noted as “report ref.” for traceability.
Note (Sanitized evidence)
Screenshots black out credentials, emails, session (PHPSESSID) values and contact numbers with solid boxes (not reversible blur), and the images have their metadata stripped. In HTTP and tool output, credentials, session values and personal data are redacted as <SESSION_ID>, <VICTIM_EMAIL> and <REDACTED>. The target’s own identifiers (name, host bimbycart.duckdns.org, IP) are shown as-is, since it is an authorized Dibimbing lab.
1. Improper session expiration — session hijacking via cookie replay
Description. The application does not invalidate the session server-side on logout. I captured a logged-in user’s PHPSESSID, logged that browser out, then set the same cookie in a different browser with no login — and was fully authenticated as the victim, without any email or password. The session ID is never destroyed or expired on the server, so a “logged-out” cookie can still be replayed.
Evidence.
The MY ACCOUNT menu and populated cart confirm an authenticated session, using the cookie captured before logout.
Remediation.
Invalidate the session server-side on every logout (destroy the session record, not just the client cookie).
Add idle and absolute session timeouts.
Regenerate the session ID on every privilege change (login, logout, password change).
Set HttpOnly, Secure and SameSite on the session cookie.
2. SQL injection in the coupon code parameter — full database compromise
Description. The coupon code field is concatenated into a SQL query without parameterization, making it injectable (boolean-based, error-based and time-based blind, all confirmed with sqlmap). Through it, an unauthenticated attacker enumerated all databases and the 16 tables of the shop database, dumped the admins table (passwords in plaintext), and used those credentials to log straight into the admin panel — a full database read plus admin account takeover.
Evidence. The captured request was saved and replayed with sqlmap:
Dumping only the admins table (to prove impact without touching customer data) returned the administrator email and a plaintext password, which logged into /admin_area/login.php on the first attempt.
Remediation.
Use parameterized queries / prepared statements for every query involving user input.
Validate and whitelist the code parameter server-side.
Apply least privilege to the application’s database account.
Disable detailed database errors in production; consider a WAF as an extra layer.
Description. The admin profile endpoint selects an admin by a sequential integer ID with no object-level authorization check. Logged in as one admin (via Finding 2), I changed user_profile to another admin’s ID and reached that admin’s edit form — and could not only read it but modify it. The form also returns the stored password in plaintext (CWE-256), so any admin can read and overwrite any other admin’s account.
Evidence.
Remediation.
Enforce object-level authorization on every endpoint that takes an ID.
Use indirect references (per-user UUID/token) for sensitive records instead of sequential IDs.
Add real role separation (RBAC) between admin levels.
Never return the password field (plaintext or hash) in an edit form; leave it empty and only update on change.
Endpoint:POST /functions/fetch_password.php, parameter email · Tools: Burp Suite
Description. The “forgot password” flow takes only an email address and performs no ownership verification. The backend generates a new 8-character password, updates it in the database, and returns it in cleartext through a third-party email API in the request body (template_params.password) — with no confirmation link or token sent to the real owner. Anyone who knows a customer’s email can reset that account and immediately learn the new password.
Evidence.
Reset request (sanitized)
1
POST /functions/fetch_password.php HTTP/1.1
2
Host:bimbycart.duckdns.org
3
4
email=<VICTIM_EMAIL>
Intercepting the resulting traffic showed the backend call the email API with the freshly generated password in cleartext in template_params.password. The source file functions/fetch_password.php confirmed the endpoint updates and returns the password with no validation.
Remediation.
Use a single-use, time-limited reset token emailed to the registered address; never return a new password in the response.
Keep the response identical whether or not the email exists (no account enumeration).
Rate-limit the endpoint, invalidate active sessions on reset, and notify the owner.
5. Information disclosure — exposed .git repository
Severity: High (7.5) · CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
Category: Information disclosure · Report ref.: Finding 1
Endpoint:/.git · Tools: Nmap
Description. The /.git directory is publicly readable (found via Nmap’s http-git script during recon). Its config pointed to a public GitHub repository holding the full application source. Committed alongside the code was a database backup containing the schema and full contents — admin credentials and all customer PII — with passwords in plaintext. No exploitation is needed to obtain any of this.
Evidence.
The DATABASE FILE folder held a full SQL dump; the admin row stored the password as cleartext (<REDACTED_PLAINTEXT_PASSWORD>), not a hash.
Remediation.
Block /.git at the web server (RedirectMatch 404 /\.git for Apache; location ~ /\.git { deny all; } for nginx).
Never commit backups, .env files or credentials; use .gitignore.
Take down / privatize the public repo and purge history; treat all exposed secrets as burned and rotate them.
6. Stored XSS in the profile name field
Severity: High (7.6) · CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:L/A:N
Description. The profile name field is not encoded on output. A payload saved in the name executes when the profile page is reloaded. Because the session cookie has no HttpOnly flag, the script can read document.cookie, which makes this practically usable to steal the session of anyone who views the name — including an administrator, since customer names render in the admin panel. The same missing-encoding pattern appears on several admin fields (edit_product_title, manufacturer_name, cat_title, admin_name), so it is systemic.
Evidence. Proof payload saved in the name field:
1
<script>alert(document.cookie)</script>
On reload the script ran and the alert showed the session cookie:
Remediation.
Output-encode all user data rendered to a page (htmlspecialchars), on customer and admin pages.
Validate input server-side to reject HTML/tags in fields that don’t need them.
Add a Content Security Policy as defense in depth.
Set HttpOnly on the session cookie (links to Finding 1).
7. IDOR in confirm.php — access & confirm other users’ orders
Severity: High (8.1) · CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N
Description. The order-confirmation endpoint does not verify that the requested order_id belongs to the logged-in customer. Any authenticated customer can change order_id in the URL to view, and even confirm the payment status of, another customer’s order. Because the IDs are sequential, the whole range in use at test time (roughly order_id 1–130) can be swept automatically with Burp Intruder.
Evidence.
Request (sanitized)
1
GET /customer/confirm.php?order_id=<other-customers-id> HTTP/1.1
2
Host:bimbycart.duckdns.org
3
Cookie:PHPSESSID=<SESSION_ID>
Changing order_id from my own order to another customer’s loaded and let me act on that order; iterating the range confirmed the pattern across ~130 orders.
Remediation.
Verify that the requested order_id belongs to the session’s customer before reading or processing anything.
Apply authorization middleware consistently to every endpoint that reads user-owned data (orders, cart, wishlist, history).
Prefer unpredictable identifiers; add logging and rate limiting to detect sequential-ID sweeps.
8. Insecure password storage (plaintext)
Severity: High (7.5) · CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
Endpoint:customers table (observed via the Finding 2 dump) · Tools: Burp Suite, sqlmap
Description. The database dump showed the customers table (like admins) storing passwords as cleartext, with no hashing or salting (no $2y$... bcrypt prefix or any hash). This is a separate root cause from the injection that exposed it: injection is an input-validation failure, this is a data-at-rest failure. Its effect is a multiplier — every password reachable through any leak path (the .git backup, the SQL injection) is usable immediately, and reusable against the victim’s accounts elsewhere (credential stuffing).
Evidence.
customer / admin password column: stored as <plaintext>, no hash prefix (e.g. no "$2y$...")
Remediation.
Hash all passwords with a slow algorithm (argon2id or bcrypt) and a unique per-user salt.
Force a password reset for every existing account after migrating (the stored plaintext is already exposed).
Enforce a minimum password policy on registration and change.
9. Parameter tampering on add-to-cart / checkout price
Endpoint:POST /<product-slug>, parameter product_price · Tools: Burp Suite
Description. The add-to-cart request sends the product price from the client, and the server accepts it without re-checking against the catalog price in the database. I intercepted the request in Burp Suite, changed product_price from a product’s real price to a token amount, and completed checkout — the order finished with status Paid at the tampered price, proving there is no server-side price re-validation anywhere in the flow (cart → checkout → payment).
Endpoint: all application endpoints · Tools: Wireshark
Description. The shop serves only plain HTTP — no redirect to HTTPS, no certificate. All traffic, including login credentials, session cookies and transaction data, travels in cleartext and can be read by anyone on the same network path (a man-in-the-middle). Capturing my own test login on my own test network showed the POST /login.php body with the credentials in the clear.
Evidence.
Captured login (sanitized)
1
POST /login.php HTTP/1.1
2
Host:bimbycart.duckdns.org
3
4
c_email=<VICTIM_EMAIL>&c_pass=<VICTIM_PASSWORD>
The vector is adjacent (AV:A): an attacker on the same network (public Wi-Fi, shared LAN) can sniff every login and session cookie, which also feeds the session-hijacking finding.
Remediation.
Install a valid TLS certificate (e.g. Let’s Encrypt) and redirect all HTTP to HTTPS (301).
Mark session cookies Secure.
Add HSTS to prevent downgrade / SSL-stripping; check for mixed content once HTTPS is on.
The four root causes behind Dibimbing-Shop's 10 findings, how they chain into full compromise, and the overall business impact and priorities.
The black-box assessment of Dibimbing-Shop identified 10 vulnerabilities: 4 Critical, 4 High, 2 Moderate. Every finding was proven with a proof of concept, and at the time of the report all were open. Eight of ten are Critical or High, so the application in its tested state is not adequate to protect customer or transaction data.
Four root causes
The 10 findings reduce to four underlying problems:
Input validation and authorization are not enforced server-side. The SQL injection in the coupon code parameter (Finding 2), the two IDORs in the admin panel and the order flow (Findings 3 and 7), the stored XSS (Finding 6), and the checkout price tampering (Finding 9) all come from trusting data sent by the client.
Credential and session management is weak. Customer and admin passwords are stored in plaintext (Finding 8), the password reset does not verify ownership (Finding 4), and sessions are never invalidated on logout (Finding 1).
Sensitive information is exposed. The .git directory is publicly accessible and contains the source code and a database backup with admin credentials and customer PII (Finding 5).
Transport is unprotected. The app serves only HTTP, so credentials and session cookies travel in cleartext (Finding 10).
How the findings chain together
The vulnerabilities are not isolated; they combine into realistic attack paths:
[no access]
│ exposed .git (5) OR SQL injection (2)
▼
[admin credentials] ──► log in to /admin_area/
│ IDOR in user_profile (3)
▼
[take over every admin account, read their plaintext passwords]
[any email address]
│ insecure password reset (4)
▼
[take over that customer account]
[same network as a shopper] [a crafted name rendered to a viewer]
│ no HTTPS (10): sniff the cookie │ stored XSS (6) + cookie without HttpOnly
▼ ▼
[obtain a session cookie] ──► session never expires (1) ──► durable account access
An attacker with no account can obtain administrator credentials from the .git leak or the SQL injection, enter the admin panel, and take over other admin accounts through the IDOR.
Any customer can be taken over with only their email address, through the password-reset flow.
Plaintext storage (Finding 8) means every password seen along any of these paths is usable immediately, including against the victim’s accounts on other services.
Business impact
Exploited together, these findings risk:
Leakage of customer PII and payment data (through the .git backup, the SQL injection, and the order IDOR).
Direct financial loss through checkout price manipulation.
Account takeover of both customers and administrators.
Reputational damage and loss of user trust if exploited by an external party.
Priorities
Fixing the top of each root-cause area breaks every chain at its source rather than patching symptoms:
Priority
Action
Closes
1
Parameterized queries everywhere user input reaches SQL
Finding 2
2
Block /.git; take down the public repo and backup; rotate secrets
Finding 5
3
Server-side object-level authorization on every ID parameter
Findings 3, 7
4
Token-based password reset; destroy sessions on logout + expiry
Findings 4, 1
5
Hash all passwords (argon2id/bcrypt); force a reset of existing ones
Finding 8
6
Output-encode all user data; set HttpOnly; add CSP
Finding 6
7
Re-read price from the database server-side
Finding 9
8
TLS everywhere, redirect HTTP→HTTPS, HSTS, Secure cookies
Finding 10
Full per-finding remediation is on the Findings page.