Mobile app security testing in the UAE: what an OWASP MASVS test covers, how to read the report, and when to test
By Dr. Hani Elimam Manager & CEO, SmartTech Studio
The weaknesses that sink mobile apps are rarely exotic. A login token saved in plain text on the phone. An API that returns another customer’s booking when one number in the request changes. A release build that still writes personal data to the device log. None of these shows up in a demo, and all of them are on the checklist of a proper security test.
This guide is for founders, product owners and IT managers in the UAE who are about to launch an iOS or Android app, or who have been asked by a bank, a hospital group or an enterprise customer to prove that their app has been tested. It uses the OWASP Mobile Application Security project as the yardstick, because it is open, free and widely used by testers.
Where we stand: SmartTech Studio designs and builds apps and their backends from Abu Dhabi. We are not an independent testing lab and hold no testing certification. We write from the builder’s side: this is the checklist we work to and the one we suggest you hand to your tester. The business side, breach response and governance, is covered in our guide to preventing data breaches in the UAE; this article stays with the app.
What a mobile app security test actually covers
To an attacker, an app is three things: the code installed on the phone, the traffic between the phone and your servers, and the API and backend that answer it. A test that looks only at the first is a review of the least valuable part. A useful test covers all three, with the app as the way in.
The OWASP Mobile Application Security (MAS) project splits the work into three documents. The Mobile Application Security Verification Standard (MASVS) says what a secure app must do. The Mobile App Security Weakness Enumeration (MASWE) lists the specific weaknesses that break those requirements. The Mobile Application Security Testing Guide (MASTG) describes how to test for them on Android and iOS, with techniques, tools and test cases. When a tester says they test “against MASVS”, the MASTG is how they do it.
The current version, MASVS 2.1.0, was released in January 2024. It is shorter than the version 1 checklist many people remember: eight control groups, each with a handful of high-level controls, and no L1 or L2 levels inside the standard itself. The levels moved into separate testing profiles, which we come to below.
The eight MASVS control groups, and what a tester checks in each
MASVS states each control in one sentence: “The app securely stores sensitive data.” “The app performs identity pinning for all remote endpoints under the developer’s control.” The sentences are short on purpose; the detail lives in the MASWE weaknesses and MASTG tests underneath. The table turns each group into what a tester actually opens, runs and tries.
| Group | What MASVS asks | What the tester checks |
|---|---|---|
| MASVS-STORAGE | Store sensitive data securely and prevent it leaking | Keychain and Keystore use, files and databases on the device, logs, backups, the app-switcher snapshot, keyboard cache and clipboard |
| MASVS-CRYPTO | Current strong cryptography and sound key management | No home-made or outdated algorithms, no keys written into the app file, keys held by the Keychain or Keystore |
| MASVS-AUTH | Secure authentication and authorisation, safe local authentication, extra checks for sensitive operations | Tokens, session expiry and logout on the server, biometric unlock tied to a key, a second check before payments or bank-detail changes |
| MASVS-NETWORK | Secure all traffic, and pin the identity of endpoints the developer controls | HTTPS everywhere, TLS settings, certificate validation, pinning and how easily it is bypassed |
| MASVS-PLATFORM | Use inter-process communication, WebViews and the user interface securely | Exported components, deep links, intents and URL schemes, JavaScript bridges in WebViews, sensitive data on screen |
| MASVS-CODE | An up-to-date platform version, enforced updates, no components with known vulnerabilities, validated inputs | Minimum OS version, the forced-update path, third-party SDK versions, injection through inputs and deep links |
| MASVS-RESILIENCE | Check platform integrity and resist tampering, static analysis and dynamic analysis | Root and jailbreak detection, repackaging, obfuscation, debugger and hooking detection, and how long each takes to bypass |
| MASVS-PRIVACY | Minimise access to data, prevent identification, be transparent, give users control | Permissions requested versus used, SDKs collecting identifiers, store privacy labels against real traffic, in-app data deletion |
The privacy group is the newest, added in 2.1.0. It matters in practice because the privacy labels you declare to Apple and Google are a promise, and a tester watching the traffic can see whether an analytics SDK sends more than you declared. Our guide to publishing on the App Store and Google Play covers those declarations.
How deep to test: the four MAS profiles
Not every app needs the same test. A restaurant menu app and a wallet do not face the same attacker. OWASP handles this with testing profiles. Its advice is to start from a threat model, and to fall back on the default profiles when a custom one is not feasible.
Each default profile is defined by who the attacker is. MAS-L1 (Essential Security) assumes other apps on the device are the adversary. MAS-L2 (Advanced Security) assumes the operating system cannot be trusted and the attacker may have the phone in hand. MAS-R (Resilient Security) assumes the user is the attacker: reverse engineers and cheaters. MAS-P (Baseline Privacy) is not about an attacker at all; it covers how the app handles personal data.
OWASP’s own examples are a good guide. A news or calendar app holding only a name and email fits L1 plus P. An app handling location, payments, health data or access tokens, or offering money transfers or medical record uploads, moves to L2 plus P. R is added when the app carries business logic worth protecting from tampering, as in banking, insurance and games.
Applied to our own work: Taxi Masr, a ride-hailing app we built, shares live trips and takes wallet, InstaPay and card payments, so it carries location and payment data, which by those examples puts it in L2 territory. A loyalty app whose points turn into money is a candidate for R, because the user has a reason to cheat. Settle the profile before you ask for quotes, because it decides most of the scope.
Network traffic, TLS and certificate pinning
Both platforms now push apps towards encrypted traffic by default. Apple’s App Transport Security requires the app’s connections to use TLS 1.2 or later with a trusted certificate, and Apple says exceptions reduce security and some must be justified when the app is submitted to the App Store. On Android, cleartext traffic has been disabled by default since Android 9 (API level 28). A tester still checks the edges: an ATS exception left over from development, a third-party SDK calling a plain HTTP address, or custom code that accepts any certificate to get past a staging server.
Certificate pinning is the control people ask about most. It means the app accepts only specific certificates or public keys for your servers, instead of any certificate signed by a trusted authority, so an attacker holding a rogue certificate cannot read the traffic. MASVS asks for identity pinning on endpoints under the developer’s control, and that qualifier matters. Pinning your own API is sensible. Pinning a payment gateway’s or a map provider’s domain is how apps break overnight when that provider renews its certificate.
Android’s documentation gives the practical rules. Pin the public key rather than the whole certificate. Always include a backup key, so you can rotate without shipping an emergency update. Understand the trade-off of a pin expiry date: it keeps old versions of the app working after a key change, but it may also let an attacker bypass the pins once they expire. Agree the rotation plan with whoever runs your servers before you ship.
Expect the tester to bypass your pinning on a rooted or jailbroken phone. That is normal and is not a finding in itself. Pinning raises the cost of watching traffic; it does not make the API secret. Anything the API trusts the app to do, the server must check as well.
On the phone: storage, keys and login
The device is where the most common findings sit, and they are usually simple. Tokens or personal data kept in plain files or an unencrypted local database. Personal data written to the system log. Sensitive screens captured in the app-switcher snapshot. Files swept into device backups. The fix is nearly always the same: keep secrets in the iOS Keychain or the Android Keystore, store as little as possible on the phone, and keep what remains out of backups and logs.
Secrets written into the code are the cryptography finding we would bet on. An API key, a payment provider’s secret key or an encryption key built into the app can be pulled out of the file with free, widely available tools; obfuscation slows that down but does not stop it. A secret that must stay secret belongs on the server. Keys that must live on the device should be generated there and held by the Keychain or Keystore, not shipped inside the app.
Login deserves its own attention. The server, not the app, decides when a session ends: logging out should invalidate the token on the server, and a stolen token should expire. Biometric unlock is often built as a yes-or-no check, which a tester can flip with a hooking tool; done properly, a successful fingerprint or Face ID unlocks a key in the Keychain or Keystore. MASVS also asks for extra authentication before sensitive operations, such as adding a payee.
If your app signs people in with UAE PASS, the same rules apply to the tokens it returns; our guide to UAE PASS integration for apps and websites covers the flow itself.
The half most app tests skip: your API
Every mobile app is a client for an API, and that API is open to anyone who installs the app and points an intercepting proxy at it. That is why a test of the app alone gives false comfort. OWASP publishes a separate list for this, the API Security Top 10, and the 2023 edition is the current one.
The 2023 list, in order: broken object level authorization (API1), broken authentication (API2), broken object property level authorization (API3), unrestricted resource consumption (API4), broken function level authorization (API5), unrestricted access to sensitive business flows (API6), server side request forgery (API7), security misconfiguration (API8), improper inventory management (API9) and unsafe consumption of APIs (API10).
The first item tops the list for a reason. Broken object level authorization means the API checks that you are logged in but not that the record you asked for is yours: change booking 1041 to 1042 in the request and you see a stranger’s booking. Testing through the screens never finds it. When we built Ehgizli, a clinic SaaS where several clinics share the same infrastructure, we enforced the boundary between clinics at the database layer, so one clinic cannot reach another clinic’s patients even if a single endpoint forgets a check. A tester should still try, with two accounts in two clinics, on every endpoint.
Two more items are easy to miss in a mobile project. Unrestricted resource consumption covers the one-time-password endpoint with no rate limit, which lets an attacker send thousands of paid SMS messages at your cost. Improper inventory management covers the old version of the API, still running for the app version from two years ago, without the fixes made since. Ask the tester to work from your API documentation and from live traffic, so endpoints the current app no longer calls are covered too.
Static, dynamic and manual testing, and what the tester needs from you
Static testing reads the app without running it: the source code if you share it, otherwise the compiled app, decompiled. It finds secrets in the code, insecure settings in the Android manifest or the iOS Info.plist, weak cryptography calls, debug flags and vulnerable library versions. It is fast and good at breadth, and it also reports issues that may not be reachable in practice.
Dynamic testing runs the app on a real device, usually rooted or jailbroken, with traffic going through an intercepting proxy and instrumentation tools hooked into the app. It shows what actually happens: what is written to disk after login, what leaves the phone, whether the server accepts a modified request. On Android, apps targeting Android 7.0 or later do not trust user-installed certificates by default, which is why a tester needs a debug build configured to allow it, or a rooted device, to see the traffic.
Manual work is what neither tool does: abusing the business logic. Paying for one item and receiving two. Redeeming a voucher twice from two phones at the same moment. Booking a slot that should be closed. Scanners do not know what your app is supposed to forbid. A good test mixes all three, and a quote that is entirely automated should be priced and described as a scan.
To get value from the days you pay for, give the tester release-candidate builds for both platforms, two test accounts for every role so they can test access between users, your API documentation, a staging environment with realistic but not real data, and a developer who answers questions the same day. Do not test against production with real customer data unless you have agreed it in writing.
When to test, and what to ask before you hire a tester
Test before the first public release, early enough to fix what is found; a test the week before launch tends to end in an argument about which findings can wait. Test again after any release that changes sign-in, payments, the personal data you collect or the SDKs you ship. Between tests, keep an automated dependency check in the build pipeline, because MASVS-CODE asks that the app use only components without known vulnerabilities, and new ones are published all the time. A security incident in the first month is a quick way to lose users’ trust; our article on why mobile apps fail in the UAE covers the other reasons.
Before you sign, ask: which MAS profile will you test against, and why? Is the API in scope? How much of the work is manual? Will you test iOS and Android on real devices? Who does the work, and can we see a sample report? Is a retest included? How will our builds and data be deleted afterwards? A tester who cannot answer the first question in terms of your app has not looked at it yet.
Budget for the test separately from the build, and agree with your developer before the project starts who fixes the findings and at whose cost. Our article on what a mobile app costs in the UAE covers the rest of the budget.
Reading the report and fixing by severity
A useful report gives, for each finding, a title, the MASVS control or API Top 10 item it maps to, a severity, the evidence (requests, screenshots, code locations), the steps to reproduce it and a recommended fix. Many testers rate severity with CVSS or their own matrix of impact and likelihood. The executive summary is for the board; the developer needs the reproduction steps.
Fix in this order. Critical and high findings block the release: access to other users’ data, an authentication bypass, secrets that open your backend or payment account, personal data sent unencrypted. Medium findings, such as tokens that never expire, go into the next sprint with a date. Low and informational findings go into the backlog or are accepted in writing with a reason.
Read each severity against your app, not the tester’s template. Missing jailbreak detection is a high finding in a banking app tested at L2 plus R and close to irrelevant in a restaurant app tested at L1. If you disagree with a rating, say why and ask the tester to record the agreed severity, rather than leave a disputed “critical” in a report your customer may ask to see.
Then retest. A fix nobody has verified is a hope. Ask for a short retest report that marks each finding as fixed, partly fixed or open, and keep the two documents together. That pair is what a bank, an insurer or an enterprise customer will ask for when they review your app.
UAE rules, and where we fit
In the UAE the starting point is the Personal Data Protection Law, Federal Decree-Law No. 45 of 2021, in force since 2 January 2022. The government portal u.ae summarises it as setting the general obligations of companies holding personal data to secure it and keep it confidential, and says it applies to processing by electronic systems inside or outside the country. The UAE Data Office, set up by Federal Decree-Law No. 44 of 2021, is the federal data regulator. Free zones with their own data protection law, such as DIFC, follow that law instead. The federal law does not prescribe a mobile penetration test, but a test report and a retest are the most direct evidence that the app protects the data it collects.
Sectors add their own rules. Health apps fall under Federal Law No. 2 of 2019 on the use of information and communication technology in health fields, which applies across the UAE including the free zones. Payment, wallet and banking apps licensed by the Central Bank of the UAE follow its rules for the activity, and a bank partner may add requirements in the contract; our guide to fintech app development in the UAE covers scoping those controls. In both sectors, ask your compliance adviser what the regulator or partner expects before you scope the test, not after.
Where we fit: we build iOS and Android apps from one Flutter codebase, with the backend and admin dashboard, and our baseline includes role-based access, an audit log, encryption, automated backups and a separate staging environment. We do not certify our own work; we give the tester you choose builds, accounts and documentation, and fix findings in the code we wrote. Our guide to mobile app development in Dubai explains how a project runs. Our app development service starts from AED 10,000 for a cross-platform app and from AED 20,000 for a full product with an admin dashboard and API, excluding VAT. The tester prices the security test on its scope; we do not publish a figure for it.
If you have an app about to go live, or a report you are not sure how to read, send it to us with the platform and your deadline. We will tell you plainly which findings matter and what fixing them involves.
Sources
- OWASP Mobile Application Security: the MASVS (Mobile Application Security Verification Standard) and its control groups
- OWASP Mobile Application Security: MAS Testing Profiles (L1, L2, R and P)
- OWASP API Security Top 10, 2023 edition
- Apple Developer: Preventing insecure network connections (App Transport Security)
- Android Developers: Network security configuration (cleartext defaults and certificate pinning)
- u.ae: Data protection laws (Federal Decree-Law No. 45 of 2021, the Personal Data Protection Law)
FAQ
What is the difference between a vulnerability scan and a penetration test for a mobile app?
A scan runs automated tools over the app file and reports likely issues quickly, including false positives. A penetration test adds a tester working by hand against the app and its API, trying to reach other users’ data, get past the login or abuse the business logic. Most apps going live need the second, scoped to an OWASP MAS profile.
Does our app need certificate pinning?
Not every app. MASVS asks for pinning on endpoints under your own control, and it makes sense for apps handling payments, health data or access tokens. Pin public keys, include a backup key and plan rotation with your server team. Do not pin third-party domains you do not control, or the app can break when they renew a certificate.
Does UAE law require a security test for mobile apps?
The federal Personal Data Protection Law requires companies to secure the personal data they hold, but it does not name a mobile penetration test. Sector regulators, bank partners and enterprise customers may require one. A test report together with a retest is the clearest evidence you can give that the app protects its users’ data.
Can the developer who built the app also test it?
Developers should test their own code, and automated checks belong in every build. An independent test is different: a tester who did not write the code looks for what the team assumed. For a first release that handles personal or payment data, use a separate tester and have the developer fix the findings.