Key Takeaways
- “Parameter tampering” has been identified as the core attack technique behind a series of hacking incidents in the Korean financial sector, with analysts pointing to “insufficient authorization” as the root vulnerability that allowed this method to succeed.
- An estimated 7 financial firms, including Shinhan Bank, suffered damage. The attack appears to have followed a multi-stage flow, moving from automated credential stuffing by an AI agent to parameter tampering.
- This case highlights the consequences of failing to distinguish between Authentication and Authorization: even when multi-factor authentication functions normally, it cannot prevent authorization flaws caused by missing server-side permission validation.
An insufficient authorization flaw — in which an attacker who has passed authentication accesses data beyond their permissions through tampered parameters — cannot be blocked by authentication hardening alone, such as MFA. Server-side ownership verification at the API layer and the application of centralized authorization policies are essential.
Table of Contents
- Key Takeaways
- 1. Incident Overview: 72 Hours That Swept Through 1st and 2nd Tier Financial Firms
- 2. Attack Flow: From Credential Stuffing to Parameter Tampering
- 3. How Insufficient Authorization Works: The Hotel Key Card Analogy
- 4. Why the Attack Targeted Internal Business Systems
- 5. Why Authentication Hardening Alone Cannot Stop This
Seven financial firms, including Shinhan Bank, were breached in succession within 72 hours. The attack began with automated credential stuffing run by an AI agent and ended with a single line of parameter tampering. The real lesson this incident leaves behind is not “let’s strengthen MFA,” but rather the fact that “the moment server-side authorization validation is omitted, all authentication is rendered useless.”
Synthesizing the technical background from Boannews’ incident analysis article and threat intelligence, the attacker logged in normally with a standard user account, then manipulated the resource identifier in the request body to access another customer’s data. How KISA’s emergency response procedures were activated was covered in KISA emergency response analysis; this article focuses on the attack mechanism and the structural causes of the authorization flaw.
1. Incident Overview: 72 Hours That Swept Through 1st and 2nd Tier Financial Firms
In early October 2026, 7 financial firms including Shinhan Bank detected abnormal access one after another. On the surface, the API calls resembled normal activity — small-amount account inquiries and loan agent information lookups — so traffic-based DDoS detection and signature-based IPS systems were not triggered. As outlined in The Quiet Infiltration of AI-Powered Attacks on the Financial Sector, the attack was uncovered only thanks to behavior-based monitoring and internal data integrity checks at the financial firms.
2. Attack Flow: From Credential Stuffing to Parameter Tampering
The attack unfolded in two stages. In stage 1, the AI agent automatically injected Korean email and password combinations harvested from the dark web into each financial firm’s login endpoint. Some dormant accounts and accounts with high password reuse rates were compromised, yielding a large number of valid sessions.
Stage 2 is the main event. When calling internal APIs with the obtained sessions, the attacker sequentially incremented resource identifiers such as userId or accountNo in the request body to read other customers’ information. In Burp Suite’s Repeater, the authentication header was left untouched, and a single-line change from {"userId":12345} to {"userId":12346} was enough for another user’s data to be included in the response.
3. How Insufficient Authorization Works: The Hotel Key Card Analogy
Authentication is the process of proving “who I am,” while Authorization is the process of determining “whether that identity is qualified to access this resource.” In this incident, the two were not separated.
An analogy would be a hotel key card system. A guest who has completed identity verification at the front desk receives a key card with their room number printed on it. However, if the backend system only checks the room number on the key card and fails to block cases where a guest passes a different room number directly as a URL parameter, that is not an authentication problem — it is an authorization defect.
This is the most common pattern I encounter in the field during audits. Even when login is well implemented, nearly half of the APIs are missing the code that checks whether “a request coming in with this user ID actually touches only that user’s own resources.” When permission checks are copy-pasted into each controller, it is realistic that one or two end up missing.
4. Why the Attack Targeted Internal Business Systems
An interesting point about the surface of this attack is that the targets were not customer-facing services like internet banking or mobile apps, but rather internal business APIs such as loan agent inquiry systems, employee mobile systems, and ODS (Operational Data Store). The reason is simple: backend authorization logic is often omitted under the assumption that “this is an internal network or only authorized employees can access it.”
The problem is that the very assumption — that the system is only called from devices controlled by VPN and MDM — has been broken. If a valid session coming from outside can call the same internal API as-is, that “internal-only” label is nothing more than a documentation comment, not a security control.
5. Why Authentication Hardening Alone Cannot Stop This
The most commonly cited response right after this incident was “accelerate MFA adoption.” But MFA only strengthens the authentication stage and is powerless against a scenario in which an attacker who already has a valid session simply changes parameters to disguise their own resources as someone else’s. The issue is not whether the session is genuine or fake, but whether the session has the right to touch that resource.
6. OWASP API Security Top 10 Mapping
S-Care’s analysis mapped this technique to two items on the OWASP API Security Top 10. The first is API1:2023 Broken Object Level Authorization (BOLA), a classic case of missing object-level ownership checks. The second is API3:2023 Excessive Data Exposure, in which the response returned to one user includes fields belonging to other users.
| OWASP API Item | Manifestation in This Incident | Detection Difficulty |
|---|---|---|
| API1 BOLA | Other users’ accounts accessed by tampering with the userId parameter | Medium (requires per-API inspection) |
| API3 Excessive Data Exposure | Loan agent information of other users included in the response | High (requires response schema analysis) |
| API5 Broken Function Level Auth | Admin-tier internal API called with a standard user session | Medium |
7. Comparative Case: MS Exchange CVE-2026-96940
CVE-2026-96940 in Microsoft Exchange, disclosed around the same time, is essentially the same “weak authorization” flaw at its core. This vulnerability, rated CVSS 8.8, allows an authenticated user within the same organization to access other users’ mailbox resources through privilege escalation. The fact that passing authentication does not guarantee authorization puts this financial sector breach and that vulnerability in the same threat pattern category.
8. Practical Response: Server-Side Authorization Validation and Policy Frameworks
The first thing to address is the authorization middleware on the API server. Code that forcibly checks whether the subject of the logged-in session (the sub claim in the JWT) matches the owner of the requested resource (e.g., userId) must be invoked without omission in every controller. Copy-pasting a line like if (resource.owner !== req.user.id) throw 403; into individual controllers is not recommended, as it is guaranteed to be missed in one or two places.
A realistic solution is to externalize authorization decisions using Open Policy Agent (OPA) and Rego policies. When OPA filters perform policy evaluation at the API gateway (Kong) or Envoy sidecar, controller code takes responsibility only for identifying resources, while the policy layer centralizes the judgment of “whether this user is qualified to perform this action on this resource.”
At the static analysis stage, add the following custom Semgrep rules to CI to block issues at the new PR stage.
rules:
- id: missing-owner-check
languages: [javascript, typescript]
pattern: |
router.$METHOD($PATH, async (req, res) => {
...
await $MODEL.findById(req.params.id)
...
})
message: "Owner check against req.user.id required immediately after findById call"
severity: ERROR
Integrating Burp Suite’s Autorize plugin or OWASP ZAP’s Access Control testing plugin into regular regression tests allows you to automatically detect, for every new API deployment, whether “a low-privilege account can access high-privilege resources.”
9. Expert Diagnosis
Regarding this incident, Yoon Woo-hee, CEO of S-Care, pointed out that “the calls looked like those of a normal user in small volumes, so they passed nearly all of the existing SIEM rules. The organizational culture of treating authentication and authorization as the same concept is the root problem.” Park Se-jun, CEO of TIORI, likewise diagnosed that “the practice of labeling something as an internal API and skipping permission checks is the biggest entry point.”
10. Why Tampering Attempts Have Become the Default Arsenal
The attack surface in this incident was not a targeted APT but “well-crafted automated credential stuffing plus a single line of parameter tampering.” The fact that even attackers with limited funding can reach this level with a single LLM agent has fundamentally changed the threat landscape. Tampering attempts are no longer an exceptional bypass technique — they have become the default weapon that AI agents try first.
What to Do Right Now
- Within one week, run a full scan with a custom Semgrep rule to identify any points in your controller inventory where the
req.user.idcomparison is missing immediately after afindById(req.params.xxx)call. - Externalize authorization decisions to a policy layer using OPA + Envoy or Kong + OPA plugin, and run a pilot on the top-traffic service within one quarter.
- Integrate Burp Suite’s Autorize plugin into your CI/CD pipeline to automate authorization regression testing of all new APIs using low-privilege account sessions.
- Enable JSON schema validation at the API gateway and enforce data type, length, and enumeration range on resource identifier fields such as
userIdandaccountNoto block tampering attempts at the input layer. - Configure alerts using Splunk UBA or Microsoft Sentinel UEBA rules to detect anomalous patterns in which the same session queries multiple userIds.
Frequently Asked Questions
Isn’t a full inspection impossible because there are too many legacy systems?
In practice, yes. Instead, a strategy of prioritizing coverage of new code and the top 20% of APIs by traffic with the Semgrep + OPA combination, while reducing the attack surface of the remaining segments through schema validation and rate limiting at the API gateway, is cost-effective.
Is there really a path for external access to internal business systems?
If a valid user session passes through the VPN, it can call internal network APIs as-is. MFA alone is insufficient, and additional context-based authorization that combines device trust, IP reputation, and session context for the user’s endpoint is required.
How do you persuade an organization to adopt a centralized authorization framework?
In many cases, the productivity incentive — “each service team no longer has to rewrite authorization logic from scratch every time” — works better than the defensive incentive of “one breach will affect all services simultaneously.” The realistic approach is to run a pilot with one service, then bring developer team satisfaction metrics into the budget review process.
Source
This article was written after verifying the following original source: Boannews — [When Banks Get Breached – Diagnosis ⓛ] What is the ‘Parameter Tampering’ Hidden in Systems, and Why the Weak Link ‘Internal Business Systems’ Was Targeted
Leave a Reply