disarm 0.12.0-aarch64-linux → 0.14.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6327afe7a1127ae46ad3a134207a80b5ca397b6b06ca51ec0caa3dd915f4f40b
-  data.tar.gz: 80cb1882dd5a8a604d6eb1c3ed8d29612c2bde7832a9edd0349fdac5c3be4bd3
+  metadata.gz: 8626868ff11d6125f1768356c699416cbf5013b97bcdb75f02e53cefce7168d7
+  data.tar.gz: 236bf3cebcfdb91dd2d55a6fb4f2a510488550b37007dd4668df0b767781c523
 SHA512:
-  metadata.gz: 96891160cb88546242ef3cd5c488d4e81f2afd1dfcd05571967aba69dd10dfd1b6fcbc66e8e9deb1f0b9e0777ed703f16d4a5f9e1c3be73cb939af1a3a45aea7
-  data.tar.gz: 78cf97d16dc84cb43e387221245ed80fe159af2d49fa0a4c8f0bb15aa3b27d7d9f45473ec5d6711bd538e01a48e10a62b54a4f6b914a91b10c95cc19258f3347
+  metadata.gz: 3b1068de3adb50799dbb3c9bf408664d69c095c99f558ac6e8153a61d8a36db1088e2cd1613a3123aacef1ee222321f642ba5939991acd6f944dcd6b2979a548
+  data.tar.gz: ce875b46faa853663866f8357e8d3ad9ca36bd6608f9e839f3b7667a7ac549165e95d818a2eb99611b8605cdc677755a8901ed2205c762be714cb5a8d379a09d

data/lib/disarm/version.rb

@@ -2,5 +2,5 @@
 
 module Disarm
   # Kept in lockstep with the Rust crate / Python package version.
-  VERSION = "0.12.0"
+  VERSION = "0.14.0"
 end

data/lib/disarm.rb

@@ -54,8 +54,18 @@ module Disarm
     end
 
     # Fold cross-script confusables toward `target:` (:latin or :cyrillic).
-    def normalize_confusables(text, target: :latin)
-      translate_errors { _normalize_confusables(text, target.to_s) }
+    #
+    # `digit_policy:` selects how non-Latin DIGITS fold (#561). `:numeric` (default)
+    # sends them to the ASCII digit — `०` becomes `0` — which is right for prose, where
+    # a Devanagari zero really is a zero. `:tr39` uses upstream's targets, which send
+    # most of them to a Latin letter (`०` → `o`; three of the 45 rows fold to `.` or
+    # to the two characters `rn` instead); that is what an identifier *skeleton*
+    # wants, since its only job is to make two confusable identifiers collide. The two
+    # differ on 45 rows and agree everywhere else. Scoped to `target: :latin` — the
+    # override rows are generated from the Latin table and carry TR39's Latin-script
+    # targets, so with `target: :cyrillic` it is a no-op.
+    def normalize_confusables(text, target: :latin, digit_policy: :numeric)
+      translate_errors { _normalize_confusables(text, target.to_s, digit_policy.to_s) }
     end
 
     # Whether `text` contains a character confusable with `target:` (:latin or
@@ -151,14 +161,78 @@ module Disarm
       translate_errors { _fold_case(text) }
     end
 
+    # Whether `text` is a stable identity key under case folding — whether
+    # `fold_case` and `String#downcase` agree on it (#619). A false result means
+    # some other string folds to the same value, so a table keyed on this one can
+    # collide: "groß.txt" and "gross.txt" are the pair node-tar collided on
+    # (CVE-2026-23950). It is a fact about the string, not an accusation.
+    def case_fold_stable?(text)
+      translate_errors { _is_case_fold_stable?(text) }
+    end
+
+    # Which of `values` are the same name under `key` (#620).
+    #
+    # Every other disarm detector is a single-string predicate, and a collision is
+    # not a property of a single string — "groß.txt" is an ordinary German filename,
+    # and "аdmin" is only a problem next to "admin". This is the set-shaped question
+    # node-tar's PathReservations guard failed to ask (CVE-2026-23950).
+    #
+    # `key:` is one of "fold_case", "search_key", "catalog_key", "canonicalize",
+    # "canonicalize_strict", "normalize_confusables". There is no default: a stronger
+    # key finds more collisions, including ones nobody attacked ("search_key" collides
+    # "Muller" with "Müller"), so the choice is the policy.
+    #
+    # A group is reported only when two or more DISTINCT inputs share a key; the same
+    # name twice is the same name twice. `lang:` reaches "search_key" and
+    # "catalog_key" and is ignored by the rest.
+    #
+    # Returns an array of hashes with `:key`, `:values` (distinct, first-appearance
+    # order) and `:indices` (every position, ascending — not parallel to `:values`).
+    def find_key_collisions(values, key:, lang: nil)
+      translate_errors { _find_key_collisions(values, key.to_s, lang&.to_s) }
+        .map { |k, vals, idx| { key: k, values: vals, indices: idx } }
+    end
+
     # Whether the hostname looks like a mixed-script / confusable / bidi-reorder
     # IDN spoof. Flags a mixed-script label, a Latin confusable, or a
