# Data leaks in internal systems: where they start

> Data leaks in internal systems: the common paths data takes out without passing through the screens, and a simple test your team can run for each.

Author: José Carlos Maciel, Founder and developer. Published 2026-11-20, updated 2026-11-20.
Source: https://boosting.tech/en/blog/data-leaks-in-internal-systems/

**Quick answer:** In internal systems, leaks usually start on paths nobody checks: a report link that opens without login, an API that answers without authentication, a role with overly broad permissions, a backup in open storage, or an integration with more access than it needed. Each path has a simple test the team can run in a few minutes.

The IT manager at an industrial services company reads that a competitor in the same sector had employee and customer data exposed. From what was made public, there was no sophisticated attack. A report in the competitor's internal system could be opened through a link that never asked for a password, and that link had been forwarded by email for months. The next morning, a simple question lands on the manager's desk: does our system have a door like that?

This article shows how data usually gets out of an internal system in practice and gives you a list of tests your team can use to check each path. The focus is on how the leak actually happens. What shows up on screens, in reports and in logs, from the point of view of Brazil's General Data Protection Law (LGPD), is covered in the article on [LGPD in internal systems](/en/blog/lgpd-in-internal-systems-what-to-review/). Here the subject is data that leaves the system without passing through those screens.

## What is a data leak in an internal system?

A data leak in an internal system happens when information stored by the system becomes available to someone who should not have access to it. That someone could be a person outside the company, a vendor, an employee from another business unit or a bot crawling the internet. There isn't always a break-in. Often the data was simply reachable and someone found it.

