※ This post was written as of September 2026. New bypass methods may emerge, and it is unclear how long the current method will remain valid. I have heard that something was updated in October, but I am not certain about it. First and foremost, I am writing this to look back on my assumption that I could root a Galaxy device the same way as before.
Introduction
On the S24 I had been using for security assessments, the Wi‑Fi connection kept dropping repeatedly. After checking whether the problem reproduced on other devices connected to the same AP, and whether things worked normally on a different network, I was able to suspect a compatibility or configuration issue between the AP and the handset. I searched Reddit and XDA for similar cases and remedies and tried several measures, but the problem was not resolved, so in the end I updated to the latest AOS firmware.
I do not mainly do operations work, but I like computers, so I unconditionally liked new patches, and I happily went ahead with the firmware update at the thought of seeing a new UI. That complacency was my mistake, and Samsung’s researchers are, as expected, remarkable people.. Fortunately, thanks to a recently disclosed CVE, rooting was possible on the 2026/08 update with AOS16 and One UI 8.
(Contents)
- eFuse, the hardware-level downgrade prevention mechanism
- The bootloader’s signature verification scheme
- A brief explanation of a recent kernel vulnerability (CVE-2026-43499, known as GhostLock)
- A detailed explanation of CVE-2026-43499 is planned for a follow-up post
- Sharing the Frida error that occurs when the GC is CMC
1. Basic Components of Galaxy Firmware
| Category | Name | Primary Role |
|---|---|---|
| AP | Application Processor | The largest file, containing the core Android OS areas such as System, Vendor, Boot, and Recovery |
| BL | Bootloader | The area that checks the hardware and loads the OS at power-on (responsible for security verification) |
| CP | Core Processor | Modem and communication-related control software (LTE/5G, Wi-Fi, etc.) |
| CSC | Consumer Software Customization | Carrier/region-specific configuration data (wipes data on installation) |
| HOME_CSC | Home CSC | Used instead of CSC to update the firmware while preserving existing user data |
| This categorization is not merely a software distinction; it also reflects an actual physical chip distinction. |
- BL (Boot Loader) is the boot-stage firmware on the AP (Application Processor) chip
- CP (Core Processor) is the firmware for a processor separate from the AP
2. The Traditional Approach: OEM Unlocking and the Bootloader
To root a device, you first have to enable OEM Unlocking in the developer options, and that value is a state flag the bootloader refers to. The reason this value has to be changed is to flash an AP that removes the BL’s integrity verification and grants su privileges to Magisk.
The standard approach Google has defined in the official AOSP (Android Open Source Project) documentation
- The bootloader passes an
androidboot.flash.lockedvalue on the kernel command line. It is1when locked and0when unlocked. - If
androidboot.verifiedbootstate, which represents the Verified Boot (dm-verity) state, isorange(the user-unlocked state), the system uses that as the basis for settingro.boot.flash.lockedto0. - As of Android 12, these values are carried in the
bootconfigarea rather than on the kernel command line.
After checking this state, the bootloader decides whether an unsigned or tampered image is allowed to boot. Samsung devices are also based on this AOSP standard and are known to add their own Knox-related flags on top of it, and you can check those bits when entering download mode. [reference]
3. Why the Traditional Approach Is Blocked: Changes in One UI 8 and Galaxy Firmware
OneUi8
- The OEM Unlocking toggle itself was removed from developer mode
- To enter download mode you have to go into “Repair Mode” in Settings (annoying)
Galaxy Devices / Firmware
efuse (Update bit verification)
- An efuse (electronic Fuse) is a very small metal/polysilicon trace etched inside the SoC (AP chip) die. It is read by the Boot ROM, and if the Update bit is higher than the current one, it apparently burns one more (Knox Rollback Protection Fuses)
- If there is a firmware with the same Update bit and One UI 7 or lower, a rollback is possible, but there was no such case with the same Update bit as my firmware version ⇒ If you update without thinking, you can neither disable BL verification through the GUI nor downgrade One UI [reference]
Q. Can’t the bootloader binary be modified directly?
- Digital signature verification The bootloader image is signed with Samsung’s private key, and the Boot ROM decrypts it with the public key to perform integrity verification It would be possible if you knew Samsung’s private key. Nothing is known about the algorithm either.
4. A Brief Introduction to CVE-2026-43499 (GhostLock)
GhostLock is a use-after-free that occurs in the kernel’s futex/rtmutex PI (Priority Inheritance) path. The core of it is that FUTEX_CMP_REQUEUE_PI, an optimization path meant to avoid the thundering herd problem of condition variable broadcasts, reuses remove_waiter(), which was written on the assumption that “it only needs to clean up its own wait state.” As a result, another thread’s pi_blocked_on is left uncleaned and remains as a dangling pointer.
This UAF is exploited by re-occupying the dead slot on the kernel stack with a value of the attacker’s choosing (stack grooming) and then making the scheduler read that slot again. On success, a pipe fd turns into an arbitrary kernel physical R/W primitive, which is then used to patch the attacking process’s own cred to root, bypass SELinux, and install an su daemon.
Actual rooting tools
- https://xdaforums.com/t/i-made-a-one-click-rooting-tool-for-samsung-galaxy-devices-using-cve-2026-43499.4795400/
- https://github.com/BuSung-dev/Root-My-Galaxy
Mechanism (vulnerability/exploit)
A code-level deep dive — from the rtmutex structures to the cause of the bug, the PoC/exploit flow, and reproduction on Ubuntu — is planned for a separate post.
5. Actual Rooting Result
AOS kernel Version : 6.1.157-android-14-11
As shown above, I confirmed root privileges on the S24. Before I hit the update button again next time, I think I will need to find a rooting approach other than the existing Magisk. And for assessment work, a Galaxy without eFuse applied, or a different phone, would probably be better.
That said, the Frida setup procedure changed for AOS 16, and running a script on frida-server 17 caused a crash. When I asked Claude about it, the cause turned out to be the GC: it used to be CC (Concurrent Copying), but this device uses CMC (Concurrent Mark-Compact), and Frida does not properly keep up with this GC scheme. The process of finding the cause and fixing it is briefly summarized in section 6.
(Note) If you just want a quick fix, simply changing the GC setting back to CC should do it I went through the process of finding the cause, because I wanted to use Frida on CMC without touching the default settings.
6. Analyzing and Fixing the Frida 17 GC Crash
6.1 Finding the Basic Cause of the Crash
JNI DETECTED ERROR IN APPLICATION: JNI ERROR (app bug): jstring is an invalid
JNI transition frame reference ... in call to GetStringChars
signal 11 (SIGSEGV), fault addr 0x10
#00 art::ReferenceMapVisitor<...>::VisitFrame()+1652
#03 art::gc::collector::MarkCompact::ThreadFlipVisitor::Run(art::Thread*)
The same problem had already been reported (frida-java-bridge#387, frida#3805,#394) but had not yet been fixed.
6.1.1 Reading the tombstone and debugging
Since it was a native crash, I read the tombstone. It dies while reading 0x10, and there are GC-related functions in the trace.
signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x0000000000000010 (read)
x21 0000007246736c10 ...
backtrace:
#00 pc 00000000006367cc libart.so (art::ReferenceMapVisitor<...>::VisitFrame()+1652)
#03 pc 00000000005b71ec libart.so (art::gc::collector::MarkCompact::ThreadFlipVisitor::Run(art::Thread*)+104)
...
#40 pc 00000000002c2300 libart.so (art_quick_generic_jni_trampoline+144)
memory near x21:
0000007246736c10 12000119032f2888 ...
Disassembling VisitFrame showed code that walks ArtMethod ⇒ declaring_class_ ⇒ DexCache ⇒ DexFile in order, and x21 was the ArtMethod. Class::dex_cache_ was null, so it died reading 0 + 0x10.
Looking at memory near x21, there is 12000119032f2888, and examining the values related to this among Frida’s behaviors shows the following: at a malloc location there is the access_flags_ that a copy created by Frida holds, so we can tell that the error occurs while reading Frida’s ArtMethod copy.
| Offset | Field | Value | Meaning |
|---|---|---|---|
| +0 | declaring_class_ | 0x032f2888 | The address of the class this method belongs to |
| +4 | access_flags_ | 0x12000119 | 0x119 = public, static, final, native / 0x02000000 = kAccCompileDontBother / 0x10000000 = unidentified |
6.1.2 Summary: after the hook, the GC moved the class
- When you install a hook, Frida copies the original ArtMethod into malloc memory. At this point the copy’s
declaring_class_holds the correct class address. - Afterwards the CMC GC runs, compacts the heap, and moves the class object to a different address. The previous CC collector took care of ArtMethods found on the stack, whereas CMC finds the ArtMethods in the LinearAlloc region owned by ART and updates their class addresses in bulk.
- In the next stage of the same GC, while walking thread stacks, it encounters the copy (x21). It trusts the old address left in the copy as the class and reads it. That location no longer holds this class, so 0 comes out at the
dex_cache_slot, and it dies reading 0 + 0x10.
6.1.3 Two currently usable PRs
- frida-java-bridge#410: changes the allocation location of Frida’s copy to LinearAlloc so that it becomes a target of CMC’s updates. This seems to have better portability across the board.
- frida-java-bridge#413: installs a hook right after the GC has finalized the post-compaction addresses (at the end of
MarkCompact::CompactionPause) so that Frida’s copy gets updated as well. I did not notice PR 410 at first and tried fixing it myself for this device, but since it relies on non-exported symbols and on inferred logic, its portability across various firmwares probably is not good, so I do recommend patching with 410 instead.
References
- frida-java-bridge#387: Android 16 GC crash issue
- frida-java-bridge#394: an earlier fix attempt
- frida-java-bridge#410: a PR that fixes the same cause via LinearAlloc allocation
- frida-java-bridge#413: my PR
- frida-tools bridges: the bridge bundled and shipped with frida-tools
- frida#3805:
DecodeGcMasksOnlycrash (x86_64) - ART source:
runtime/thread.cc(ReferenceMapVisitor),runtime/gc/collector/mark_compact.cc(RunPhases,CompactionPause,VisitRoots)