-    # bidi-direction conflict (see #bidi_conflict?, the "BiDi Swap" precondition).
+    # bidi-direction conflict (see #bidi_conflict?, the "BiDi Swap" precondition),
+    # or a UAX #9 bidi control character (#603 — the RLO spoof, which the direction
+    # conflict is blind to).
     # A false result asserts nothing was *found*, not that the host is safe.
     def suspicious_hostname?(host)
       translate_errors { _suspicious_hostname?(host) }
     end
 
+    # The full hostname homoglyph analysis (#549) behind #suspicious_hostname?,
+    # as a Hash. `:suspicious` is a maximally conservative screen (an any-character
+    # confusable test flags essentially every non-Latin host), not a precise verdict;
+    # branch on the granular signals plus your own policy. Keys: :suspicious,
+    # :scripts, :mixed_script, :has_confusables, :bidi_conflict, :bidi_control,
+    # :has_invisible, :cross_label_script,
+    # :label_scripts, :whole_script_confusable, :label_whole_script_confusable,
+    # :canonical. `:whole_script_confusable` is a graded signal, NOT folded into
+    # `:suspicious` (see #545).
+    def analyze_hostname(host, contractions: false)
+      suspicious, scripts, mixed_script, has_confusables, bidi_conflict,
+        bidi_control, has_invisible, cross_label_script, label_scripts,
+        whole_script_confusable, label_whole_script_confusable, canonical =
+        translate_errors { _analyze_hostname(host, contractions) }
+      {
+        suspicious:,
+        scripts:,
+        mixed_script:,
+        has_confusables:,
+        bidi_conflict:,
+        bidi_control:,
+        has_invisible:,
+        cross_label_script:,
+        label_scripts:,
+        whole_script_confusable:,
+        label_whole_script_confusable:,
+        canonical:,
+      }
+    end
+
     # Apply a Unicode normalization form. `form:` is :nfc (default), :nfd,
     # :nfkc, or :nfkd (a Symbol or String; case-insensitive).
     def normalize(text, form: :nfc)
@@ -287,6 +361,41 @@ module Disarm
       end
     end
 
+    # Every upstream confusable source the bundled table does not fold, as a sorted
+    # Array of single-character Strings (#563). An Array rather than a Set, matching
+    # `list_scripts` and avoiding a `require "set"` in the gem entrypoint.
+    #
+    # Read as exposure, not as a score — this is where an adaptive attacker goes once
+    # the mapped sources stop working. It includes five ASCII characters ("%", "0",
+    # "1", "I", "m"): TR39 is a skeleton transform, and disarm deliberately does not
+    # apply those rows because folding a legitimate "m" to "rn" corrupts prose.
+    def unmapped_confusables(target: :latin)
+      translate_errors { _unmapped_confusables(target.to_s) }
+    end
+
+    # Confusable sources in `text` the bundled table does not fold, as an Array of
+    # `{ char:, offset: }` hashes in order of appearance — the confusables analogue of
+    # `find_untranslatable`, with the same byte-offset convention (#563).
+    def find_unmapped_confusables(text, target: :latin)
+      translate_errors do
+        _find_unmapped_confusables(text, target.to_s)
+          .map { |ch, offset| { char: ch, offset: offset } }
+      end
+    end
+
+    # ML/NLP normalization: NFKC → emoji→text → transliterate → strip accents →
+    # [case fold] → strip control → strip zero-width → collapse whitespace.
+    #
+    # `fold_case:` defaults to true. Pass false in front of a CASED model — folding is
+    # destructive, cannot be undone downstream, and an uncased evaluation harness cannot
+    # measure what it cost. It restores case, not diacritics: accents are still stripped.
+    #
+    # Folds no confusables, so it is not a homoglyph defence at any setting; compose it
+    # after `normalize_confusables` when a model needs both.
+    def ml_normalize(text, lang: nil, emoji_style: "cldr", fold_case: true)
+      translate_errors { _ml_normalize(text, lang&.to_s, emoji_style.to_s, fold_case) }
+    end
+
     # The Unicode scripts present in `text`, in first-appearance order
     # (Common/Inherited excluded), as stable UCD identifiers (e.g. "Latin").
     def detect_scripts(text)
@@ -329,6 +438,13 @@ module Disarm
       translate_errors { _script_info(name.to_s) }
     end
 
+    # The Unicode `confusables.txt` release the bundled confusable tables were folded
+    # from, e.g. "17.0.0". Not a Unicode version for the library as a whole — the
+    # case-folding and width tables track different releases (see docs/provenance.md).
+    def confusables_version
+      translate_errors { _confusables_version }
+    end
+
     # Every script disarm knows, as stable UCD script identifiers (includes
     # "Common"/"Inherited"), sorted by name.
     def list_scripts

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: disarm
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.14.0
 platform: aarch64-linux
 authors:
 - Richard Quinn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-15 00:00:00.000000000 Z
+date: 2026-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake