From 041e5a311bc2ba82efdf1707d4d7ee36b0ae8c62 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Fri, 30 Oct 2026 15:04:54 -0600 Subject: [PATCH] [ot-layout] Collect glyph alternates without dangling references (#6482) hb_pair() preserves references to lvalue arguments. The alternate collection callbacks returned pairs referencing their own by-value parameters, so the next iterator stage read them after the call ended. Pass each AlternateSubst glyph directly to the collector helper, which already encodes its alternate index. This also keeps alternate_count keyed by the original glyph. Return a value pair for SingleSubst format 1, as the subsetting path already does. Cross-check collected maps against the per-glyph getter for four SourceSansPro lookups. The alternate and both SingleSubst format 1 cases fail on the previous code; the format 2 control passes. Testing: meson test -C build (292 passed; check-symbols skipped on macOS). All five alternate API tests also pass under ASan and UBSan, with stack-use-after-return detection enabled. Discovered by Anthropic's OSS Scanner, as vulnerability ANT-2026-N7S3EYU4. Assisted-by: OpenAI Codex --- src/OT/Layout/GSUB/AlternateSet.hh | 7 ++-- src/OT/Layout/GSUB/SingleSubstFormat1.hh | 2 +- test/api/test-ot-alternates.c | 46 ++++++++++++++++++++++++ 3 files changed, 50 insertions(+), 5 deletions(-) diff --git a/src/OT/Layout/GSUB/AlternateSet.hh b/src/OT/Layout/GSUB/AlternateSet.hh index 9420f3460..747ae6727 100644 --- a/src/OT/Layout/GSUB/AlternateSet.hh +++ b/src/OT/Layout/GSUB/AlternateSet.hh @@ -103,10 +103,9 @@ struct AlternateSet hb_map_t *alternate_count /* IN/OUT */, hb_map_t *alternate_glyphs /* IN/OUT */) const { - + hb_enumerate (alternates) - | hb_map ([gid] (hb_pair_t _) { return hb_pair (gid + (_.first << 24), _.second); }) - | hb_apply ([&] (const hb_pair_t &p) -> void - { _hb_collect_glyph_alternates_add (p.first, p.second, + + hb_iter (alternates) + | hb_apply ([&] (hb_codepoint_t alternate) -> void + { _hb_collect_glyph_alternates_add (gid, alternate, alternate_count, alternate_glyphs); }) ; } diff --git a/src/OT/Layout/GSUB/SingleSubstFormat1.hh b/src/OT/Layout/GSUB/SingleSubstFormat1.hh index 9683dc4f6..d072a66f7 100644 --- a/src/OT/Layout/GSUB/SingleSubstFormat1.hh +++ b/src/OT/Layout/GSUB/SingleSubstFormat1.hh @@ -192,7 +192,7 @@ struct SingleSubstFormat1_3 hb_codepoint_t mask = get_mask (); + hb_iter (this+coverage) - | hb_map ([d, mask] (hb_codepoint_t g) { return hb_pair (g, (g + d) & mask); }) + | hb_map ([d, mask] (hb_codepoint_t g) { return hb_codepoint_pair_t (g, (g + d) & mask); }) | hb_apply ([&] (const hb_pair_t &p) -> void { _hb_collect_glyph_alternates_add (p.first, p.second, alternate_count, alternate_glyphs); }) diff --git a/test/api/test-ot-alternates.c b/test/api/test-ot-alternates.c index 4db6b1558..daa27a3a7 100644 --- a/test/api/test-ot-alternates.c +++ b/test/api/test-ot-alternates.c @@ -44,10 +44,56 @@ test_ot_layout_lookup_get_glyph_alternates (void) hb_face_destroy (face); } +/* Collect one lookup and cross-check every entry against the per-glyph getter. */ +static void +test_ot_layout_lookup_collect_glyph_alternates (gconstpointer user_data) +{ + hb_face_t *face = hb_test_open_font_file ("fonts/SourceSansPro-Regular.otf"); + unsigned lookup_index = GPOINTER_TO_UINT (user_data); + hb_map_t *alternate_count = hb_map_create (); + hb_map_t *alternate_glyphs = hb_map_create (); + unsigned glyph_count = hb_face_get_glyph_count (face); + unsigned collected = 0; + unsigned covered = 0; + + hb_ot_layout_lookup_collect_glyph_alternates (face, lookup_index, + alternate_count, alternate_glyphs); + + for (hb_codepoint_t gid = 0; gid < glyph_count; gid++) + { + hb_codepoint_t alternates[16]; + unsigned count = 16; + unsigned total = hb_ot_layout_lookup_get_glyph_alternates (face, lookup_index, gid, 0, &count, alternates); + + g_assert_cmpuint (total, ==, count); + if (!count) + { + g_assert_false (hb_map_has (alternate_count, gid)); + continue; + } + g_assert_cmpuint (count, ==, hb_map_get (alternate_count, gid)); + for (unsigned i = 0; i < count; i++) + g_assert_cmpuint (alternates[i], ==, hb_map_get (alternate_glyphs, gid + (i << 24))); + collected += count; + covered++; + } + + g_assert_cmpuint (collected, ==, hb_map_get_population (alternate_glyphs)); + g_assert_cmpuint (covered, ==, hb_map_get_population (alternate_count)); + + hb_map_destroy (alternate_count); + hb_map_destroy (alternate_glyphs); + hb_face_destroy (face); +} + int main (int argc, char **argv) { hb_test_init (&argc, &argv); hb_test_add (test_ot_layout_lookup_get_glyph_alternates); + hb_test_add_data_flavor (GUINT_TO_POINTER (0), "single-format2", test_ot_layout_lookup_collect_glyph_alternates); + hb_test_add_data_flavor (GUINT_TO_POINTER (1), "alternate", test_ot_layout_lookup_collect_glyph_alternates); + hb_test_add_data_flavor (GUINT_TO_POINTER (2), "single-format1", test_ot_layout_lookup_collect_glyph_alternates); + hb_test_add_data_flavor (GUINT_TO_POINTER (18), "single-format1-many", test_ot_layout_lookup_collect_glyph_alternates); return hb_test_run (); }