confusable-vision

Punteggio di similarità empirica dei glifi mediante raycasting su contorni vettoriali. Analizza coppie di caratteri Unicode confondibili su 245 font di sistema, misura la similarità strutturale direttamente dai contorni dei font (nessuna rasterizzazione) e produce artefatti JSON con punteggi di distanza continua per ogni font.

Risultati principali da 52,6 milioni di confronti a carattere singolo e 190 milioni a caratteri multipli su 22.581 caratteri e 12 sistemi di scrittura:

• 249.976 coppie uniche confondibili a carattere singolo su 245 font, 12 scritture, 66 coppie inter-scrittura. 764.395 scoperte totali a livello di font.
• 2.524.275 coppie uniche confondibili a caratteri multipli (bigrammi) inclusi rn/m su 95 font (33 sotto distanza 0,40) e oy/Cyrillic uk su 16 font.
• Punteggi di distanza continua per font, non elenchi binari. Ogni coppia ha una distanza ray misurata per font, offrendo una confidenza consapevole del font per strumenti di sicurezza a valle.
• 305% più scoperte rispetto a SDF, 29% più veloce. La firma arricchita a cinque strati è un superset stretto dei risultati SDF; le coppie esclusive di SDF non si sono replicate nella revisione manuale.

L'output alimenta direttamente namespace-guard per il rilevamento runtime di confondibili in nomi di pacchetti, nomi di dominio e identificatori.

Come funziona

RaySpace proietta raggi paralleli attraverso i contorni dei font a 36 angoli e cattura cinque strati di informazione per glifo: conteggi di attraversamento, posizioni degli attraversamenti, angoli di attraversamento, distanze ping (spessore del tratto a ogni attraversamento) e ping max (larghezza del controtratto tra gli attraversamenti). Questo produce una firma compatta per carattere per font. Due firme vengono confrontate con una distanza L1 pesata su tutti e cinque gli strati.

Una cascata di filtri a tre stadi rende il confronto esaustivo trattabile:

1. Filtro larghezza avanzamento (tolleranza 15%) elimina coppie con larghezze di carattere diverse. Rimuove il 63% dei candidati.
2. Confronto ray (soglia 2,0, stretta a 1,0 per coppie di scritture grandi). Rimuove un altro 33%.
3. Solo il 3,3% dei candidati sopravvive per diventare scoperte.

Il banco di firme (294.646+ voci su 245 font; di più con --include-uppercase) viene precalcolato una volta. La scoperta viene poi eseguita come aritmetica a singolo thread sul banco, completando 52,6 milioni di confronti di coppie in 31 minuti senza thread worker o GPU.

Avvio rapido

npm install

# 1. Costruisci il banco di firme ray (prerequisito, ~24 min)
npx tsx scripts/build-signature-bank.ts

# 1b. Includi maiuscole latine A-Z (opzionale)
#     Per impostazione predefinita il banco include solo codepoint PVALID IDNA (minuscole,
#     cifre, simboli). Usa --include-uppercase per aggiungere A-Z maiuscole, utile
#     per l'identificazione dei font e il confronto visivo di marchi dove le forme
#     delle maiuscole sono importanti. Il costruttore è riprendibile, quindi calcola
#     solo i codepoint aggiuntivi.
npx tsx scripts/build-signature-bank.ts --include-uppercase

# 1c. Includi intervalli di codepoint arbitrari (opzionale)
npx tsx scripts/build-signature-bank.ts --extra-range=0041-005A

# 2. Scoperta a carattere singolo (22.581 caratteri, 12 scritture, ~36 min)
npx tsx scripts/discover-singlechar-sdf.ts --scorer=ray

# 3. Scoperta a caratteri multipli (bigrammi) (676 bigrammi, ~63 min)
npx tsx scripts/discover-multichar-sdf.ts --scorer=ray

# 4. Valuta i confondibili multi-carattere TR39 noti (~5 min)
npx tsx scripts/score-multichar-sdf.ts --scorer=ray

# Valutazione coppie confondibili TR39
npx tsx scripts/build-index.ts          # Indice di rendering (~160s, 11.370 PNG)
npx tsx scripts/score-all-pairs.ts      # Valuta tutte le coppie (~65s, 235K confronti)

# Scoperta di nuovi confondibili
npx tsx scripts/build-candidates.ts          # Insieme candidato (~23K caratteri)
npx tsx scripts/build-index.ts --candidates  # Render candidati (~40min, 89K PNG)
npx tsx scripts/score-candidates.ts          # Valuta contro target latini (~15min, 2,9M confronti)

# Estrai scoperte ad alto punteggio da entrambe le pipeline
npx tsx scripts/extract-discoveries.ts

Cosa ha trovato

Coppie confondibili principali (carattere singolo, distanza media < 0,10)

"Zeri" = font in cui i contorni producono firme ray bit-identiche (distanza 0,000). Latino w/Cirillico ԝ è identico in tutti i 19 font che contengono entrambi i glifi.

Scoperte inter-scrittura (carattere singolo)

Il Georgiano Coda (U+10FF) forma un anello confondibile a quattro vie con Latino o, Cirillico o e Omicron greco, tutti sotto distanza 0,08.

Risultati principali multi-carattere

