Skip to main content

narvy-cli

Local static security scanner for Android and iOS apps and their source code, plus Google Play and App Store upload checks for APK, AAB and IPA files.

PyPI Python License: Apache 2.0

narvy store-check on InsecureBankv2.apk

Install

pipx install narvy-cli      # or: pip install narvy-cli

Python 3.10 or later. Android scans need Java 11 or later; if none is found, a JRE and jadx are downloaded into ~/.narvy/tools on the first APK scan. No account is needed. Per-OS notes are in Install details.

Quick start

narvy store-check app-release.aab      # Play / App Store upload requirements, offline
narvy scan app-release.apk             # APK, AAB, split APKs, IPA, or a source folder
narvy scan ./repo --output sarif --file results.sarif --fail-on high   # CI gate

narvy store-check on InsecureBankv2, a deliberately vulnerable Android app (narvy-cli 1.2.2, some detail lines removed):

$ narvy store-check InsecureBankv2.apk
narvy-store-check 0.3.0  |  InsecureBankv2.apk  (android/apk)
  id=com.android.insecurebankv2 version=1.0 build=1 min_os=15 target_sdk=22
  requirements as of 2026-10-09  |  sha256 b18af2a0e44d7634...

[BLOCKER] PLAY-DEBUGGABLE: Build is debuggable (android:debuggable=true)
    android:debuggable is true. Google Play rejects debuggable APKs and app bundles.
    - evidence: AndroidManifest.xml = true (application@android:debuggable)
    doc: https://developer.android.com/studio/publish/preparing#publishing-configure

[BLOCKER] PLAY-TARGET-SDK: Target API 22 is below Google Play's requirement (API 36)
    - evidence: AndroidManifest.xml = targetSdkVersion=22
    doc: https://developer.android.com/google/play/requirements/target-sdk

[WARNING] PLAY-CLEARTEXT: Cleartext HTTP allowed for all domains (default for target API 22)
[WARNING] PLAY-PERMISSION-DECLARATION: Play Console declaration needed: SMS, Call Log
[NOT DETERMINED] PLAY-CALL-LOG-VERIFICATION: Required from 2027-01-27: READ_CALL_LOG not allowed for account verification by phone call (use not determined)
[PASS] PLAY-16KB-ELF: No 64-bit native library to align for 16 KB pages

Summary: 2 blockers, 2 warnings, 0 info, 1 not determined
NOT READY: at least one blocker
Deterministic checks only. Not a security scan.

narvy scan on the same APK (progress lines and per-finding detail removed):

$ narvy scan InsecureBankv2.apk
Found 19 potential issues:
┏━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━┓
┃ Severity ┃ Rule Name                            ┃ File                                 ┃               Lines ┃ Hits ┃ Confidence ┃
┡━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━╇━━━━━━━━━━━━┩
│ CRITICAL │ Potential secret: hardcoded          │ sources/com/android/insecurebankv2/… │              27, 35 │    2 │   MEDIUM   │
│          │ encryption key (pattern match, not   │                                      │                     │      │            │
│          │ tested)                              │                                      │                     │      │            │
│ CRITICAL │ Application is Debuggable            │ resources/AndroidManifest.xml        │                  32 │    1 │    HIGH    │
│ CRITICAL │ Potential secret: hardcoded          │ sources/com/android/insecurebankv2/… │                  22 │    1 │   MEDIUM   │
│          │ encryption key (pattern match, not   │                                      │                     │      │            │
│          │ tested)                              │                                      │                     │      │            │
│   HIGH   │ Component is Exported without        │ resources/AndroidManifest.xml        │ 49, 56, 60, 64 (+2) │    6 │   MEDIUM   │
│          │ Permission                           │                                      │                     │      │            │
│   HIGH   │ Hardcoded Cryptographic IV           │ sources/com/android/insecurebankv2/… │              26, 34 │    2 │   MEDIUM   │
│          │ (indirect)                           │                                      │                     │      │            │
│   HIGH   │ Application Data Backup is Enabled   │ resources/AndroidManifest.xml        │                  33 │    1 │    HIGH    │
│  MEDIUM  │ Write to Unscoped External Storage   │ sources/com/android/insecurebankv2/… │            163, 181 │    2 │    LOW     │
│  MEDIUM  │ Write to Unscoped External Storage   │ sources/com/android/insecurebankv2/… │              25, 29 │    2 │    LOW     │
│  MEDIUM  │ Logging a value that looks like a    │ sources/com/android/insecurebankv2/… │                 117 │    1 │   MEDIUM   │
│          │ credential/token/secret - readable   │                                      │                     │      │            │
│          │ via adb/crash reporters on many      │                                      │                     │      │            │
│          │ devices.                             │                                      │                     │      │            │
│  MEDIUM  │ JavaScript enabled in WebView - can  │ sources/com/android/insecurebankv2/… │                  30 │    1 │   MEDIUM   │
│          │ enable XSS if untrusted content is   │                                      │                     │      │            │
│          │ loaded.                              │                                      │                     │      │            │
└──────────┴──────────────────────────────────────┴──────────────────────────────────────┴─────────────────────┴──────┴────────────┘
Scanned the decompiled app with 48 local rules (28 pattern, 2 taint, 18 structural); 9 of them produced findings.

