confusable-vision

Évaluation empirique de la similarité des glyphes par raycasting vectoriel des contours. Rend les paires de caractères Unicode confusables dans 245 polices système, mesure la similarité structurelle directement à partir des contours (sans pixellisation), et produit des artefacts JSON notés avec des scores de distance continue par police.

Résultats clés issus de 52,6 millions de comparaisons mono-caractère et 190 millions de comparaisons multi-caractères sur 22 581 caractères et 12 systèmes d'écriture :

• 249 976 paires confusables mono-caractère uniques sur 245 polices, 12 écritures, 66 paires inter-écritures. 764 395 découvertes au total au niveau des polices.
• 2 524 275 paires confusables multi-caractères (bigrammes) uniques incluant rn/m sur 95 polices (33 en dessous d'une distance de 0,40) et oy/uk cyrillique sur 16 polices.
• Scores de distance continue par police, pas des listes binaires. Chaque paire possède une distance de rayon mesurée par police, offrant une confiance tenant compte de la police pour les outils de sécurité en aval.
• 305% de découvertes en plus que le SDF, 29% plus rapide. La signature enrichie à cinq couches est un sur-ensemble strict des découvertes SDF ; les paires exclusives au SDF ne se sont pas reproduites lors d'une vérification manuelle.

La sortie alimente directement namespace-guard pour la détection de confusables à l'exécution dans les noms de paquets, les noms de domaine et les identifiants.

Fonctionnement

RaySpace projette des rayons parallèles à travers les contours des polices à 36 angles et capture cinq couches d'information par glyphe : nombre d'intersections, positions des intersections, angles d'intersection, distances de ping (épaisseur de trait à chaque intersection) et ping max (largeur de contre-forme entre les intersections). Cela produit une signature compacte par caractère et par police. Deux signatures sont comparées avec une distance L1 pondérée sur les cinq couches.

Un filtre en cascade à trois étapes rend la comparaison exhaustive réalisable :

1. Filtre de largeur d'avance (tolérance 15%) élimine les paires de largeurs différentes. Supprime 63% des candidats.
2. Comparaison de rayons (seuil 2.0, resserré à 1.0 pour les grandes paires d'écritures). Supprime encore 33%.
3. Seulement 3,3% des candidats survivent pour devenir des découvertes.

La banque de signatures (294 646+ entrées sur 245 polices ; plus avec --include-uppercase) est précalculée une fois. La découverte s'effectue ensuite par arithmétique mono-thread sur la banque, réalisant 52,6 millions de comparaisons en 31 minutes sans threads ouvriers ni GPU.

Démarrage rapide

npm install

# 1. Construire la banque de signatures de rayons (prérequis, ~24 min)
npx tsx scripts/build-signature-bank.ts

# 1b. Inclure les lettres majuscules latines A-Z (optionnel)
#     Par défaut la banque n'inclut que les points de code IDNA PVALID (minuscules,
#     chiffres, symboles). Utilisez --include-uppercase pour ajouter A-Z majuscules,
#     utile pour l'identification de polices et la comparaison visuelle de marques
#     où les formes des majuscules comptent. Le constructeur est repréable, donc
#     seuls les points de code supplémentaires sont calculés.
npx tsx scripts/build-signature-bank.ts --include-uppercase

# 1c. Inclure des plages arbitraires de points de code (optionnel)
npx tsx scripts/build-signature-bank.ts --extra-range=0041-005A

# 2. Découverte mono-caractère (22 581 caractères, 12 écritures, ~36 min)
npx tsx scripts/discover-singlechar-sdf.ts --scorer=ray

# 3. Découverte multi-caractère (bigrammes) (676 bigrammes, ~63 min)
npx tsx scripts/discover-multichar-sdf.ts --scorer=ray

# 4. Noter les confusables multi-caractères TR39 connus (~5 min)
npx tsx scripts/score-multichar-sdf.ts --scorer=ray

# Notation des paires confusables TR39
npx tsx scripts/build-index.ts          # Construire l'index (~160s, 11 370 PNG)
npx tsx scripts/score-all-pairs.ts      # Noter toutes les paires (~65s, 235 000 comparaisons)

# Découverte de nouveaux confusables
npx tsx scripts/build-candidates.ts          # Ensemble candidat (~23 000 caractères)
npx tsx scripts/build-index.ts --candidates  # Rendre les candidats (~40min, 89 000 PNG)
npx tsx scripts/score-candidates.ts          # Noter par rapport aux cibles latines (~15min, 2,9 millions de comparaisons)

# Extraire les découvertes les mieux notées des deux pipelines
npx tsx scripts/extract-discoveries.ts

Ce qui a été trouvé

Principales paires confusables (mono-caractère, distance moyenne < 0,10)

« Zéros » = polices où les contours produisent des signatures de rayons bit-identiques (distance 0,000). Le w latin / ԝ cyrillique est identique dans les 19 polices contenant les deux glyphes.

Percées inter-écritures (mono-caractère)

La codavie géorgienne (U+10FF) forme un anneau de confusables à quatre avec le o latin, le o cyrillique et l'omicron grec, tous en dessous d'une distance de 0,08.

Résultats clés multi-caractères

La découverte oy/uk cyrillique est le résultat le plus marquant : le bigramme latin « oy » est visuellement identique à la lettre digraphe cyrillique uk (ѹ) à une distance de 0,000 dans Helvetica et 0,0005 dans Arial Unicode MS.

Calibration des seuils

Trois niveaux d'exploitation recommandés :

• Strict (< 0,50): 138 paires mono-caractère, quasi aucun faux positif. Convient au blocage automatisé (enregistrement IDN, validation de noms de paquets) où les faux positifs ont un coût réel.
• Standard (< 1,00): 4 174 paires mono-caractère, bon équilibre couverture/précision. Convient au signalement et à la révision manuelle dans les outils de sécurité.
• Exploratoire (< 2,00): Ensemble complet des découvertes. Contient du bruit en haut de l'échelle mais utile pour la recherche, l'audit de polices et la construction d'ensembles d'entraînement.

Interrogation par police

Interrogez les paires confusables existant pour une police donnée. Utile pour les concepteurs de polices livrant une nouvelle police, les éditeurs de navigateurs évaluant un changement de police système, ou toute personne choisissant une police d'affichage pour des contextes sensibles à la sécurité comme les domaines IDN.

npx tsx scripts/query-font.ts --list-fonts                    # 218 polices dans les données de découverte
npx tsx scripts/query-font.ts "Arial"                         # Toutes les paires pour Arial (SSIM >= 0,7)
npx tsx scripts/query-font.ts "Arial" --threshold 0,8         # Haute confiance uniquement
npx tsx scripts/query-font.ts "Arial" --compare "Georgia"     # Différence entre deux polices par delta SSIM
npx tsx scripts/query-font.ts "Arial" --json                  # JSON pour traitement en aval

La correspondance du nom de police est insensible à la casse et partielle, donc « arial » correspond à Arial, Arial Black et Arial Unicode MS. Le mode comparaison trie par les plus grands écarts SSIM en premier, révélant exactement quelles paires s'améliorent ou se dégradent en changeant de police.

Nécessite les fichiers de découverte issus du pipeline de notation (gitignorés, à régénérer localement).

Sortie

Commités (CC-BY-4.0)

Générés (gitignorés, exécuter le pipeline pour régénérer)

Progression

• Validation TR39 (1 418 paires, 230 polices, pipeline SSIM)
• Découverte de nouveaux confusables (793 paires hautement notées parmi 23 317 candidats, SSIM)
• Analyse des confusables inter-écritures (12 écritures ICANN, 23,6 millions de paires, 563 découvertes, SSIM)
• Interrogation par police et comparaison de polices
• Scoreur vectoriel à cinq couches RaySpace (remplace SDF et SSIM pour la découverte)
• Découverte mono-caractère RaySpace (249 976 paires uniques, 245 polices, 12 écritures)
• Découverte multi-caractère RaySpace (2 524 275 paires bigrammes uniques, 245 polices)
• Découverte inter-écritures avec RaySpace (305% de paires en plus que SDF, sur-ensemble strict)
• Production de confusable-weights-v2.json avec enregistrements distributionnels par paire : moyenne, p50, p90, nombre de polices, nombre de zéros, fraction de zéros et niveau recommandé (strict/standard/exploratoire). Les distances RaySpace remplacent SSIM. 4 174 paires au seuil standard.
• Format de banque de signatures binaire (réduire le temps de chargement de 273 secondes à quelques secondes)
• Noter des polices arbitraires par chemin sans relancer le pipeline complet

Connexes

• namespace-guard (v0.16.0+) consomme confusable-weights.json pour l'évaluation mesurée du risque visuel via confusableDistance({ weights })
• REPORT.md : rapport technique complet du pipeline SSIM (12 sections, analyse par police, annexes)

Articles de blog

Écrits disponibles sur paultendo.github.io couvrant les découvertes et la méthodologie derrière ce projet :

Méthodologie et découvertes RaySpace :

• RaySpace : mesurer la similarité des glyphes par raycasting vectoriel des contours
• Des scanners CT aux caractères confusables : l'art antérieur derrière RaySpace
• Confusables multi-caractères : quand rn devient m
• 250 000 paires confusables. 102 qui comptent pour les noms de domaine.

Découvertes du pipeline SSIM :

• J'ai rendu 1 418 paires confusables Unicode dans 230 polices. La plupart ne sont pas visuellement confusables.
• 793 caractères Unicode ressemblent à des lettres latines mais ne sont pas (encore) dans confusables.txt
• 28 caractères CJK et Hangul ressemblent à des lettres latines
• 248 paires confusables inter-écritures qu'aucune norme ne couvre
• 148x plus rapide : reconstruction d'un pipeline d'analyse Unicode pour l'échelle inter-écritures
• Quand la similarité des formes ment : artefacts de rapport de taille dans la détection de confusables
• Le nouveau DDoS : les confusables Unicode ne trompent pas les LLM, mais ils peuvent quintupler votre facture API

Contexte

Articles couvrant le problème plus large qui a motivé ce projet :

• Un modèle de menace pour l'usurpation d'identifiant Unicode
• Rendre le risque Unicode mesurable
• Votre LLM lit les points de code Unicode, pas les glyphes. C'est une surface d'attaque.
• Qui la détection de confusables protège-t-elle réellement ?
• Unicode fournit une carte de confusables. Il en faut deux.
• confusables.txt et NFKC sont en désaccord sur 31 caractères

Licence

• Code (src/, scripts/) : MIT
• Données générées (data/output/) : CC-BY-4.0. Libre d'utilisation, de partage et d'adaptation pour tout usage, y compris commercial, avec attribution.
• Attribution : Paul Wood FRSA (@paultendo), confusable-vision