hashbro
126 lines
4.1 KiB
Python
126 lines
4.1 KiB
Python
"""Patch campaign / channel id embedded in type-0x01 and core/business dylibs."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
import secrets
|
|
|
|
# C-string keys immediately before the channel value in type-0x01 __cstring.
|
|
CHANNEL_ANCHOR = b"u\x00d\x00f\x00s\x00c\x00"
|
|
CHANNEL_LEN = 32
|
|
# New channel ids: lowercase alphanumeric. Embedded originals remain hex.
|
|
_CHANNEL_RE = re.compile(rb"^[0-9a-z]{32}$")
|
|
_CHANNEL_HEX_RE = re.compile(rb"^[0-9a-f]{32}$")
|
|
|
|
|
|
def gen_channel_id() -> str:
|
|
"""32 lowercase hex chars (alphanumeric subset; pack-safe)."""
|
|
return secrets.token_hex(16)
|
|
|
|
|
|
def validate_channel_id(value: str, *, name: str = "--channel-id") -> str:
|
|
if not isinstance(value, str) or not _CHANNEL_RE.fullmatch(value.encode("ascii")):
|
|
raise SystemExit(
|
|
f"{name} must be exactly {CHANNEL_LEN} lowercase [0-9a-z] chars "
|
|
f"(got {value!r})"
|
|
)
|
|
return value
|
|
|
|
|
|
def find_channel_offsets(data: bytes, *, expect_old: bytes | None = None) -> list[int]:
|
|
"""Return offsets of the 32-byte channel value after CHANNEL_ANCHOR."""
|
|
offsets: list[int] = []
|
|
start = 0
|
|
while True:
|
|
index = data.find(CHANNEL_ANCHOR, start)
|
|
if index < 0:
|
|
break
|
|
value_at = index + len(CHANNEL_ANCHOR)
|
|
value = data[value_at : value_at + CHANNEL_LEN]
|
|
if (
|
|
len(value) == CHANNEL_LEN
|
|
and _CHANNEL_HEX_RE.fullmatch(value)
|
|
and data[value_at + CHANNEL_LEN : value_at + CHANNEL_LEN + 1] == b"\x00"
|
|
):
|
|
if expect_old is None or value == expect_old:
|
|
offsets.append(value_at)
|
|
start = index + 1
|
|
return offsets
|
|
|
|
|
|
def patch_channel_in_dylib(
|
|
data: bytes,
|
|
new_channel: str,
|
|
*,
|
|
old_channel: str | None = None,
|
|
expect_hits: int = 1,
|
|
label: str = "dylib",
|
|
) -> bytes:
|
|
"""In-place replace type-0x01 channel C-string (must stay {CHANNEL_LEN} bytes)."""
|
|
new_channel = validate_channel_id(new_channel, name="channel")
|
|
new_b = new_channel.encode("ascii")
|
|
old_b = old_channel.encode("ascii") if old_channel else None
|
|
if old_b is not None:
|
|
validate_channel_id(old_channel, name="old channel")
|
|
|
|
offsets = find_channel_offsets(data, expect_old=old_b)
|
|
if len(offsets) != expect_hits:
|
|
raise SystemExit(
|
|
f"{label}: channel anchor hits={len(offsets)} (want {expect_hits}). "
|
|
"Secondary payload layout may have changed; re-adapt _channel_patch."
|
|
)
|
|
|
|
buf = bytearray(data)
|
|
for offset in offsets:
|
|
buf[offset : offset + CHANNEL_LEN] = new_b
|
|
return bytes(buf)
|
|
|
|
|
|
def find_plain_channel_offsets(data: bytes, channel: bytes) -> list[int]:
|
|
"""Return offsets of null-terminated plain ASCII channel C-strings."""
|
|
if len(channel) != CHANNEL_LEN or not _CHANNEL_HEX_RE.fullmatch(channel):
|
|
raise ValueError("channel must be 32 lowercase hex bytes")
|
|
needle = channel + b"\x00"
|
|
offsets: list[int] = []
|
|
start = 0
|
|
while True:
|
|
index = data.find(needle, start)
|
|
if index < 0:
|
|
break
|
|
offsets.append(index)
|
|
start = index + CHANNEL_LEN
|
|
return offsets
|
|
|
|
|
|
def patch_plain_channel_in_dylib(
|
|
data: bytes,
|
|
new_channel: str,
|
|
*,
|
|
old_channel: str,
|
|
expect_hits: int,
|
|
label: str = "dylib",
|
|
) -> bytes:
|
|
"""Replace plain C-string channel (core / business plugins; no type-0x01 anchor).
|
|
|
|
FAT arm64+arm64e binaries typically embed the same string once per slice
|
|
(expect_hits=2). Length must stay exactly 32 ASCII hex chars.
|
|
"""
|
|
new_channel = validate_channel_id(new_channel, name="channel")
|
|
old_channel = validate_channel_id(old_channel, name="old channel")
|
|
if new_channel == old_channel:
|
|
return data
|
|
|
|
old_b = old_channel.encode("ascii")
|
|
new_b = new_channel.encode("ascii")
|
|
offsets = find_plain_channel_offsets(data, old_b)
|
|
if len(offsets) != expect_hits:
|
|
raise SystemExit(
|
|
f"{label}: plain channel hits={len(offsets)} (want {expect_hits} for "
|
|
f"{old_channel}). Core/plugin layout may have changed."
|
|
)
|
|
|
|
buf = bytearray(data)
|
|
for offset in offsets:
|
|
buf[offset : offset + CHANNEL_LEN] = new_b
|
|
return bytes(buf)
|