Run narvy doctor to check the Java, jadx and iOS tooling, and narvy <command> --help for every flag.

What it checks

  • Android (.apk, .aab, split APKs .apkm / .xapk / .apks, Gradle or Kotlin source): manifest settings (debuggable, backup, exported components, cleartext traffic), hardcoded secrets and keys, weak cryptography (static keys and IVs, ECB, weak hashes), WebView settings, insecure storage and logging, TLS trust bypass, native library hardening flags (NX, PIE, RELRO, stack canary, RPATH).
  • iOS (unencrypted .ipa, Swift or Objective-C source): Info.plist and App Transport Security, Mach-O hardening (PIE, stack canary, ARC), keychain accessibility, URL schemes, hardcoded secrets, weak cryptography, TLS trust bypass.
  • Web and backend source (JavaScript/TypeScript, Python, PHP, Go, Ruby, Rust, Java/Kotlin; C#/.NET for secrets and dependencies): injection, SSRF, XSS, unsafe deserialization, weak cryptography, hardcoded secrets.
  • Dependencies: known vulnerabilities, matched on your machine against a downloaded copy of the OSV.dev database (see Dependency check).
  • Store readiness (store-check): 14 Google Play and 7 App Store checks, listed in Store check.

Output: console, JSON, or SARIF for GitHub and GitLab code scanning. Secret findings are reported as potential: values are masked and never tested against the service they belong to.

Three other commands work on targets you own, without an app file: web-scan (Nuclei scan of a live URL, passive unless --active), host-audit (over your SSH access, with Lynis as the hardening baseline) and cloud-scan (AWS or GCP posture, with your own credentials).

What leaves your machine

What When Sent to
Nothing store-check (no network call)
An ecosystem name (e.g. npm), to download its OSV database scan, when the database for that ecosystem is missing or older than 24 h; db update osv-vulnerabilities.storage.googleapis.com
Package names, ecosystems and versions, never code or paths only with scan --osv-api Narvy's EU-hosted OSV mirror (OSV_API_URL to change)
iOS library names only with NARVY_GITHUB_ADVISORIES=1 (never with --offline) api.github.com
JRE and jadx downloads first APK scan, only if Java 11+ or jadx is missing api.adoptium.net, github.com
One anonymous usage event per command (fields listed in Telemetry) every command except store-check and telemetry, on by default narvy.io
Your API token only, to check it (/api/v1/whoami) scan --upload, before the scan starts; narvy login narvy.io (or NARVY_URL)
Findings, never code or binary only with --upload (needs narvy login or NARVY_TOKEN) your Narvy account
With the findings: the app name (the repository name from the git remote, else the folder or file name), the git remote URL with any user, password or token removed (the host is kept), and the branch, when the scanned folder is the root of a git checkout; a local-path or file:// remote is never sent only with scan --upload, unless --app is given your Narvy account
With the findings of an APK, AAB or IPA: its package id (manifest package or CFBundleIdentifier) only with scan --upload your Narvy account
With a dependency finding of a source scan: the path of its manifest or lockfile relative to the scanned folder (e.g. backend/package.json), never an absolute path only with scan --upload your Narvy account
With the findings: the dependency check status, one word (complete, partial, degraded or none) only with scan --upload your Narvy account

scan --offline sends nothing: no database or tool download, no usage event, no GitHub advisory lookup. If jadx or Java is missing for an APK scan, the code analysis does not run (INCOMPLETE, exit 2 with --fail-on); run narvy doctor once while online to install them.

Telemetry is on by default. Turn it off with narvy telemetry off, NARVY_TELEMETRY=0 or DO_NOT_TRACK=1. Semgrep, which runs the structural rules, is started with its version check and metrics disabled.

License

Apache License 2.0, rules included. See LICENSE and License details.

Project site and hosted dashboard: narvy.io.


Install details

If your shell says narvy: command not found / The term 'narvy' is not recognized, pip installed the command into a directory that is not on your PATH. python -m narvy always works (py -m narvy on Windows), and prints once the command that adds that directory to PATH. Narvy never edits PATH itself.

Optional extras:

pip install 'narvy-cli[ios-full]'  # full Obj-C introspection for iOS binary scans
pip install 'narvy-cli[cloud]'     # boto3 + google-auth, needed for cloud-scan

Windows

Recommended, with pipx:

py -m pip install --user pipx
py -m pipx ensurepath          # then close and reopen the terminal
pipx install narvy-cli
narvy scan app.apk

Without pipx:

py -m pip install narvy-cli
py -m narvy scan app.apk

To use the short narvy command after a plain pip install, add pip's Scripts directory to PATH. For the current PowerShell window only (Python 3.14 from python.org; change Python314 to your version):

$env:Path += ";$env:APPDATA\Python\Python314\Scripts"

To make it permanent for your user account, then open a new terminal:

[Environment]::SetEnvironmentVariable("Path", [Environment]::GetEnvironmentVariable("Path", "User") + ";$env:APPDATA\Python\Python314\Scripts", "User")

The exact directory is in pip's WARNING: The script narvy.exe is installed in ... which is not on PATH line, and in the hint py -m narvy prints. The Microsoft Store Python uses a different one (under %LOCALAPPDATA%\Packages\PythonSoftwareFoundation.Python.3.x_...\LocalCache\local-packages). Windows on ARM: semgrep has no Windows ARM64 build, use x64 Python.

macOS

Homebrew's Python refuses pip install outside a virtualenv (error: externally-managed-environment). Use pipx:

brew install pipx && pipx ensurepath   # then open a new terminal
pipx install narvy-cli

or a virtualenv (python3 -m venv ~/.venvs/narvy && ~/.venvs/narvy/bin/pip install narvy-cli). A pip install --user puts narvy in ~/Library/Python/3.x/bin, which is not on PATH: add it with echo 'export PATH="$HOME/Library/Python/3.14/bin:$PATH"' >> ~/.zshrc, or run python3 -m narvy.

Linux

pipx (sudo apt install pipx / dnf install pipx, then pipx ensurepath) is the simplest. Debian 12+ and Ubuntu 23.04+ refuse a system-wide pip install the same way Homebrew does. A pip install --user puts narvy in ~/.local/bin; if that is not on PATH, add export PATH="$HOME/.local/bin:$PATH" to ~/.bashrc, or run python3 -m narvy.

Usage

# Android APK/AAB, split bundle, or a Gradle/Kotlin source checkout
narvy scan app-release.apk
narvy scan app.apkm
narvy scan ./my-android-app/

# iOS: unencrypted IPA, or a Swift/Xcode source checkout
narvy scan MyApp.ipa
narvy scan ./my-ios-app/

# Web/backend source (Node, Python, PHP, Go, Ruby, Rust, Java/Kotlin, C#/.NET)
narvy scan ./my-api-repo/

# SARIF output, for CI or GitHub/GitLab code scanning
narvy scan app-release.apk --output sarif --file results.sarif

# Passive web scan of a live URL: no active injection payloads
narvy web-scan https://example.com

# Agentless host hardening audit over your own SSH access
narvy host-audit example.com --user deploy

# AWS account posture check with the standard AWS credential chain
# (profile, env vars, SSO, instance role); --upload sends the findings only
narvy cloud-scan --profile prod --upload

# GCP project posture check with Application Default Credentials
narvy cloud-scan --provider gcp --project my-project

# List recent scans on your Narvy account (requires `narvy login`)
narvy scans

# Scan + upload every .apk/.aab/.apkm/.xapk/.ipa found in a folder, in one command
narvy upload-all ./my-apps-folder/

# CycloneDX SBOM (optionally Ed25519-signed) and CBOM with a PQC score, offline
narvy sbom ./my-app -f sbom.cdx.json
narvy cbom ./my-app -f cbom.cdx.json

# Google Play / App Store upload requirements, offline (not a security scan)
narvy store-check app-release.aab
narvy store-check MyApp.ipa --lang fr --json

The console summary table groups hits of the same rule in the same file into one row, with a hit count and the lines involved. --no-group shows one row per hit. SARIF and JSON output always list every hit.

Very large Android apps

Decompiling is memory-hungry, and file size is a poor predictor of how much you need. Before decompiling, the CLI reads the DEX headers to estimate the Java heap the app needs and sizes the jadx heap from that estimate and the memory free right now: a small app on a busy 8 GB laptop gets a small heap instead of a refusal. --max-mem sets an upper limit (default auto). When the estimate does not fit in free memory the scan still runs with the largest heap that does, and says so. If jadx runs out of memory it is retried once (a bigger heap when memory allows, otherwise one worker thread), then the scan fails with the numbers. --force runs exactly --max-mem, without sizing or retry.

Sending results to your Narvy dashboard

narvy login links the CLI to a Narvy account. Add --upload to a scan to send its results (the findings, never your code or binary) to your account, where they are de-duplicated, false-positive filtered and kept in the dashboard history; the CLI prints a direct link to the scan. This needs a paid plan (Solo and up) and is never on by default. narvy upload-all <directory> does the same for every binary target found in a folder in one command. narvy scans lists recent scans on your account from the terminal.

In CI, set the token in the NARVY_TOKEN environment variable instead of running narvy login (narvy.io > Profile > API Credentials). It takes precedence over a stored login. NARVY_API_TOKEN is read as an alias when NARVY_TOKEN is not set. With --upload, the token is checked before the scan starts: a rejected token or an unreachable server exits 4 right away.

Exit codes

Code Meaning
0 Scan completed (and nothing reached the --fail-on threshold)
1 --fail-on: at least one finding at or above the threshold
2 --fail-on: nothing reached the threshold, but part of the scan did not run (timed-out pass, unreachable CVE database), so it cannot be certified clean
3 The target or arguments are not usable (path not found, unsupported file type or project, refused URL, invalid option)
4 The scan, login, upload or report write failed
130 Interrupted (Ctrl-C, SIGTERM)

With --upload, --fail-on leaves out the findings your team dismissed in Narvy (false positive, accepted risk, won't fix), as listed in the upload response, and says how many. Without --upload, or when the server does not return that list, every local finding counts. An Info finding never fails the gate; --fail-on any means Low and above.

narvy doctor exits 0 when every required check passes and 1 when one fails. Missing optional tools are shown as INFO and do not change its exit code.

Resource limits

The structural analysis pass runs with at most 4 parallel workers and a 3 GB memory ceiling per analyzed file, so a very large repository does not exhaust the machine. NARVY_SEMGREP_JOBS and NARVY_SEMGREP_MAX_MEMORY_MB (0 = no ceiling) override them; files skipped because of the ceiling are listed in the scan notes. Outside a terminal (CI logs), a progress line is printed every 30 seconds; NARVY_PROGRESS_INTERVAL changes that (0 = off).

Store check

narvy store-check answers one question: will Google Play or the App Store accept this build, and what will they ask about it? It reads the manifest, resources, native libraries, Info.plist, Mach-O load commands, imported symbols and privacy manifests of the file, and evaluates them against the store requirements in force at a date (--as-of, default today).

narvy store-check app-release.aab
narvy store-check app.xapk --fail-on warning      # CI gate on warnings too
narvy store-check MyApp.ipa --json > store.json   # EN and FR messages in one report
narvy store-check MyApp.ipa --as-of 2027-02-01    # evaluate a future deadline
Store Checks
Google Play PLAY-TARGET-SDK, PLAY-16KB-ELF, PLAY-16KB-ZIPALIGN, PLAY-EXPORTED, PLAY-DEBUGGABLE, PLAY-CLEARTEXT, PLAY-FGS-TYPE, PLAY-FGS-PERMISSION, PLAY-FGS-DECLARATION, PLAY-PERMISSION-DECLARATION, PLAY-CONTACTS-PERMISSION, PLAY-PRECISE-LOCATION, PLAY-FGS-GEOFENCING, PLAY-CALL-LOG-VERIFICATION
App Store APPSTORE-SDK-VERSION, APPSTORE-MIN-OS, APPSTORE-REQUIRED-REASON-API, APPSTORE-PRIVACY-MANIFEST, APPSTORE-THIRD-PARTY-SDK, APPSTORE-ATS, APPSTORE-PURPOSE-STRINGS

Each check reports fail (severity blocker, warning or info), pass, not_determined (the binary does not settle the question) or not_applicable, with the evidence read from the file and the official page the rule comes from. In --json, title describes the result for its status and cites the value read ("Target API 33 is below Google Play's requirement (API 36)"), and requirement holds the rule itself ("Target API level meets Google Play's current requirement"), both in English and French. Store values and their sources live in narvy/store_check/data/.

Four Google Play policy changes take effect on 2027-01-27: the Contacts Permissions policy (READ_CONTACTS in apps that target API 37+), the precise location declaration and location button (ACCESS_FINE_LOCATION, onlyForLocationButton), geofencing removed as a foreground service use, and READ_CALL_LOG no longer accepted for account verification by phone call. Before that date their findings read "Required from 2027-01-27". They are never blockers: what Google requires (a declaration it approves, or a use it no longer allows) is not in the binary. When the answer depends on how the app uses a permission or a service, the check reports not_determined.

It runs offline: no network call, no telemetry event, nothing written to disk (the archive is read in memory). It does not check store listing metadata, Data safety answers, whether a declared permission use is acceptable under Play policy, or SDK signatures.

Exit codes: 0 no blocker (with --fail-on warning, no warning either), 1 at least one blocker (or warning), 3 the file cannot be analysed.

Dependency check (SCA)

Dependencies are matched on your machine against the public OSV database (OSV.dev data dumps). For each ecosystem a scan needs (npm, PyPI, Maven, Go, RubyGems, Packagist, crates.io, NuGet, SwiftURL), the CLI downloads https://osv-vulnerabilities.storage.googleapis.com/<ecosystem>/all.zip. The request names the ecosystem and nothing else: no package name, no code, no path. The file is checked (size, md5, zip integrity), stored as SQLite in ~/.cache/narvy/osv/ ($XDG_CACHE_HOME/narvy/osv/ when XDG_CACHE_HOME is set, NARVY_OSV_DB_DIR to choose another directory) with a sha256 checked on each use, and downloaded again when older than 24 hours.

narvy db update                 # refresh the ecosystems already cached
narvy db update -e npm,PyPI     # download these ecosystems
narvy db status                 # what is cached, age, size, damaged files
narvy scan . --offline          # use the cache only, nothing leaves the machine
narvy scan . --osv-api          # previous behaviour: query the OSV API

Sizes on disk: npm 301 MB (220 MB download), PyPI 71 MB, Packagist 28 MB, Maven 27 MB, Go 19 MB, NuGet 14 MB, the others under 10 MB. A refresh builds the new file next to the old one: for npm, about 820 MB free space is needed while it runs (old file, zip and new file).

The check is reported INCOMPLETE (exit code 2 with --fail-on), never clean, when an ecosystem's database cannot be used: no copy and no download possible, --offline without a copy, a copy older than 7 days (online or offline), or a damaged file. A damaged file is moved aside as <ecosystem>.db.corrupt and downloaded again, except with --offline. A copy between 24 hours and 7 days old (refresh failed, or --offline) is used and the scan says how old it is.

--osv-api sends each dependency's name, ecosystem and version to Narvy's EU-hosted OSV mirror, or to OSV_API_URL (a base URL, /query and /querybatch are appended; OSV_BATCH_API_URL overrides the batch URL). Responses are cached 7 days in ~/.narvy/osv_cache.db.

Dependencies with no lookup key (an ecosystem OSV does not carry, an iOS library with no known source repository URL) are counted as unverified.

CI

Cache ~/.cache/narvy/osv between runs, or every run downloads the database again. narvy init-ci --github, --gitlab and --bitbucket write this for you, and add --upload to the scan when a NARVY_TOKEN secret or variable is set (without one the scan stays local).

GitHub Actions, one key per UTC day:

- id: osv_day
  run: echo "day=$(date -u +%Y-%m-%d)" >> "$GITHUB_OUTPUT"
- uses: actions/cache/restore@v4
  with:
    path: ~/.cache/narvy/osv
    key: narvy-osv-${{ steps.osv_day.outputs.day }}
    restore-keys: narvy-osv-
- run: narvy scan . --fail-on high
- if: always()
  uses: actions/cache/save@v4
  with:
    path: ~/.cache/narvy/osv
    key: narvy-osv-${{ steps.osv_day.outputs.day }}

GitLab caches only paths inside the project and has no date variable for a key: point NARVY_OSV_DB_DIR at $CI_PROJECT_DIR/.narvy-osv and cache that folder with a fixed key and when: always; the CLI refreshes a copy older than 24 hours.

SBOM and CBOM

Both are offline, CycloneDX 1.6 JSON. They work on a source directory, an .apk/.aab or an .ipa, alone or as part of a scan.

narvy sbom ./my-app -f sbom.cdx.json --sign-key key.pem   # signed SBOM
narvy verify-sbom sbom.cdx.json --public-key pub.pem      # exit 0 = valid
narvy cbom ./my-app -f cbom.cdx.json                      # crypto inventory + PQC score
narvy scan ./my-app --sbom sbom.cdx.json --sign-key key.pem --cbom cbom.cdx.json

SBOM. The dependencies the dependency check reads (npm, PyPI, Packagist, Go, RubyGems, crates.io, Maven/Gradle, NuGet, CocoaPods, SwiftPM; Maven coordinates left in an APK; versioned frameworks in an IPA). No vulnerabilities inside; narvy scan does that lookup. Licenses only where recorded locally: package-lock.json, installed node_modules, composer.lock. A version taken from a manifest range, not a lockfile, is marked manifest-range-floor.

Signing. Ed25519, in the JSF format CycloneDX uses (signature at the root, signed over the canonical JSON). Needs pip install 'narvy-cli[sign]' and an unencrypted PEM key (openssl genpkey -algorithm ed25519 -out key.pem). Without --sign-key the SBOM is unsigned and the CLI says so. The embedded public key only proves the file was not changed; pass --public-key to verify-sbom to check who signed it.

CBOM. Basic open inventory, not the platform's PQC analysis. It lists the algorithm families found: in source, at API call sites (regex, comments, vendored, build and test folders skipped); in an APK, as exact dex string constants (library code included); in an IPA, CommonCrypto, Security and CryptoKit symbols and Go crypto packages. No data flow, no key sizes. An APK that bundles Bouncy Castle lists the post-quantum names it ships, but they do not count in the score. Score per family found: 100 * post-quantum / (post-quantum + quantum-vulnerable). Quantum-vulnerable: RSA, ECDSA, ECDH, DH, DSA, X25519, Ed25519. Post-quantum: ML-KEM, ML-DSA, SLH-DSA. MD5, SHA-1, DES and 3DES are listed as classically weak and do not change the score. No asymmetric algorithm found gives no score, not 100.

Telemetry

The CLI sends one small anonymous event per command (store-check sends none), so we can see which scan types are used and where they fail. It is sent in the background with a 1 second timeout, is never retried or stored for later, and never fails a scan. At most it adds 1 second at exit. A notice is printed the first time it runs.

Exactly these fields are sent:

Field Example
schema 1, the event format version
install_id a random UUID created on first run and stored in ~/.narvy/config.json (not derived from your machine, user or account)
cli_version, python_version, os 1.3.0, 3.11, linux / darwin / windows / other
ci true when a CI environment variable is set
command scan, web-scan, host-audit, ...
surface android, ios, source, web, host, cloud or none
duration_bucket <10s, 10s-1m, 1-5m, 5-15m, 15-60m, >60m
findings per severity, a bucket: 0, 1-5, 6-20, 21-100, 101-500, >500
exit_code the process exit code
error_class on a crash, the exception class name only (e.g. ValueError), never its message

Never sent: code, file, project, package or repository names, paths, URLs, hosts or IPs you scan, finding details, your account id or email.

Turn it off with any of:

narvy telemetry off        # saved in ~/.narvy/config.json; `narvy telemetry on` to re-enable
export NARVY_TELEMETRY=0
export DO_NOT_TRACK=1

narvy telemetry status shows the current state. The code is in narvy/telemetry.py.

Free rules and premium rules

The CLI ships the community rule set under Apache 2.0: the language-level rules for every supported language (injection, weak cryptography, dangerous configuration, storage, WebView, transport), every hardcoded-secret rule, and the Android and iOS rules. It is the same engine and the same community rules that Narvy runs on its servers.

Framework-specific rules (Django, Flask, FastAPI, Express, Laravel, Symfony, Ruby on Rails, Spring and the Java persistence/serialization stack, Gin) and the C#/.NET code rules are premium: they run when a project is scanned on a Narvy paid plan, not in the CLI. When a scanned project uses one of those frameworks, the CLI says so in one line at the end of the scan, with the number of checks it did not run. It never hides a finding it did compute.

Known limitations

  • Encrypted iOS binaries (the normal App Store distribution state) are detected but not decrypted; only the local, static checks that don't need the decrypted binary run.
  • Web-source coverage depth isn't uniform across all eight languages: Rust and C#/.NET have a smaller rule set than the others, and the CLI says so in its own output when it applies.
  • Only one architecture's native libraries are checked in a multi-ABI APK/split bundle.
  • Windows: a decompiled file whose full path passes 260 characters is only read when Windows long-path support is enabled (LongPathsEnabled); a very deep package tree in %TEMP% can hit it.

See SETUP.md for detailed install and troubleshooting steps.

License details

Apache License 2.0, see LICENSE.

Rule packs under narvy/rules/ are authored by Narvy (Apache 2.0, same as the rest of this package) and contain no third-party rule text. host-audit runs Narvy's own host checks (secrets exposed on disk, unauthenticated data services, cloud metadata exposure, container/daemon posture, exposed VCS/artifacts in web roots) and, as the hardening baseline, shells out to Lynis (GPL-3.0), auto-fetched at run time over your SSH access, run arm's-length, never bundled. Lynis is attributed as the engine in the audit output; its controls are not presented as Narvy's own.

Contributing

Issues and pull requests are welcome, in particular new or improved detection rules. All rule packs are Narvy's own, under narvy/rules/: Android/iOS (rules/android, rules/ios) and web/backend (rules/web). The web/backend packs run on the Semgrep OSS engine, which Narvy invokes as a dependency; the rules themselves are authored by Narvy (Apache-2.0).

Metadata

Release files for narvy-cli 1.3.7

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for narvy-cli 1.3.7
File Size Uploaded Provenance Actions
narvy_cli-1.3.7.tar.gz 637.8 kB Without provenance Details for narvy_cli-1.3.7.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for narvy-cli 1.3.7
File Interpreter ABI Platform Actions
narvy_cli-1.3.7-py3-none-any.whl Python 3 none any Details for narvy_cli-1.3.7-py3-none-any.whl

Total release size: 1.3 MB

Release files / narvy_cli-1.3.7.tar.gz

Download URL narvy_cli-1.3.7.tar.gz
Size 637.8 kB
Tags Source
SHA-256 checksum
How to use checksums
25fc9271e270826fa9eb04199379647d361fae02c9e9b9b5f0c5c7a99c4a7af4
BLAKE2b-256 checksum
How to use checksums
dd95b5742879ba2fa78bcc8faccac27ce86054881da379956b2e580d0b00bdff
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.12

Release files / narvy_cli-1.3.7-py3-none-any.whl

Download URL narvy_cli-1.3.7-py3-none-any.whl
Size 649.5 kB
Tags Python 3
SHA-256 checksum
How to use checksums
21b1a8f7f39fc98ba41666ff2f49319ed9ceb8b0cc97fa94067fe414d85d6a9e
BLAKE2b-256 checksum
How to use checksums
6ac763777a14e63bee49c75b3a98f6b49563cfb9fc7f5e81de0b61ca12d44016
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.12

Security for narvy-cli 1.3.7

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page