Contents
Mobile app security based on OWASP Mobile means systematically avoiding the best-known weaknesses of mobile applications – from insecurely stored data to broken authentication. With the Mobile Top 10 and the MASVS verification standard, the OWASP project provides a freely available, field-tested framework. This article translates the risks into concrete measures for your app project.
What OWASP Mobile is and why it matters
The Open Worldwide Application Security Project (OWASP) is a non-profit community that publishes standards and tools for application security. Three resources are relevant for mobile apps:
- OWASP Mobile Top 10: a list of the ten most important risk categories for mobile apps, last updated in 2024.
- MASVS (Mobile Application Security Verification Standard): a catalogue of verifiable security requirements, grouped into areas such as storage, cryptography, authentication and network.
- MASTG (Mobile Application Security Testing Guide): guidance on how to test these requirements.
For clients this is practical: you can reference a recognised standard in your specification and acceptance criteria instead of describing security vaguely. Regulatory expectations for software are also rising – see NIS2 and the Cyber Resilience Act.
The OWASP Mobile Top 10 and matching safeguards
| Risk | Typical example | Safeguard |
|---|---|---|
| M1 Improper credential usage | API key hard-coded in the app | No secrets in the client, access via your own backend, short-lived tokens |
| M2 Inadequate supply chain security | Outdated SDK with a known vulnerability | Inventory dependencies, scan them automatically, use trusted sources only |
| M3 Insecure authentication/authorisation | Server doesn't check whether a user may access someone else's data | Check permissions server-side on every request, use established standards such as OAuth 2.0 with PKCE |
| M4 Insufficient input/output validation | Manipulated deep links or inputs lead to injection | Validate all input on client and server, use parameterised queries |
| M5 Insecure communication | Unencrypted connections or ignored certificate errors | TLS everywhere, no exceptions for certificate validation, certificate pinning where appropriate |
| M6 Inadequate privacy controls | Personal data in logs or analytics | Data minimisation, pseudonymisation, sanitised logs |
| M7 Insufficient binary protections | App is decompiled and tampered with | Obfuscation, integrity checks, move critical logic to the server |
| M8 Security misconfiguration | Debug mode or exposed components in the release build | Review release configuration, minimise exported components |
| M9 Insecure data storage | Tokens stored in plain text locally | Keychain or Android Keystore, encryption of sensitive data |
| M10 Insufficient cryptography | Home-grown or outdated encryption | Use proven platform libraries and current algorithms |
The backend is half of app security
A common misconception is that security measures belong mainly in the app. But every app can be analysed, manipulated or replaced by a script that talks directly to your API. It follows that:
- The server never trusts the client. Prices, discounts, permissions and limits are validated server-side.
- Object-level access checks: a request to
/orders/1234must verify that the order belongs to the signed-in user. Missing checks are among the most frequent causes of data leaks. - Rate limiting and abuse detection protect login, registration and expensive endpoints.
- Secure token handling: short-lived access tokens, rotating refresh tokens and the ability to revoke sessions.
How to design robust interfaces from the outset is covered in API design for mobile apps.
Building security into the development process
Security cannot be "tested in" at the end. It has to be part of every phase:
- Requirements: determine how sensitive the data is and select matching MASVS requirements. A banking app needs different measures from an event app.
- Threat modelling: for critical flows such as login, payment or data export, walk through how an attacker would proceed.
- Development: secure defaults, security-focused code reviews, no secrets in the repository.
- Automated checks: static code analysis and dependency scanning in the CI pipeline.
- Pre-release testing: depending on risk, an internal security test or an external penetration test – see penetration testing for apps.
- Operations: monitoring of suspicious access, quick updates for known vulnerabilities, an incident response process.
AI-assisted development speeds up the work but does not automatically produce secure code. Generated code goes through the same reviews and checks as hand-written code.
Checklist for clients
Ask your development partner these questions:
- Which standard (e.g. MASVS) is the app developed and verified against?
- Where and how are tokens and sensitive data stored on the device?
- Are permissions checked server-side on every API call?
- How are dependencies monitored for vulnerabilities and updated?
- Is there a penetration test before launch, and who fixes the findings?
- How quickly are security updates shipped after launch?
- How is personal data handled in logs and analytics?
Privacy and security are closely linked. Our GDPR checklist for apps is a useful companion.
Agentic coding workshop for your team? From €799 net – request a quote by e-mailConclusion
OWASP Mobile offers a clear, freely available framework for app security. The most effective measures are often unspectacular: no secrets in the client, consistent permission checks on the server, secure storage via Keychain and Keystore, TLS without exceptions and well-maintained dependencies. Planning security from requirements through to operations saves expensive rework. For a securely planned app, our offer wizard leads to a fixed-price quote after a free analysis.
Frequently Asked Questions
What is the difference between the OWASP Mobile Top 10 and MASVS?
The Top 10 name the most important risk categories, while MASVS describes concrete, verifiable security requirements. MASVS is better suited for specifications and acceptance testing.
Do I need certificate pinning?
It can make sense for apps with high protection needs, such as finance or health applications. It requires a clean process for certificate rotation, otherwise outages can occur.
Are cross-platform apps less secure than native apps?
Not inherently. What matters is the implementation and the use of secure platform features such as Keychain and Keystore, which Flutter and React Native can also access.
How often should an app be security-tested?
Automated checks should run with every build, with a deeper test before launch and after major changes. Apps with high protection needs benefit from regular external testing.