OWASP, a nonprofit foundation that publishes open software security references, keeps broken access control in first place on its [2025 Top 10](https://owasp.org/Top10/2025/A01_2025-Broken_Access_Control/). According to the document, 100% of the applications tested in the project's dataset had some form of this flaw. The category covers exactly the paths in this article: a page that opens without login, a user who sees someone else's record by changing a number in the address, an API with no access control, and backup files left inside the server's public folder.

Internal systems carry more risk for a simple reason. The system was built to be used inside the company, by people everyone knows, and many decisions were made on that assumption. Over time it gained internet access, a mobile app, an ERP integration and a link so a vendor could check orders. The assumption changed, and the old decisions stayed in place.

## Why does a leak go unnoticed for months?

A leak goes unnoticed because, on most paths, unauthorized access looks like normal access. Someone who opens a link without logging in or calls an open API triggers no alarm. The system hands over the information as it would to any user, and the event log, when there is one, shows an ordinary request.

Three factors usually add up:

1. The system was built in layers, by different people, over several years. Whoever created the report share link has left the company, and nobody knows the link exists.
2. The tests the team runs are functional tests. They check that the report opens for the people who need it, and almost never check that it stays closed to the people who don't.
3. Part of the path sits outside the system: the backup in cloud storage, the database copy in the test environment, the credential the BI vendor received three years ago.

Verizon's annual incident report, the [2026 DBIR](https://www.verizon.com/about/news/breach-industry-wide-dbir-finds), backs up the third point. In this year's edition, breaches involving a third party reached 48% of the total, a 60% increase over the previous edition. The same report lists employees' use of unapproved AI tools as the third most common activity among non-malicious leaks. The data leaves through the integration or through a copy someone made, while the system's front door stays locked.

Hospitals, ports and manufacturers keep personal and operational data in internal systems: staff schedules, contractor documents, patient or service history, shipping schedules. When these systems grow without review, the exposure can last for months until someone from outside reports it.

## How does data get out without passing through the screens?

Data gets out through five main paths, and all of them have one thing in common: they skip the login screen the team thinks of as the system's protection. The table sums up each one.

| Path | How it happens | Sign that it may exist |
| --- | --- | --- |
| Link without login | A report, attachment or detail screen opens straight from its address, with no authentication | The system has a "share by link" button or emails reports with a link |
| Open API | The mobile app or web screen pulls data from an API that answers any request | There is a mobile app, integration or dashboard that consumes data from the system |
| Overly broad permission | A logged-in user sees data from another unit or another customer by changing a number in the address | The system's addresses show sequential numbers, such as /order/1532 |
| Exposed file | A backup, export or attachment sits in unrestricted storage, or in a test environment with real data | Nobody can say where the backup is or whether staging uses a copy of production |
| Third-party integration | A vendor or external system received a credential with access to everything, beyond what it needed | There are old integrations, from contracts that have ended or that nobody reviews |

Overly broad permissions deserve special attention because they fool even the people who test. The user logged in, so the login screen worked. The problem is one step later: the system checks that the person is logged in, but it doesn't check that the specific record belongs to them. OWASP ranks this flaw first on its [API Security Top 10](https://owasp.org/API-Security/editions/2023/en/0xa1-broken-object-level-authorization/) and describes the mechanism like this: the attacker changes the object identifier in the request and the server returns another user's data. According to the document, the flaw is extremely common and easy to detect.

Open APIs tend to appear when the system gets a mobile app. The web version enforces permission rules on the screen, and the app came later, using an API someone published in a hurry. If the rule for who sees what lives only on the screen, anyone who calls the API directly skips the rule.

## How do you test each path in your system?

The list below gives, for each path, tests your technical team can run without special tools. Some can be done by the manager, with a regular user account and a private browser window.

### Data leak paths in internal systems and the test for each one

Run the tests with a regular user account and, where noted, from a computer outside the company network. Record the result of each item as "closed", "open" or "we don't know". Any open or unanswered item becomes a task with an owner and a deadline. The tests exist to find the flaw: stop as soon as you confirm the data shows up, and do not go further.


**Links and pages that skip the login**

- [ ] Copy the address of a report, a detail screen and an attachment, and open each one in a private browser window. You should land on the login screen
- [ ] Look for share links generated by the system ("send by link", "share report") and check whether they expire and whether they require login
- [ ] Search for the system's domain in a search engine using the site: operator and see whether any internal page shows up in the results

**APIs that answer without authentication**

- [ ] Ask the team for the list of API endpoints the system uses and call each one without the access token. You should get an access denied response
- [ ] Check whether the mobile app's API applies the same permission rules as the web version
- [ ] Check whether auto-generated API documentation is published on the internet, with endpoints and examples in plain view

**Overly broad permissions**

- [ ] Log in as a regular user, open a record and change the record number in the address bar. You should see only what belongs to that user or that business unit
- [ ] Export a spreadsheet with a restricted role and compare it with the same export run by an administrator
- [ ] List the users with administrator roles and confirm with each department manager that all of them still need that access

**Files, backups and copies in open locations**

- [ ] Ask where the database backups are stored and check that the location requires credentials and sits outside the main server
- [ ] Open the direct link to an attachment uploaded to the system without being logged in. You should get access denied or a link that expires
- [ ] Check whether any test or staging environment uses a copy of real data and whether it can be reached from the internet
- [ ] Check whether shared project folders hold old exports with personal or customer data

**Third-party integrations**

- [ ] List every external system that receives or queries data from yours (ERP, payroll, carrier, BI tool) and what each one can access
- [ ] Check that each integration uses its own credential, with access only to what it needs, and that you can revoke it without breaking the others
- [ ] Check whether vendors with ended contracts still have a user account, API key or VPN access

To adapt the list, start with the path that best fits the system's history. If it got a mobile app in recent years, start with the APIs. If it shares data with many vendors, start with the integrations. If nobody has ever been able to say where the backup is, start there.

If any item comes back "open", treat it as a priority and fix it before moving on. A link without login that exposes personal data calls for action the same day: disable the link or the feature first, and only then look into how long it was reachable.

## How do you organize the tests with your team?

The tests fit into one afternoon if you prepare ahead. A plan that works:

1. Set up two test users in the production environment, one with a regular role and another with a role from a different unit or customer. The technical team creates both and removes them at the end.
2. Ask the team in advance for three lists: the API endpoints, the active integrations with each one's credential, and the locations of backups and exports.
3. Go through the test list in a meeting, with the technical lead running the tests and the manager taking notes. Each item gets "closed", "open" or "we don't know".
4. For each open or unanswered item, assign an owner and a deadline. Items that expose personal data go to the top.
5. Keep the record with the date and result. You will use it to repeat the tests after the fixes and to show what was checked if anyone asks.

The record in step 5 is usually what's missing when an incident happens. Without it, nobody can say whether the path was open from the start or was opened by a recent change.

In the systems we build, the rule for who sees what lives on the server as well as on the screen, precisely to close off overly broad permissions and open APIs. In the [access control system for an industrial complex](/en/case-studies/industrial-access-control/), for example, each company operating on site sees only its own records, and the history keeps track of who approved or denied each access request.

## What if the system belongs to a vendor or is integrated with third parties?

If the system belongs to a vendor, the list becomes a set of questions for them. Ask them to show you, in a meeting, the link without login test, the record number test and where the backup is stored. A serious vendor can do this. If the answer is vague or takes weeks, record it as a risk to address when the contract comes up for renewal.

For integrations, the key point is the scope of the credential. Each external system should have its own credential, with access only to what it needs, that can be revoked without affecting the others. When every integration uses the same administrator account, a leak at the BI vendor exposes the whole database, and changing the password breaks every integration at once. That's why the change usually gets postponed, and the old credential keeps working.

People are a path too. An employee who exports a spreadsheet to paste into an outside AI tool takes data out of the system without any technical test noticing. The answer involves limiting who can export what and agreeing with each department on which tools are approved. If the system itself was put together with an AI tool by someone in the business, the guide to [reviewing AI-built systems](/en/blog/ai-built-systems-what-to-review/) covers the specific risks in that case.

## When is this list not enough?

The list finds the most common paths, but it has limits. It doesn't replace a penetration test by a specialist, it doesn't review the code line by line, and it doesn't look for flaws in outdated libraries. It also doesn't cover how to respond to an incident that has already been confirmed.

If a test shows that personal data was exposed, bring in the company's Data Protection Officer and legal team before making any other decision. The LGPD requires certain incidents to be reported to the ANPD, Brazil's national data protection authority, and the authority keeps a [page with guidance](https://www.gov.br/anpd/pt-br/canais_atendimento/agente-de-tratamento/comunicado-de-incidente-de-seguranca-cis) on what to report and by when. Companies outside Brazil should check the equivalent rules in their own jurisdiction. That assessment belongs to the person responsible at the company, with legal support.

Older systems often have several paths open at the same time, and sometimes the fix requires changing how the system handles permissions. In those cases, [modernizing in stages](/en/blog/legacy-system-modernization/) tends to cost less than patching each spot. For a new system, the [security checklist before production](/en/blog/security-checklist-before-production/) keeps these paths from being opened in the first place.

boosting.tech, a custom software company, offers a fixed-scope security assessment for internal systems. It looks for these paths in your system and delivers a list of what to close first. The first conversation is free and can be scheduled through the [contact](/en/contact/) page. For ongoing fixes after that, see the [support and modernization](/en/services/support-and-modernization/) service.

## Frequently asked questions about data leaks in internal systems

### How can you tell if your company's system has already had a leak?

You can't always know for sure. The first step is to check whether the paths on the list are open today. If one is, look at the server and API access logs to see how long there have been requests from outside or with no identified user. When there are no logs, the company can neither prove nor rule out a leak, and that alone shows what needs to be fixed.

### Can a system that only runs on the internal network leak data?

Yes. Staying on the internal network reduces exposure to outsiders, but it doesn't solve overly broad permissions, integrations with too much access or backups in open locations. An employee in one unit may see another unit's data, and a vendor with VPN access can reach the system. On top of that, many systems that started out internal later gained a mobile app or outside access that nobody documented.

### Who should run the tests on the list?

Ideally, the technical lead runs the tests while the department manager follows along and takes notes. The technical lead knows the API endpoints and where the backups are. The manager knows which data is sensitive and who should see what. Tests like opening a link in a private window or changing the number in the address can be done by the manager. For vendor systems, ask the vendor to run the tests in front of you.

### Does changing the password fix things after you find an open path?

It depends on the path. If the problem is a link without login or an API without authentication, changing the password does nothing, because those paths don't use a password. The system itself has to be fixed. If the problem is an integration credential with too much access, or one that leaked, then you do need to revoke it and create a new one with a narrower scope. Either way, record what you found and when it was fixed.

### How often should you repeat the tests?

Repeat them whenever the system gets a sharing feature, an app, a new integration or a new environment, because those are the changes that open these paths. Beyond that, a review every six months is usually enough for stable internal systems. The review of integrations and administrator accounts can go on the same calendar as the access review you already do with HR.

## References

- [OWASP Top 10:2025, A01 Broken Access Control](https://owasp.org/Top10/2025/A01_2025-Broken_Access_Control/)
- [OWASP API Security Top 10:2023, API1 Broken Object Level Authorization](https://owasp.org/API-Security/editions/2023/en/0xa1-broken-object-level-authorization/)
- [Verizon: 2026 Data Breach Investigations Report, key findings (2026)](https://www.verizon.com/about/news/breach-industry-wide-dbir-finds)
- [ANPD: Security incident reporting](https://www.gov.br/anpd/pt-br/canais_atendimento/agente-de-tratamento/comunicado-de-incidente-de-seguranca-cis)