La scoperta oy/uk cirillico è il risultato inedito più rilevante: il bigramma latino "oy" è visivamente identico alla lettera digrafo cirillico uk (ѹ) a distanza 0,000 in Helvetica e 0,0005 in Arial Unicode MS.

Calibrazione della soglia

Tre livelli operativi raccomandati:

• Stretto (< 0,50): 138 coppie a carattere singolo, falsi positivi quasi nulli. Adatto per blocco automatico (registrazione IDN, validazione nomi pacchetto) dove i falsi positivi hanno un costo reale.
• Standard (< 1,00): 4.174 coppie a carattere singolo, buon equilibrio tra copertura e precisione. Adatto per segnalazione e revisione manuale in strumenti di sicurezza.
• Esplorativo (< 2,00): Insieme completo delle scoperte. Contiene rumore all'estremità superiore ma utile per ricerca, audit dei font e costruzione di set di addestramento.

Ricerca per font

Interroga quali coppie confondibili esistono per un font specifico. Utile per designer di font che rilasciano un nuovo carattere tipografico, produttori di browser che valutano un cambio di font di sistema, o chiunque scelga un font per display in contesti sensibili alla sicurezza come i domini IDN.

npx tsx scripts/query-font.ts --list-fonts                    # 218 font nei dati di scoperta
npx tsx scripts/query-font.ts "Arial"                         # Tutte le coppie per Arial (SSIM >= 0,7)
npx tsx scripts/query-font.ts "Arial" --threshold 0,8         # Solo alta confidenza
npx tsx scripts/query-font.ts "Arial" --compare "Georgia"     # Differenza tra due font per delta SSIM
npx tsx scripts/query-font.ts "Arial" --json                  # JSON per elaborazione a valle

Il matching del nome del font è case-insensitive e parziale, quindi "arial" corrisponde ad Arial, Arial Black e Arial Unicode MS. La modalità di confronto ordina per le maggiori differenze SSIM, mostrando esattamente quali coppie migliorano o peggiorano cambiando font.

Richiede i file di scoperta dalla pipeline di valutazione (gitignorati, rigenerare localmente).

Output

Committed (CC-BY-4.0)

Generati (gitignorati, eseguire pipeline per rigenerare)

Avanzamento

• Validazione TR39 (1.418 coppie, 230 font, pipeline SSIM)
• Scoperta nuovi confondibili (793 coppie ad alto punteggio da 23.317 candidati, SSIM)
• Scansione confondibili inter-scrittura (12 scritture ICANN, 23,6M coppie, 563 scoperte, SSIM)
• Ricerca per font e confronto tra font
• Scorer RaySpace a cinque strati su contorni vettoriali (sostituisce SDF e SSIM per la scoperta)
• Scoperta RaySpace a carattere singolo (249.976 coppie uniche, 245 font, 12 scritture)
• Scoperta RaySpace multi-carattere (2.524.275 coppie uniche bigramma, 245 font)
• Scoperta inter-scrittura con RaySpace (305% più coppie rispetto a SDF, superset stretto)
• Produrre confusable-weights-v2.json con record distribuzionali per coppia: media, p50, p90, conteggio font, conteggio distanza zero, frazione zero e livello raccomandato (stretto/standard/esplorativo). Le distanze RaySpace sostituiscono SSIM. 4.174 coppie a soglia standard.
• Formato binario per banco firme (ridurre il tempo di caricamento da 273s a secondi)
• Valutare font arbitrari tramite percorso senza rieseguire l'intera pipeline

Correlati

• namespace-guard (v0.16.0+) consuma confusable-weights.json per valutazione del rischio visivo misurata tramite confusableDistance({ weights })
• REPORT.md: rapporto tecnico completo dalla pipeline SSIM (12 sezioni, analisi per font, appendici)

Post del blog

Articoli su paultendo.github.io che descrivono i risultati e la metodologia alla base di questo progetto:

Metodologia RaySpace e risultati:

• RaySpace: measuring glyph similarity with vector-outline raycasting
• From CT scanners to confusable characters: the prior art behind RaySpace
• Multi-character confusables: when rn becomes m
• 250,000 confusable pairs. 102 that matter for domain names.

Risultati pipeline SSIM:

• I rendered 1,418 Unicode confusable pairs across 230 fonts. Most aren't confusable to the eye.
• 793 Unicode characters look like Latin letters but aren't (yet) in confusables.txt
• 28 CJK and Hangul characters look like Latin letters
• 248 cross-script confusable pairs that no standard covers
• 148x faster: rebuilding a Unicode scanning pipeline for cross-script scale
• When shape similarity lies: size-ratio artifacts in confusable detection
• The new DDoS: Unicode confusables can't fool LLMs, but they can 5x your API bill

Contesto

Articoli che trattano lo spazio problematico più ampio che ha motivato questo progetto:

• A threat model for Unicode identifier spoofing
• Making Unicode risk measurable
• Your LLM reads Unicode codepoints, not glyphs. That's an attack surface.
• Who does confusable detection actually protect?
• Unicode ships one confusable map. You need two.
• confusables.txt and NFKC disagree on 31 characters

Licenza

• Codice (src/, scripts/): MIT
• Dati generati (data/output/): CC-BY-4.0. Liberi da usare, condividere e adattare per qualsiasi scopo, anche commerciale, con attribuzione.
• Attribuzione: Paul Wood FRSA (@paultendo), confusable-vision