Scopecreep
Scores your installed extensions against what they claim to do, and tells you when one quietly asks for more.
ScopeCreep
Scores your installed extensions against what they claim to do, and tells you when one quietly asks for more.
Date: 2026-08-15
Form factor: Browser extension (Manifest V3)
Browser surface: content script (Chrome Web Store product pages), toolbar popup, chrome.management, chrome.storage, chrome.alarms
Status: Prototype
What it is
ScopeCreep reads the permission list of every other extension in your browser, guesses what each one is supposed to do from its name and description, and flags the ones asking for more than that job needs. A background check re-scans on an interval and remembers each extension's last permission set, so if one gains a new permission after an update, ScopeCreep notices even if you never open the popup. A content script does the same check one step earlier, on the Chrome Web Store listing itself, before you click Add to Chrome.
Why it has to be an extension
The core data source is chrome.management.getAll(), which lists every extension installed in the browser along with its permissions — no website can see that list, and no other extension can either unless it asks for the same permission. Reading it, storing snapshots over time, and diffing them on a schedule are all things that only happen inside the browser process itself. The Store-page banner is a content script reading a page's live DOM the moment you land on it, before any install decision is made.
Who it serves
Individually: people who install extensions the way most people do (a quick search, a plausible name, "Add to Chrome") and have no way to check afterward whether one of them asks for more than its job requires. For teams: an IT or security lead who has to answer, this week, which extensions across the company's managed Chrome fleet request permissions their stated purpose doesn't call for.
Why it could be profitable
Free tier: manual scans, risk scores for up to 5 installed extensions. Paid tier (roughly $3.99/mo or $24/yr): unlimited extensions, the background auto-rescan, the full permission-change timeline, and a CSV export aimed at IT teams doing exactly this kind of audit across a managed fleet. That B2B export is the more defensible revenue line — a security team auditing dozens of employee machines is a much easier sell than an individual paying a few dollars a month to check their own extensions once and forget about it.
The timing is specific, not just generally relevant. Chrome Web Store's updated developer policies took effect August 1, 2026, closing the loophole that let extensions collect data outside their stated single purpose; anything still out of line risks removal. On the incident side, ModHeader, an extension with roughly 1.6 million combined Chrome and Edge installs, had its store listing pulled in July 2026 after researchers found a dormant data-collection capability sitting inside permissions it already held, gated by an empty allowlist so no new permission request ever appeared. That detail matters for what this tool can and can't promise. ScopeCreep's permission-change alert would not have caught that specific case, because nothing new was requested. What it does catch is the far more common pattern: a permission set that was already too broad for the extension's stated purpose from day one, plus any future extension that does ask for more.
How to load it in Chrome
- Open
chrome://extensionsand turn on Developer mode. - Click Load unpacked and select this folder's
extension/directory. - Open the popup — it scans your real installed extensions immediately. Visit any
chromewebstore.google.com/detail/...product page to see the inline risk banner.
How to try the demo
- Open
index.htmlin any modern browser. No server is needed — the page carries an inline copy ofsample-data.jsonfor browsers that blockfetch()onfile://. - Click the SC button in the mock toolbar to open the popup and see the scored extension list; click any row to expand its permission detail and change history.
- The mock page underneath is a stand-in Chrome Web Store listing — the risk banner above its title simulates what
extension/content.jswould inject on a real product page.
The demo can't run chrome.management.getAll() or a real background alarm, so the popup and the mock page both read from sample-data.json instead of live browser state — that's the one difference from loading the real extension.
Permissions, and why each one
| Permission | Why it's needed |
|---|---|
management |
Reads the list of installed extensions and their declared permissions so each one can be scored |
storage |
Stores scan results, permission snapshots, and the change timeline locally in the browser |
alarms |
Triggers a periodic background rescan so a newly requested permission is caught between popup opens |
Host match: chromewebstore.google.com/detail/* |
Lets the content script read a Store listing's permission disclosures before you install |
What's in this prototype
- A background service worker that scans installed extensions via
chrome.management, scores each against a small set of category-to-permission rules, and diffs the result against the last snapshot inchrome.storage.local - A toolbar popup listing every scored extension, sorted riskiest first, with a badge on rows whose permissions changed since the last scan
- A content script for Chrome Web Store product pages that scrapes the visible permission list and injects a risk banner before the Add to Chrome button
- A shared risk heuristic: sensitive permissions (
tabs,webRequest,cookies,history,management,<all_urls>, and similar) weighted against an expected set inferred from the extension's name and description - A toolbar badge count and a "recently checked on the Store" list in the popup, both fed by messages from the content script
- A demo harness with 14 sample installed extensions and one mock Store listing, covering the full range from clean to flagged
Roadmap
- Recognize more categories — the current rule set misses common ones like developer tools and browser-header utilities, which is exactly the category the ModHeader incident fell into
- Detect risk from permission combinations, not just individual permissions, since
tabspluswebRequesttogether is a different signal than either alone - A managed-fleet view for the paid tier, aggregating scan results across a Google Workspace or Chrome Enterprise deployment
- Weekly email or Slack digest of anything newly flagged, instead of requiring someone to open the popup
- Cross-reference each extension's permissions against its actual Chrome Web Store privacy disclosure, not just its name and description
Sources
- Chrome Extensions Face New Data Privacy Rules Starting August 1 — DigitBin — the Limited Use Policy, disclosure requirements, and removal risk that took effect August 1, 2026
- Chrome Extension Used by 1.6 Million Users Silently Adds Data Exfiltration Capabilities — Cyber Security News — the ModHeader incident, including the detail that the collection code activated without any new permission request
Requirements
ScopeCreep — Requirements
Goals
- Score every other installed extension's permissions against what its name and description claim to do
- Catch permission changes between scans, so a silent scope increase after an update gets flagged
- Warn before install, not just after, by scanning the permission list on a Chrome Web Store product page
- Keep the free tier genuinely useful (manual scans) while the paid tier earns its price on ongoing monitoring and export
Primary user
Two personas, one product. The individual: someone who installs extensions casually and has no way to check, six months later, whether one of them still matches what it originally asked for. The IT/security lead: someone who needs a permission audit across a managed Chrome fleet ahead of a compliance deadline, and wants evidence, not just a gut feeling about which extensions to distrust.
Functional requirements
- FR1: On install, scan all currently installed extensions via
chrome.management.getAll(), excluding ScopeCreep itself and non-extension items (themes, apps) - FR2: For each scanned extension, infer a likely category from its name and description using a keyword rule set
- FR3: For each category, maintain an expected-permission set; flag any sensitive permission the extension holds that falls outside that set
- FR4: Weight flagged permissions by sensitivity and roll them into a risk level of low, medium, or high
- FR5: Persist a permission snapshot per extension ID in
chrome.storage.local - FR6: On each scheduled rescan, diff the current permission set against the stored snapshot; if new permissions appear, mark the extension as changed and record what was added
- FR7: Re-run the scan on a recurring alarm (default: hourly) via
chrome.alarms, independent of whether the popup is open - FR8: Show a badge count on the toolbar icon equal to the number of extensions that are high-risk or newly changed
- FR9: In the popup, list all scanned extensions sorted riskiest-first, with a risk pill and a "changed" tag where applicable
- FR10: Let the user expand any row to see its full permission list, the reasons it was flagged, and (if applicable) exactly which permissions were added and when
- FR11: On a Chrome Web Store product page, scan the visibly rendered permission disclosures and compute a risk score using the same category and sensitivity rules
- FR12: Inject a single, non-intrusive banner near the page's title showing that risk score, without altering any other part of the page
- FR13: Guard against double-injecting the banner if the content script runs more than once on the same page
- FR14: Send each Store-page scan result to the background service worker so the popup can show a short "recently checked" history
- FR15: Support a manual "Rescan" action from the popup that triggers an immediate scan rather than waiting for the next alarm
User stories
- As someone who has installed a dozen extensions over the years, I want to see which ones are asking for permissions their stated purpose doesn't need, so I can decide which to remove.
- As that same user, I want to be told if an extension's permissions changed since I last checked, so an update that quietly adds tracking doesn't slip past me.
- As someone about to install a new extension, I want a risk read before I click Add to Chrome, so I can back out before granting anything.
- As an IT lead, I want to export a permission-risk snapshot across a fleet, so I can show compliance evidence without auditing each machine by hand.
- As a free-tier user, I want a useful one-time scan without paying, so I can evaluate whether the paid tier is worth it.
- As a popup user, I want to expand a single row instead of navigating to a separate screen, so I can check one extension quickly and move on.
Extension surfaces
- Toolbar popup — the main dashboard: scored extension list, expandable detail, rescan control, recently-checked Store pages
- Content script on
chromewebstore.google.com/detail/*— inline risk banner on a product page before install - Background service worker —
chrome.managementscans,chrome.alarms-driven rescheduling, snapshot diffing, badge updates chrome.storage.local— persistence for snapshots, the latest audit result, and Store-page scan history
Non-functional requirements
- Permission minimalism: the manifest declares only
management,storage, andalarms, plus the narrow content-script match pattern; no<all_urls>or general host access - Privacy: all scanning and storage stays local to the browser; the prototype makes no network calls and sends no data anywhere
- Performance: a full scan of a typical 20-extension install should complete well under a second; the alarm interval defaults to hourly to avoid unnecessary background work
- Resilience: content-script DOM scraping must fail gracefully (no banner, no error) if the Store page's markup doesn't match expected patterns, since store layouts change without notice
- Accessibility: popup rows and the risk banner use sufficient color contrast and don't rely on color alone (risk level is also stated as text)
Out of scope (for the prototype)
- Any backend service, account system, or the actual paid checkout flow — the upgrade button is a stub
- Fleet-wide aggregation across multiple managed devices (the roadmap item, not built here)
- Detecting dormant code that activates within permissions an extension already holds — a real limitation, not just an unbuilt feature, since that requires code analysis rather than permission comparison
- Any category beyond the eleven keyword rules included in this prototype
Open questions
- Should the category-inference rules be user-editable, so someone can correct a mislabeled extension instead of living with a wrong risk score?
- Where's the right line between "flag it" and "auto-disable it" for a paid tier aimed at IT teams who want stronger enforcement, not just visibility?
- Would cross-referencing the Chrome Web Store's own privacy-practices disclosure (where developers state their data use) produce a better signal than inferring category from name and description alone?