HEIF
Heist: libheif heap overflow + OpenAI SSO flaw gave access to internal
repos in 72 hours
Hacktron researchers chained a libheif heap buffer overflow in
Discourse’s image upload pipeline (via ImageMagick’s HEIC handling) with
an OpenAI SSO misconfiguration to achieve RCE on community.openai.com,
take over OpenAI employee ChatGPT/Codex accounts, and open a
proof-of-concept PR in OpenAI’s internal monorepo — all within 72 hours
of initial discovery. The broader HEIF
Heist campaign found the same class of libheif vulnerabilities
across Slack, Meta, GitHub Enterprise, Rails, Next.js, Astro and Gatsby.
Disclosure was coordinated and Discourse has patched and sandboxed
ImageMagick — patch self-hosted installs now:
./launcher rebuild app
The researchers note a clear capability jump between models: Opus 4.8
failed across multiple sessions to exploit with ASLR enabled; Opus 5
succeeded within hours of release. Their framing: AI is eliminating the
practical barrier that previously made operationalising memory
corruption expensive.
Active
campaign targeting Rust core team and popular crate owners
The Rust security team has issued a public warning about an ongoing
attack campaign targeting rust-lang members and owners of widely-used
crates. Attackers construct convincing fake companies — complete with
plausible LinkedIn presences — then reach out with job, project or
contract offers and use the resulting video calls to get targets to
install malware (a “missing audio codec”) or run clipboard-injected
commands. The goal appears to be compromising trusted crates.io accounts
to ship malware through the supply chain. Crate maintainers are advised
to be suspicious of cold outreach and to audit their MFA and login
history now.
Proofs and interop:
Valen, Verus and Bend
Three takes on making Rust-adjacent code provably correct or
seamlessly composable.
Valen. Evan Ovadia is pivoting his Vale language
into Valen, with the central goal of deep rustc interoperability: Valen
and Rust should call each other with shared generic instantiation,
memory safety, linear types, and Nick Smith’s group borrow checking. The
implementation hooks directly into rustc’s monomorphizer and LLVM
backend — when rustc encounters an empty stub for a Valen function,
Valen’s compiler takes over and produces the LLVM IR, then hands back
the list of Rust functions the Valen code calls. Very early, but this is
cross-language generics: a Rust generic instantiated with a Valen type
and vice versa.
Verus. Amazon Science on using the Dafny-inspired
verifier to prove systems code correct at compile time. Preconditions,
postconditions and loop invariants are written in a Rust-embedded spec
language and checked by SMT before the code runs. Includes a proved ring
buffer and is honest about where proof effort gets expensive.
Bend. A new systems language built around a
LAWS.bend file where developers declare invariants as
formal theorems that any AI (or human) writing code must prove before
shipping, verified by a Lean-style type checker that compiles in under a
second. Near-C single-core speed and automatic GPU parallelism, on an
affine dependent type theory. The pitch: “LAWS.bend is AGENTS.md backed
by proof.”
The deep
cost of emulating x86’s memory model on ARM
FEX-Emu’s exhaustive writeup on why emulating x86’s Total Store
Ordering on ARM’s weak ordering is genuinely hard. The LRCPC extension
family (ARMv8.3+) mostly solves the load side. Unaligned access carries
performance cliffs of up to 50% on Cortex, while Apple M1’s hardware TSO
toggle makes it nearly free. Split-lock emulation is the unsolved
correctness problem — FEX can tear data and can’t avoid it without
kernel or hardware support. Write-combine memory on PCIe GPUs can be up
to 816× worse in bandwidth, enough to run Hollow Knight: Silksong at
under 1 FPS. Standout finding: the Valve Steam Frame ships an unreleased
kernel patch that dramatically improves unaligned atomic performance on
Cortex-X4. Apple’s hardware TSO bit remains the only complete solution;
Qualcomm’s Oryon-3 has partial coherent cachelines but still no full
split-lock support.
Pre-Greek:
the substrate language fossilised in Ancient Greek
Before Greek-speaking Indo-Europeans arrived around 2000 BCE, a
different language — or family of languages — was spoken across Greece
and the Aegean, and its traces survive today. Linguists call it
“Pre-Greek”: words with non-IE phonological patterns (doubled
consonants, suffixes like -nth-, -ss-, -tt-), place names (Corinth,
Knossos, Athens, Parnassus, Hyacinthus), and key vocabulary for
indigenous flora, seafaring and religion that doesn’t derive from
Proto-Indo-European. The language may be related to Minoan — the only
undeciphered Aegean Bronze Age script — and the article is a good survey
of the evidence and what can and can’t be reconstructed.