| #!/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("<I", value & 0xFFFFFFFF) |
| |
| |
| def pack_f32(value: float) -> bytes: |
| return struct.pack("<f", value) |
| |
| |
| def emit_set_flags(ops: bytearray, flags: int) -> 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 |
