#!/usr/bin/env python3 import hashlib import math import os import shlex import struct import sys HB_FUZZING_EXTENDED_MAGIC = b"HBSUBFZ2" HB_SUBSET_SETS_GLYPH_INDEX = 0 HB_SUBSET_SETS_UNICODE = 1 HB_SUBSET_SETS_DROP_TABLE_TAG = 3 HB_SUBSET_SETS_NAME_ID = 4 HB_SUBSET_SETS_NAME_LANG_ID = 5 HB_SUBSET_SETS_LAYOUT_FEATURE_TAG = 6 HB_SUBSET_SETS_LAYOUT_SCRIPT_TAG = 7 HB_FUZZING_OP_SET_FLAGS = 1 HB_FUZZING_OP_KEEP_EVERYTHING = 2 HB_FUZZING_OP_SET_CLEAR = 3 HB_FUZZING_OP_SET_INVERT = 4 HB_FUZZING_OP_SET_ADD_RANGES = 5 HB_FUZZING_OP_SET_DEL_RANGES = 6 HB_FUZZING_OP_TEXT_ADD = 7 HB_FUZZING_OP_TEXT_DEL = 8 HB_FUZZING_OP_AXIS_PIN_ALL_TO_DEFAULT = 9 HB_FUZZING_OP_AXIS_SET = 10 HB_FUZZING_AXIS_PIN_TO_DEFAULT = 0 HB_FUZZING_AXIS_SET_RANGE = 1 FLAG_BITS = { "--no-hinting": 0x00000001, "--retain-gids": 0x00000002, "--desubroutinize": 0x00000004, "--name-legacy": 0x00000008, "--set-overlaps-flag": 0x00000010, "--passthrough-tables": 0x00000020, "--notdef-outline": 0x00000040, "--glyph-names": 0x00000080, "--no-prune-unicode-ranges": 0x00000100, "--no-layout-closure": 0x00000200, "--optimize": 0x00000400, "--no-bidi-closure": 0x00000800, "--iftb-requirements": 0x00001000, "--retain-num-glyphs": 0x00002000, "--downgrade-cff2": 0x00004000, } class UserError(Exception): pass def fail(msg: str) -> None: raise UserError(msg) def pack_u32(value: int) -> bytes: return struct.pack(" bytes: return struct.pack(" None: ops.append(HB_FUZZING_OP_SET_FLAGS) ops += pack_u32(flags) def emit_keep_everything(ops: bytearray) -> None: ops.append(HB_FUZZING_OP_KEEP_EVERYTHING) def emit_set_clear(ops: bytearray, set_type: int) -> None: ops += bytes((HB_FUZZING_OP_SET_CLEAR, set_type)) def emit_set_invert(ops: bytearray, set_type: int) -> None: ops += bytes((HB_FUZZING_OP_SET_INVERT, set_type)) def emit_set_ranges(ops: bytearray, opcode: int, set_type: int, ranges: list[tuple[int, int]]) -> None: ops += bytes((opcode, set_type)) ops += pack_u32(len(ranges)) for start, end in ranges: ops += pack_u32(start) ops += pack_u32(end) def emit_text(ops: bytearray, opcode: int, codepoints: list[int]) -> None: ops.append(opcode) ops += pack_u32(len(codepoints)) for cp in codepoints: ops += pack_u32(cp) def emit_pin_all_axes_to_default(ops: bytearray) -> None: ops.append(HB_FUZZING_OP_AXIS_PIN_ALL_TO_DEFAULT) def emit_axis_records(ops: bytearray, records: list[tuple[int, int, float, float, float]]) -> None: ops.append(HB_FUZZING_OP_AXIS_SET) ops += pack_u32(len(records)) for tag, mode, minimum, middle, maximum in records: ops += pack_u32(tag) ops.append(mode) ops += pack_f32(minimum) ops += pack_f32(middle) ops += pack_f32(maximum) def parse_decimal_ranges(value: str) -> list[tuple[int, int]]: ranges: list[tuple[int, int]] = [] for chunk in value.replace(" ", ",").split(","): if not chunk: continue if chunk == "*": fail("Internal error: wildcard range should be handled before parsing.") if "-" in chunk: start_text, end_text = chunk.split("-", 1) try: start = int(start_text, 10) end = int(end_text, 10) except ValueError: fail(f"Failed parsing decimal range '{chunk}'.") else: try: start = end = int(chunk, 10) except ValueError: fail(f"Failed parsing decimal value '{chunk}'.") if start < 0 or end < start: fail(f"Invalid decimal range '{chunk}'.") ranges.append((start, end)) return ranges def parse_hex_ranges(value: str) -> list[tuple[int, int]]: ranges: list[tuple[int, int]] = [] for chunk in value.replace(" ", ",").split(","): if not chunk: continue if chunk == "*": fail("Internal error: wildcard range should be handled before parsing.") if "-" in chunk: start_text, end_text = chunk.split("-", 1) try: start = int(start_text, 16) end = int(end_text, 16) except ValueError: fail(f"Failed parsing unicode range '{chunk}'.") else: try: start = end = int(chunk, 16) except ValueError: fail(f"Failed parsing unicode value '{chunk}'.") if start < 0 or end < start or end > 0x10FFFF: fail(f"Invalid unicode range '{chunk}'.") ranges.append((start, end)) return ranges def parse_tags(value: str) -> list[tuple[int, int]]: tags: list[tuple[int, int]] = [] for chunk in value.replace(",", " ").split(): if chunk == "*": fail("Internal error: wildcard tag set should be handled before parsing.") if len(chunk) > 4: fail(f"Tag '{chunk}' is longer than 4 bytes.") try: tag_value = int.from_bytes(chunk.ljust(4, " ").encode("ascii"), byteorder="big") except UnicodeEncodeError: fail(f"Tag '{chunk}' is not ASCII.") tags.append((tag_value, tag_value)) return tags def parse_text_codepoints(value: str) -> list[int]: codepoints = [ord(ch) for ch in value] for cp in codepoints: if cp < 0 or cp > 0x10FFFF: fail(f"Invalid codepoint value {cp}.") return codepoints def parse_tag_value(tag_text: str, kind: str) -> int: if len(tag_text) > 4: fail(f"{kind} '{tag_text}' is longer than 4 bytes.") try: return int.from_bytes(tag_text.ljust(4, " ").encode("ascii"), byteorder="big") except UnicodeEncodeError: fail(f"{kind} '{tag_text}' is not ASCII.") def parse_axis_number(text: str) -> float: try: return float(text) except ValueError: fail(f"Failed parsing axis value '{text}'.") def parse_axis_range(value: str) -> tuple[int, float, float, float]: if value == "drop": return HB_FUZZING_AXIS_PIN_TO_DEFAULT, 0.0, 0.0, 0.0 parts = value.split(":") if len(parts) == 1: v = parse_axis_number(parts[0]) return HB_FUZZING_AXIS_SET_RANGE, v, v, v if len(parts) == 2: minimum = math.nan if parts[0] == "" else parse_axis_number(parts[0]) maximum = math.nan if parts[1] == "" else parse_axis_number(parts[1]) return HB_FUZZING_AXIS_SET_RANGE, minimum, math.nan, maximum if len(parts) == 3: minimum = math.nan if parts[0] == "" else parse_axis_number(parts[0]) middle = math.nan if parts[1] == "" else parse_axis_number(parts[1]) maximum = math.nan if parts[2] == "" else parse_axis_number(parts[2]) return HB_FUZZING_AXIS_SET_RANGE, minimum, middle, maximum fail(f"Failed parsing axis range '{value}'.") def parse_variations(value: str) -> tuple[bool, list[tuple[int, int, float, float, float]]]: pin_all = False records: list[tuple[int, int, float, float, float]] = [] for item in value.replace(" ", ",").split(","): if not item: continue if "=" not in item: fail(f"Unsupported variation item '{item}'. Expected tag=value.") tag_text, axis_value_text = item.split("=", 1) if tag_text == "*": if axis_value_text != "drop": fail("Only *=drop is supported for wildcard axis pinning.") pin_all = True continue tag = parse_tag_value(tag_text, "Axis tag") mode, minimum, middle, maximum = parse_axis_range(axis_value_text) records.append((tag, mode, minimum, middle, maximum)) return pin_all, records def add_set_option(ops: bytearray, set_type: int, modifier: str, value: str, parser) -> None: if modifier == "": emit_set_clear(ops, set_type) if value == "*": if modifier == "-": emit_set_clear(ops, set_type) else: emit_set_clear(ops, set_type) emit_set_invert(ops, set_type) return ranges = parser(value) if ranges: emit_set_ranges( ops, HB_FUZZING_OP_SET_DEL_RANGES if modifier == "-" else HB_FUZZING_OP_SET_ADD_RANGES, set_type, ranges, ) def parse_output_arg(argv: list[str], usage_text: str) -> tuple[str, list[str]]: out = "" args = argv[1:] while args: arg = args[0] if arg == "-o": if len(args) < 2: print(usage_text, end="", file=sys.stderr) raise SystemExit(1) out = args[1] args = args[2:] continue if arg in ("-h", "--help"): print(usage_text, end="") raise SystemExit(0) if arg == "--": args = args[1:] break break return out, args def read_text_file(path: str) -> list[int]: with open(path, "r", encoding="utf-8") as fp: return parse_text_codepoints(fp.read()) def read_range_file(path: str, parser) -> list[tuple[int, int]]: ranges = [] with open(path, "r", encoding="utf-8") as fp: for line in fp: line = line.split("#", 1)[0].strip() if line: ranges.extend(parser(line)) return ranges def resolve_seed_output_path(font_path: str, font_bytes: bytes, out_path: str, default_suffix: str) -> tuple[str, str]: digest = hashlib.sha1(font_bytes).hexdigest() default_name = digest + default_suffix default_dir = os.path.join(os.path.dirname(__file__), "fonts") if not out_path: display_path = os.path.join(default_dir, default_name) return display_path, os.path.abspath(display_path) if out_path.endswith(os.sep): display_path = os.path.join(out_path, default_name) return display_path, os.path.abspath(display_path) abs_out_path = os.path.abspath(out_path) if os.path.isdir(abs_out_path): if os.path.isabs(out_path): display_path = os.path.join(out_path, default_name) else: display_path = os.path.join(out_path, default_name) return display_path, os.path.join(abs_out_path, default_name) return out_path, abs_out_path def format_leading_comment(argv: list[str]) -> bytes: return ("$ " + " ".join(shlex.quote(arg) for arg in argv) + "\n").encode("utf-8") def write_seed_file(font_file: str, out_path: str, ops: bytearray, default_suffix: str = ".susbset-seed", leading_comment: bytes = b"") -> str: font_path = os.path.abspath(font_file) if not os.path.isfile(font_path): fail(f"Font file not found: '{font_path}'.") with open(font_path, "rb") as fp: font_bytes = fp.read() display_path, seed_path = resolve_seed_output_path(font_path, font_bytes, out_path, default_suffix) parent = os.path.dirname(seed_path) if parent: os.makedirs(parent, exist_ok=True) with open(seed_path, "wb") as fp: fp.write(leading_comment) fp.write(font_bytes) fp.write(ops) fp.write(pack_u32(len(ops))) fp.write(HB_FUZZING_EXTENDED_MAGIC) return display_path def print_recorded_seed_path(seed_path: str) -> None: print(seed_path) def main_with_user_errors(main_fn, argv: list[str]) -> int: try: return main_fn(argv) except UserError as e: print(e, file=sys.stderr) return 1