Estensioni JSON del browser e privacy: un incidente e un audit dei permessi
In sintesi: Un'estensione di formattazione JSON con oltre 200.000 utenti ha cominciato da un giorno all'altro a iniettare script di tracciamento; la causa sta nel permesso <all_urls> e in un modello di fiducia basato sugli aggiornamenti automatici. Questo articolo ricostruisce la cronologia dell'incidente, misura le differenze reali di permessi su quattro repository open source e fornisce una checklist di cinque controlli prima dell'installazione e un confronto di fiducia tra quattro forme di strumenti.

Un'estensione di formattazione che detiene il permesso
<all_urls>può leggere ogni pagina che apri nel browser — e come userà quel diritto domani dipende da un aggiornamento automatico che non controlli.
Uno: l'incidente — ciò che 200.000 utenti avevano installato ha cambiato rotta
A metà 2026, una delle estensioni di formattazione JSON più popolari su Chrome (oltre 200.000 utenti) ha attraversato una catena di cambiamenti: prima è passata a codice chiuso, poi ha stretto una partnership con il partner di dati GiveFreely e ha cominciato a iniettare script di tracciamento geolocalizzato e popup di donazione nelle pagine di checkout visitate dagli utenti. La difesa pubblica dello sviluppatore si riassumeva in "è per beneficenza". La comunità ha risposto con una disinstallazione collettiva. Una retrospettiva di novembre 2026 su dev.to ha ricostruito questa cronologia e recensito gli strumenti sostitutivi.
L'incidente merita una pausa da parte di ogni sviluppatore: perché uno strumento che "si limita a formattare bene il JSON" ha la capacità di iniettare script nelle pagine di acquisto? La risposta non sta in un singolo commit malevolo — sta nel modello di permessi delle estensioni stesso. E peggio: le estensioni si aggiornano automaticamente. La versione che hai verificato il giorno dell'installazione può non essere il codice in esecuzione tre mesi dopo. La chiusura del codice più l'iniezione del partner è un caso di studio completo della rottura di questa catena di fiducia.
Due: perché la portata di un content script è intrinsecamente più ampia di quella di una pagina web
Secondo la definizione di MDN, il content script di un'estensione può leggere e modificare il DOM e i dati della pagina in cui viene iniettato, e l'iniezione può avvenire già a document_start — prima ancora che gli script della pagina stessa girino. Un'estensione JSON che richiede <all_urls> detiene teoricamente questo potere su ogni pagina di ogni sito: il corpo di risposta che incolli in un pannello amministrativo interno, i dati di un sistema intranet — tutto è visibile.
È un modello di fiducia fondamentalmente diverso da quello di uno strumento web online. Il confine di capacità di uno strumento web è il suo stesso dominio; i dati che incolli esistono solo in quella scheda. Il confine di un'estensione è l'intero browser. Perciò la prima domanda su un'estensione non è com'è fatta la sua interfaccia, ma quali permessi richiede, su quali pagine e in quale momento interviene.
Tre: l'audit di quattro repository open source — lo stesso compito, differenze di permessi di un ordine di grandezza
Tutto ciò che un'estensione può fare è scritto nel suo manifest.json. Ho scelto quattro estensioni JSON con repository pubblici e, il 21/11/2026, ho letto direttamente il manifest del branch HEAD di ciascuno, estraendo tre gruppi di campi: permissions, host_permissions e content_scripts. Ecco cosa richiedono:
| Repository (stelle / licenza / ultimo push) | Manifest | permissions | host_permissions | content_scripts |
|---|---|---|---|---|
| callumlocke/json-formatter (4.136★, BSD-3, 2026-09) | MV3 | storage, unlimitedStorage, webRequest | *://*/* + <all_urls> |
due voci, entrambe <all_urls>, una a document_start |
| arnav-kr/json-formatter (9★, MIT, 2026-05) | MV3 | storage, unlimitedStorage | *://*/* + <all_urls> |
una voce, <all_urls>, document_start |
| zalando-incubator/bro-q (84★, MIT, in archivio dal 2020) | MV2 | tabs, activeTab, http://*/*, https://*/*, storage, alarms |
(dichiarati dentro permissions) | una voce, <all_urls>, document_start |
| oppoic/JSONViewer (54★, MIT, 2026-09) | MV3 | solo storage | nessuno | nessuno |
L'audit si riproduce in due passi: recupera il percorso del manifest da raw.githubusercontent.com (la struttura delle cartelle varia; cerca prima manifest.json nell'albero dei file), poi estrai i tre gruppi di campi:
# Una volta noto il percorso del manifest, un comando mostra tutta la superficie dei permessi
curl -sS "https://raw.githubusercontent.com/callumlocke/json-formatter/HEAD/ext/manifest.json" \
| python3 -c "
import json,sys
m=json.load(sys.stdin)
print('permissions :', m.get('permissions'))
print('host_permissions:', m.get('host_permissions'))
print('content_scripts :', [(c.get('matches'), c.get('run_at')) for c in m.get('content_scripts',[])])
"
La lettura fianco a fianco dei quattro risultati è istruttiva. Per lo stesso compito — "formattare JSON" — all'implementazione più conservativa basta un unico permesso storage e zero content script (la via JSONViewer: nulla viene renderizzato finché l'utente non apre manualmente). Le implementazioni diffuse richiedono <all_urls> e si iniettano a document_start su ogni pagina, perché devono prendere in carico il rendering della risposta nell'istante in cui apri un link: più l'esperienza è fluida, più larga è la superficie dei permessi. La build callumlocke dichiara inoltre webRequest (osservazione in sola lettura sotto MV3), e bro-q porta ancora un manifest MV2, in cui tabs più gli URL di tutti i siti è il vecchio stile largo — e lo stato di archivio del repository significa che questi permessi non verranno mai più stretti.
Nessuno qui è "colpevole": <all_urls> più document_start è il prezzo necessario della forma di prodotto "formattazione automatica". Ciò che va verificato non è la larghezza dei permessi in sé, ma il prodotto di tre fattori: larghezza dei permessi × trasparenza della manutenzione × controllo degli aggiornamenti.
Quattro: la verifica in cinque passi prima dell'installazione, cinque minuti
- Leggi i permessi, non il punteggio. Apri la sezione "Autorizzazioni" nella pagina dello store e chiediti, punto per punto, se la funzione ne ha davvero bisogno. Tutto ciò che va oltre "leggere e modificare i tuoi dati su tutti i siti" per uno strumento JSON — cronologia di navigazione, gestione dei download — richiede una giustificazione in una frase; se non c'è, cambia estensione.
- Verifica l'apertura del codice e l'attività dei commit. Se esiste un repository, guarda la data dell'ultimo commit, la licenza e la velocità di risposta alle issue. L'estensione dell'incidente è uscita di binario subito dopo la chiusura del codice — il codice chiuso non è un male in sé, ma toglie l'unico strumento di verifica preventiva.
- Cerca un cambio di proprietario nella cronologia delle versioni. Il campo "sviluppatore" di un'estensione può cambiare; un passaggio improvviso del manutentore storico o un crollo netto della curva delle valutazioni sono segnali. La cronologia delle "modifiche ai permessi" nella pagina dello store merita uno scorrimento.
- Verifica i flussi di dati col pannello Network. Dopo l'installazione apri DevTools, incolla un JSON con campi segnaposto e osserva se durante la formattazione partono richieste verso domini di terze parti. Lo stesso metodo vale per gli strumenti online — vedi la formattazione JSON online invia i tuoi dati.
- Provalo offline. Un formattatore puramente locale deve continuare a funzionare senza rete. Se muore offline, il rendering dipende da un servizio remoto e i tuoi dati hanno attraversato lo stack di rete almeno una volta.
Cinque: cosa ha stretto MV3 — e cosa no
MV3 in Chrome ha sostituito le pagine di background persistenti con service worker on-demand, vietato il codice ospitato da remoto e degradato webRequest alla sola lettura — la superficie d'attacco si è davvero ridotta. Ma due cose non sono cambiate: le estensioni possono ancora richiedere host permissions <all_urls>, e i content script possono ancora iniettarsi in ogni pagina a document_start. Cioè, le differenze di superficie dei permessi della tabella d'audit sopra restano pienamente valide nell'era MV3. Trattare "MV3 = sicuro" come lasciapassare senza controlli è l'errore più pericoloso lasciato da questo incidente.
Sei: modelli di fiducia di quattro forme di strumenti
| Forma | Confine dei dati | Verificabilità | Per cosa |
|---|---|---|---|
| Estensione del browser | Tutto il browser (dipende dai permessi) | Richiede codice aperto + aggiornamenti tracciabili | Consultazione frequente di risposte non sensibili |
| Strumento web online | La scheda corrente | Pannello Network + test offline | Uso occasionale, dopo verifica |
| Editor desktop (VS Code ecc.) | File locali | Completamente locale | Dati sensibili, file grandi |
| CLI (jq ecc.) | File locali | Completamente locale | Script, elaborazione in batch |
Lo stesso fabbisogno di formattazione comporta costi di fiducia completamente diversi in ciascuna forma. Per JSON con dati di clienti, segreti o risposte di API intranet, editor desktop e CLI sono la base a esposizione di rete zero; lo strumento online, solo dopo i controlli 4 e 5; riserva le estensioni alle poche che sono piccole nei permessi, aperte nel codice e attivamente manutenute.
Sette: trasforma l'audit in un'abitudine
Tre punti per concludere. Primo, la fiducia in un'estensione ha una data di scadenza: la cronologia dell'incidente (codice chiuso → iniezione del partner → disinstallazione collettiva) può riprodursi su qualsiasi estensione popolare; rifai la verifica in cinque passi sugli strumenti critici ogni sei mesi. Secondo, valuta i permessi prima delle funzionalità; la tabella di scelta generale è nel confronto tra strumenti di formattazione JSON, e se il tuo lavoro è leggere la struttura più che modificare i dati, vedi strumenti di visualizzazione JSON. Terzo, la regola di gestione del JSON sensibile sta in una riga: tieni i dati dentro un confine già verificato — la tua macchina o una scheda, non l'intero browser.
FAQ
Il permesso <all_urls> è sempre pericoloso?
No. Le estensioni di formattazione automatica devono prendere in carico il rendering all'inizio del caricamento della pagina, quindi <all_urls> più document_start è un prerequisito funzionale. Pericolosa è la combinazione "permessi larghi × codice chiuso × assenza di audit". Leggi i tre gruppi di campi del manifest prima di installare, e il rischio passa da "sconosciuto" a "noto".
Come vedo i permessi effettivi di un'estensione installata?
Apri chrome://extensions, entra nella pagina dei dettagli — lì sono elencati tutti i permessi richiesti; il pannello Network mostra le richieste in uscita. Firefox mostra la stessa lista nella scheda "Autorizzazioni" di about:addons.
Cosa è più sicuro: uno strumento JSON online o un'estensione?
Le premesse differiscono, non c'è una risposta assoluta: il confine di uno strumento online è una sola scheda e può essere verificato offline, quello di un'estensione dipende dai permessi. Uno strumento online verificato come "calcolo puramente locale" può essere più controllabile per dati sensibili di un'estensione chiusa con permessi ampi.
Posso continuare a usare l'estensione dell'incidente?
Puoi, ma quella catena di fiducia si è già rotta una volta: il passaggio al codice chiuso e la partnership di dati sono fatti compiuti. Oltre allo stesso autore esistono un successore open source (arnav-kr) e la build open source classica (callumlocke); prima di reinstallare, verifica il manifest con il metodo di questo articolo.
Un'estensione che apre solo file JSON locali è automaticamente sicura?
La sua superficie di permessi è effettivamente piccola (ad esempio solo storage), ma controlla comunque host permissions e content scripts — se le capacità sono minimizzate lo decide il manifest, non il testo promozionale.