A React Native security review is most effective when it is a repeatable release activity rather than a one-time penetration test. This checklist helps development teams track dependencies, secrets, authentication data, storage, WebViews, network behavior, logs, source maps, and release artifacts across Expo and native workflows.
Overview
React Native apps share business logic across platforms, but their security exposure spans several layers: JavaScript packages, native dependencies, application configuration, backend APIs, operating-system storage, build pipelines, and the final Android or iOS artifact. A secure development process therefore needs more than a package-manager vulnerability scan.
Use this guide as a recurring React Native app security audit. Record findings in your normal issue tracker, assign an owner, define a severity and deadline, and preserve the evidence needed to verify remediation. The exact commands and scanner coverage can change as React Native, Expo, package managers, mobile operating systems, and third-party services evolve, so check each tool's current documentation before relying on a result.
The objective is not to make a blanket claim that an app is secure. It is to reduce avoidable exposure, identify unknowns, and make release decisions traceable.
What to track
1. Dependencies and native modules
Maintain an inventory of direct and transitive JavaScript packages, Expo modules, CocoaPods, Gradle dependencies, and custom native code. For each dependency, record its version, purpose, maintainer or source, license review status, last review date, and whether it handles sensitive data or native permissions.
Run the audit command appropriate to the lockfile and package manager, then review the result rather than treating every advisory as an automatic blocker. Typical starting points include:
npm audit
pnpm audit
yarn npm auditWhere appropriate, supplement package-manager reports with an external software composition analysis tool, an advisory database, or an organization-approved scanner. Tools such as Dependabot, Snyk, OSV-Scanner, or equivalent services may fit different workflows; compare their lockfile support, native dependency coverage, private-package handling, reachability analysis, and remediation guidance before selecting one.
For every finding, capture the affected package, vulnerable range, reachable code path, available upgrade or patch, compatibility risk, and decision. A package that appears in a lockfile may not be used by the shipped feature, but that assumption should be documented and tested rather than guessed.
2. Secrets, credentials, and configuration
Classify configuration before it enters the repository. A useful template is:
| Data | Classification | Allowed location | Rotation owner |
|---|---|---|---|
| Public API identifier | Public or limited-use | App configuration, with server-side restrictions where available | Platform owner |
| Access token or refresh token | Confidential | Protected device storage and backend-controlled session flow | Authentication owner |
| Signing key, private API key, database credential | Highly confidential | Secret manager or CI environment; never the app bundle | Security or release owner |
| Test fixture or mock value | Non-production | Test-only files and isolated environments | Test owner |
Search source code, Git history, build logs, pull requests, CI variables, crash reports, and generated artifacts for credentials. A value is not safe merely because it is stored in an environment file: variables bundled into a mobile application can often be inspected by someone who obtains the application.
Use secret-management features in the CI or hosting environment for signing credentials and server-side secrets. Keep production and non-production credentials separate, restrict access, and document how each credential is revoked and replaced.
3. Tokens and secure storage
Separate short-lived access tokens, refresh tokens, device identifiers, personally identifiable information, and cached application data. Define what happens when a user signs out, changes a password, loses a device, or has an account revoked.
Do not place sensitive tokens in general-purpose asynchronous storage or plain-text files. Evaluate a maintained secure-storage option that uses platform-provided protected storage, such as a supported Expo secure-storage module or a React Native keychain library. Confirm current React Native, Expo, iOS, Android, and new-architecture compatibility before adoption. Secure storage does not replace server-side expiry, revocation, least-privilege scopes, or TLS.
Test storage behavior on both platforms, including reinstall, backup and restore, biometric changes, device lock states, app backgrounding, and logout. Avoid logging token values while debugging these flows.
4. WebViews, deep links, and network behavior
Audit every WebView and document its purpose, allowed origins, navigation rules, JavaScript settings, injected scripts, file access behavior, and message bridge. Prefer a narrow allowlist over unrestricted navigation. Treat data received from a WebView as untrusted, and validate messages before they reach native code or authenticated application logic.
Review custom URL schemes, universal links, and Android App Links for account or payment actions. Ensure links do not accept arbitrary redirect targets or place credentials in URLs. For a deeper routing review, use the React Native deep linking and release testing guide.
Verify that production builds use the intended API hosts, reject unexpected environment substitutions, and do not disable certificate validation or TLS checks as a troubleshooting shortcut. Test authentication failure, timeout, replay, and offline behavior.
5. Logs, source maps, and release artifacts
Define a redaction policy for application logs, analytics events, crash reports, and network diagnostics. Review event names and payloads for tokens, email addresses, payment data, full request bodies, and authorization headers. Apply the same review to third-party analytics and crash-reporting integrations.
Source maps can improve crash diagnosis but may expose readable application structure if distributed publicly. Upload them through the approved monitoring workflow, restrict access, and verify that public artifact hosting does not expose them unintentionally. For operational context, compare your process with the React Native crash reporting and monitoring guide.
Inspect the release APK, AAB, IPA, or equivalent output—not only the source repository. Search the JavaScript bundle and native resources for URLs, test credentials, private keys, debug flags, verbose logging, internal hostnames, and unintended feature configuration. An artifact review is especially important after changing environment variables or build scripts.
6. Permissions and platform privacy behavior
List every declared and requested permission, the feature that needs it, the user-facing explanation, and the point at which it is requested. Remove unused permissions and test denial, limited access, revocation, and upgrade scenarios. Consult the React Native permissions testing guide when building a cross-platform test matrix.
7. Mobile-security scanner coverage
| Tool category | Useful for | Limitations to check |
|---|---|---|
| Package-manager audit | Known advisories in JavaScript dependency trees | May not cover application logic, runtime reachability, or all native dependencies |
| Software composition analysis | Policy enforcement, dependency inventory, and upgrade tracking | Coverage varies for private packages, lockfiles, licenses, and native components |
| Secret scanner | Credential patterns in source, history, and CI artifacts | Can miss unusual formats and produce false positives |
| Static analysis | Suspicious code patterns, injection risks, and insecure API use | Requires tuned rules and does not prove runtime safety |
| Mobile application scanner | Manifest settings, bundled secrets, permissions, and common mobile weaknesses | Results depend on artifact type, configuration, and scanner version |
| Dynamic or penetration testing | Runtime flows, authentication, authorization, and network behavior | Needs a defined scope, test accounts, and remediation ownership |
Cadence and checkpoints
Use several checkpoints instead of waiting for a quarterly review.
- Every pull request: run linting, tests, secret detection, and the fastest dependency checks. Block newly introduced high-confidence secrets.
- On every dependency change: review the package source, release history, permissions, native code, maintenance signals, transitive dependencies, and license implications. Build both platforms and run security-relevant tests.
- Before each release candidate: inspect configuration, permissions, WebViews, logs, source maps, bundle contents, signing settings, and backend environment selection.
- Monthly or quarterly: refresh the dependency inventory, review unresolved advisories, verify secure-storage behavior, test credential rotation, and confirm scanner rules and CI integrations still work.
- After an incident or major advisory: freeze affected releases when appropriate, identify exposure, rotate credentials, patch or remove the dependency, review logs, and document the timeline.
Keep a compact audit record containing the commit or build identifier, scanner versions, commands used, findings, accepted risks, owners, and retest date. This turns recurring security work into an auditable engineering workflow.
How to interpret changes
A rising vulnerability count does not always mean the application became less secure, just as a clean scan does not prove it is safe. A scanner update may add advisories, a lockfile change may expose a transitive package, or improved detection may reveal a pre-existing issue.
Prioritize findings using context: Is the vulnerable code reachable? Does it process attacker-controlled input? Does it run in the shipped production build? Can an attacker cross an authentication or authorization boundary? Is exploitation dependent on a disabled feature? Does a fix introduce a compatibility or supply-chain risk?
Classify each result as remediate, mitigate, accept temporarily with an owner and expiry date, or mark as false positive with evidence. Re-run the relevant scan after remediation and test the affected user flow. Do not silently close a finding because an upgrade changed the report format.
Workflow: auditing a new package
- State the feature need and identify whether the package handles credentials, network data, WebViews, storage, permissions, or native code.
- Review its repository, release source, lockfile impact, maintenance signals, license, and known advisories.
- Inspect install scripts and native changes; compare Expo or native-module compatibility with the project architecture.
- Run dependency and secret scans, build a release-like artifact, and inspect the resulting bundle.
- Record the decision, owner, version range, upgrade policy, and rollback plan.
Workflow: rotating an exposed credential
- Revoke or disable the credential with the issuing service, without waiting for a code change.
- Determine where it appeared: source, history, CI logs, app bundle, crash report, or third-party service.
- Remove it from code and history where appropriate, then scan again.
- Issue a replacement with narrower scope, store it in the correct secret manager, and verify that no mobile bundle requires it.
- Review access logs, affected releases, and related credentials; document the incident and prevention step.
Workflow: reviewing a release artifact
- Record the build identifier, commit, environment, signing mode, and source-map handling.
- Install the artifact on representative iOS and Android test devices.
- Search the bundle and resources for secrets, debug values, internal endpoints, excessive logs, and unintended permissions.
- Exercise login, logout, token expiry, deep links, WebViews, offline mode, and permission denial.
- Save evidence and approve only after unresolved findings have an explicit disposition.
When to revisit
Revisit this React Native security checklist before every production release, after each dependency or native-module upgrade, whenever a new environment variable or permission is introduced, and after changes to authentication, payments, deep links, WebViews, analytics, or crash reporting. Schedule a fuller review monthly or quarterly based on the application's risk and release frequency.
Update the article and your internal checklist after a React Native or Expo release, a major package vulnerability, a mobile-platform policy change, a scanner capability change, or a penetration-test finding. At each review, ask three practical questions: what changed, what can reach production, and what evidence proves the control still works?
Start with the next release candidate: inventory the dependencies, classify every secret and sensitive datum, inspect storage and WebViews, scan the artifact, record exceptions, and assign dates for anything that remains open. That routine is the foundation of dependable React Native secrets management and a security process the team can repeat.
For adjacent release controls, see the React Native CI/CD guide, the native module compatibility guide, and the app size and bundle audit guide.