mrkeyoor.comAsk

DrWhax/unfairplaytested 17 Nov 2026commit d750308

unfairplay review

Our UnfairPlay source build passed in 30 seconds and all 7 recorded Go tests passed, but the CLI smoke run stopped before an app-decryption task.

  • README install 33 s
  • README usage failed
7/7tests passed
  • Install 17 s
  • Build 30 s
Dev Toolsevaluationupdated 17 Nov 2026
+25 / 4dstars / 7d

UnfairPlay is a Go command that uses a private enrollment model from a Mac to decrypt personalized iOS app packages. It lets authorized researchers inspect apps they acquired, while downloading, patching and signing remain separate tasks.

Verdict

Our UnfairPlay source build passed in 30 seconds and all 7 recorded Go tests passed, but the CLI smoke run stopped before an app-decryption task. Use it if you control an enrolled Mac and need private analysis of lawfully acquired IPAs. Skip it if you need native Windows decryption or expect conversion to guarantee a working Mac app.

UnfairPlay infographic: decrypt personalized iOS apps for private analysis, plus our test result and who it suits
Tested 17 November 2026: the README command failed. Before that: 7 of 7 source tests passed; go install took 33 s.

We ran it

Lab card: what happened when we ran unfairplay
Lab card from our sandbox run
Screenshot of unfairplay (github.com/DrWhax/unfairplay)
github.com/DrWhax/unfairplay
Install✓ · 17s11 packages
Build✓ · 30s
Tests✓ · 25s7 passed · 0 failed of 7 (go test)
Repo245 files~75,353 lines of source · 4.6 MB · 2 CI workflows

Answers from our run

Does unfairplay build from source?

Dependencies installed in 17 seconds (11 packages), and the build succeeded in 30 seconds. We cloned commit d750308 into a clean Debian container with 3 CPUs and no project-specific setup.

Do unfairplay's tests pass?

Yes. The project's own test command finished in 25 seconds and reported 7 passed, 0 failed (go test).

Who should not use unfairplay?

Users without an enrolled Mac: the documented collection workflow starts there, even when later work moves to Linux.

What are the alternatives to unfairplay?

fairplay-decrypt, frida-ios-dump. Our UnfairPlay source build passed in 30 seconds and all 7 recorded Go tests passed, but the CLI smoke run stopped before an app-decryption task.

Setup4/5In our 2026-11-17 run it installed in 33 s and its command responded; the README gave no task we could run as written.Editor’s note: Source installation and build passed; enrollment recovery and app decryption were not reproduced in a supported Mac setup.
Docs4/5The README has an install section (“Build”) and a usage section (“Usage”); we did not run its quickstart ourselves.Editor’s note: The README explains enrollment, privacy and conversion boundaries; the smoke runner failed to select a usage example, and the full workflow was not reproduced.
Community4/5Last push on 2026-11-16, 1,229 stars and maintainers answered or closed 9 of the 10 most-discussed issues we sampled.Editor’s note: Sampled issues contain specific maintainer replies and user retests; the sample does not measure adoption or ongoing support capacity.
Maturity2/5Latest release v0.4.0 on 2026-11-16 (pre-1.0), repository created 2026-10-25 and its test suite passed in our sandbox (7 of 7 passed).Editor’s note: The source tests passed and recovery changes have user confirmations; production reliability and broad app compatibility were not measured.

How we score

Discussed on

  1. hnFairPlay Has Been Cracked4 points

Who it’s for

App researchers who control a matching Mac App Store enrollment and want reusable offline decryption.
Developers analyzing or preserving lawfully acquired iOS apps and able to handle private models securely.
Experienced users who can distinguish a decrypted executable from a signed, working app.

Who it’s NOT for

Users without an enrolled Mac: the documented collection workflow starts there, even when later work moves to Linux.
Users who need native Windows decryption: it remains disabled pending equivalent private-file permission checks.
Anyone expecting universal Mac app compatibility: conversion can lose service entitlements and does not launch-test the result.
Anyone expecting ordinary decrypted output to be anonymous: account licenses and purchaser metadata remain unless redaction is requested.

Setup reality

Our sandbox run at d750308 on 2026-11-17 installed successfully in 17 seconds with 11 dependencies recorded, built in 30 seconds and passed all 7 recorded Go tests in 25 seconds. The source-run configuration was 3 CPUs, 8 GB RAM and image label golang:1.24-bookworm; actual runtime versions require the raw toolchain logs.

Useful decryption needs a Mac App Store enrollment and matching personalized app material. The app-based setup uses an app installed and opened through the native store; a complete supported bundle can replace a separate validation IPA. Downloading uses another tool, such as ipatool. Keep captures, snapshots and saved models private.

The separate CLI smoke run reached version and help, but its usage-example selection failed before a decryption task. macOS and Linux decryption are documented; v0.4.0 adds WSL instructions while native Windows remains disabled. Mac conversion and a successful app launch are different outcomes.

DrWhax/unfairplay recovers a private Mac enrollment model to decrypt personalized iOS app packages, while a separate downloader obtains the apps. Use it for authorized app analysis when you control the Mac and account. Skip it if you need a native Windows decryptor or expect every converted iOS app to run on a Mac. Our source build passed and all 7 recorded Go tests passed; enrollment recovery and app operation require their own evidence.

UnfairPlay decrypts apps from a matching Mac enrollment

UnfairPlay separates decryption from downloading: its README says it neither logs in to Apple nor buys or downloads apps. An IPA is the package containing an iOS app. The reusable model comes from the FairPlay enrollment created by an Apple Account using the native Mac App Store. It can decrypt other IPAs personalized for that enrollment, rather than requiring a new model for each app. Project documentation

The app-based setup starts with an iPhone or iPad app genuinely installed through the Mac App Store and opened once. A complete supported installed bundle can provide the validation archive itself. Supplying a matching downloaded IPA is optional. That distinction removes a download from this setup path, but it doesn't remove the enrollment requirement. For someone studying several apps from one account, reusing the private model is the practical attraction.

The documented workflow also offers an enrollment snapshot: export the enrolled Mac's state, then select an IPA during setup on macOS or Linux. A snapshot contains broader enrollment state than a saved app-validated model. Treat these as different artifacts with different jobs. The snapshot captures inputs; setup authenticates a selected route and processes the complete IPA before saving the reusable model. Snapshot documentation

Choose DrWhax's Go repository, not an older namesake

The GitHub repository for this review is DrWhax/unfairplay, the standalone Go project, not subdiox/UnFairPlay or its C relatives. The older project's README requires macOS 11.2.3 or below. It also supplies a gcc command. Applying that requirement to DrWhax's tool would send a new reader toward the wrong machine and instructions. Older C repository, DrWhax documentation

GitHub's public API recorded the last push on 2026-11-16, and the sampled tracker includes specific recovery retests from users. That combination shows recent development and an actual feedback loop. The latest-release endpoint returned v0.4.0, published on 2026-11-16. Its enrollment-snapshot instructions also update the Windows discussion below. These are dated project facts, rather than an adoption or compatibility score. Repository facts, v0.4.0 release

What people use unfairplay for

Reported uses include opening Wikipedia and Dollarwise in vphone, modifying Kindle's page turning, and recovering enrollment from troublesome captures. The reports reach different milestones, so the outcome column matters more than the app name.

Who used it Task and reported outcome
Dark Wire Labs Downloaded with ipatool, decrypted with UnfairPlay, and reported Wikipedia and Dollarwise opening in a jailbroken virtual iPhone. vphone account
Nick Farina, @nfarina Reported using 6.1 Sol to patch Kindle's swipe detection and animation, then re-signing with his developer account. X posts
peinniku Confirmed that commit 589ece1 decrypted the older bili-inter main executable and that the resulting app installed and ran. Issue #3
testcases2026 Reported recovery completing on both control-app captures from a migrated multi-account enrollment without local patches. Issue #4
NalCol Confirmed setup and decrypt working at commit 19a53bb after class-precursor failures on build 26B123. Issue #21
missuo/unfairplay-bot Documents a private Telegram bot and HTTP service combining ipatool downloads, UnfairPlay decryption and expiring download links. Bot repository

Dark Wire Labs supplies the clearest reported path from download to launch. Its environment was a fresh, jailbroken research VM with SSH access. UnfairPlay avoided a jailbroken phone for enrollment recovery, while that particular installation destination was still jailbroken. Those details answer different questions and both belong in an honest description of the workflow.

Farina's account is useful for a different reason. The desired change was specific: Kindle's swipe handling and page-turn animation. In the reply to a question about signed apps, he said he re-signed with his developer account. Decryption exposed code for modification; signing remained another operation. The supplied Reddit posts repeat the no-jailbreak and Mac-compatibility headlines, rather than adding comparable runtime reports. The YouTube and Bilibili extracts concern unrelated material and contribute no project demonstration.

What happened when we ran it

Our sandbox installed UnfairPlay in 17 seconds, built it in 30 seconds and completed the Go test step in 25 seconds, with 7 passed and 0 failed of 7. This source run used commit d750308 on 2026-11-17, with 3 CPUs, 8 GB RAM and the recorded image label golang:1.24-bookworm.

Source-run step Recorded result What it tells you
Install Succeeded in 17 seconds; 11 dependencies recorded The recorded dependency setup completed
Build Succeeded in 30 seconds The source build completed in this sandbox
Tests Succeeded in 25 seconds; 7 passed, 0 failed of 7 The recorded Go test command passed
Repository scan 245 files, about 75,353 source lines, 4.6 MB checked out This describes the measured checkout
Project signals 2 CI workflow files; no Dockerfile or tests directory detected File-layout signals, not an app compatibility result

The absence of a directory named tests is not a contradiction of the passing Go test result. The scanner and test runner recorded different things. The image label identifies the configured container image; actual runtime and operating-system versions require the raw toolchain logs. These measurements make source setup look manageable for a developer, while leaving the Mac enrollment work as the consequential setup decision.

A separate CLI smoke run at d7503082a59e on the same date cloned and installed the command in an unprivileged container. Its version command exited successfully and printed unfairplay version dev; help also exited successfully and listed commands including collect and conversion. The run used 2 CPUs and 4 GB RAM, rather than the source-run configuration above.

The smoke runner's usage step failed with the recorded message "no runnable unfairplay command in the README's usage/examples sections". It stopped before a real decryption task. The README read for this review does contain setup and decrypt examples, so that runner result describes its attempt to select an example, rather than proving the documentation has none. Teardown completed successfully.

Where people get stuck: enrollment checks can pass before recovery fails

Issue #4 reports recovery failing for two apps even though the capture and doctor checks were green. Passing those preliminary checks was therefore insufficient for those captures. The useful resolution is the later user retest: testcases2026 reported both captures completing without local patches after the missing-block and caller-continuation work reached main. Issue #4

Reported obstacle What changed Evidence of resolution
Migrated multi-account enrollment, #4 Missing blocks and caller-continuation work reached main User confirmed both control captures recovered without local patches
Older bili-inter executable, #3 589ece1 handled legacy __stub_helper structure peinniku confirmed the main executable decrypted and the app installed and ran
Unknown sinf-entry, then account-entry block, #16 Reporter tried the direct-enrollment branch ilyasaftr confirmed end-to-end success at 19a53bb on the original platform
Class-precursor failure on 26B123, #21 SIDB parsing changed during branch development NalCol confirmed setup and decrypt at 19a53bb
Unsupported SIDB sizes, #19 Maintainer replaced inferred flat geometry with native tree parsing ilyasaftr reported success at 19a53bb; the separate larger-container report has a different evidence trail

The older-app report is especially instructive. A recent build worked, but the older main executable failed an ARM64 instruction audit. The maintainer explained that lazy-bind offsets in a legacy __stub_helper section were being counted as instructions. After the structural change, peinniku reported a working main executable and app, then reported a small extension still failing. A single IPA can contain several executable images, so success for the main binary is a narrower result than success for everything inside it. Issue #3 diagnostics and retest

Issue #19 also warns against improvising setup inputs. One capture came from an unpacked IPA passed as an installed app. The maintainer explained that this did not supply the native Mac App Store license required for that control and requested an app genuinely installed and opened through the store. Merely widening accepted SIDB sizes would not solve that input problem. Match the installed app, account and enrollment before treating a parser patch as the next action. Issue #19

For a new report, follow the project's disclosure guidance: include the UnfairPlay version, macOS build and a redacted error. Keep app identities, private paths, hardware identifiers and enrollment files out of the public ticket. The error identifies where the process stopped; attaching the secrets it was processing is unnecessary. Reporting guidance

Privacy defaults require an explicit redaction choice

Ordinary decrypted output retains account-identifying licenses and metadata unless redaction is requested. The README describes --strip-account-data as removing SC_Info members and the Apple ID and purchaser fields from iTunesMetadata.plist. That makes the flag a deliberate output choice for authorized collaboration, rather than a default you can assume has already happened. Output behavior

Keep capture files and saved models private, with encrypted backups as the project instructs. An enrollment snapshot warrants particular care because it contains hardware identity and broader enrollment state. The documented snapshot export writes a mode-0600 file, refuses to overwrite an existing snapshot, and restores ownership to the invoking user when run through sudo. These file-handling rules explain why moving the workflow between operating systems involves more than compiling a binary.

The bot project makes another operating choice explicit: it documents queued tasks, separate decryption concurrency, account-data stripping and signed expiring links. A team building such a service also owns an App Store downloader session and a private model, each serving a different purpose. The wrapper's controls are claims about that wrapper; they should not be read as defaults supplied by the standalone CLI. Bot design

unfairplay vs fairplay-decrypt and frida-ios-dump

The deciding difference is where you can obtain the decryption material: UnfairPlay starts with a Mac enrollment, while the alternatives below use a jailbroken device. Choose around the device you control and the workflow you need, before comparing command syntax. fairplay-decrypt obtains its credential from a supported jailbroken device. frida-ios-dump pulls a decrypted IPA from a jailbroken device.

Option Evidence-backed distinction Pick it when
DrWhax/unfairplay Recovers a reusable model from an enrolled Mac You control the matching Mac enrollment and want repeated offline decryption
EthanArbuckle/fairplay-decrypt ONE Jailbreak describes credential extraction from a supported jailbroken device, followed by offline desktop decryption Your available starting point is a supported jailbroken device
AloneMonkey/frida-ios-dump Its repository describes pulling a decrypted IPA from a jailbroken device; ONE Jailbreak groups it with on-device dumpers You already maintain a jailbreak research environment
Redistributed decrypted IPAs Participants in #30 say distrust of strangers' IPAs motivates decrypting their own downloads Assess provenance before accepting somebody else's output

The credential-versus-Mac distinction is described in ONE Jailbreak's comparison, with the alternatives' identities checked against fairplay-decrypt and frida-ios-dump. The redistribution concern is attributed to participants in issue #30. A downloader such as ipatool is a companion to these workflows, so replacing UnfairPlay with a downloader alone leaves the decryption job undone.

What the other reviews get wrong

ONE Jailbreak's October article describes the project as being in the v0.1.0 range and presents a matching downloaded IPA as part of setup. The current documentation supports setup from a complete installed app without that separate download. GitHub's latest-release endpoint returned v0.4.0 on this review's research date, so the October version description belongs to an earlier snapshot. October article, setup documentation, current release

The early DrWhax post said offline decryption could run on Windows. Later documentation in issue #30 disabled native Windows decryption pending equivalent private-file permission checks. The v0.4.0 release now documents following the Linux workflow in WSL and keeping the snapshot in the WSL home directory. The precise correction is that native Windows remains disabled, while WSL now has upstream instructions. Early post, Windows question, v0.4.0 instructions

Ryan Merket's LinkedIn headline says opted-out iOS apps now run on Apple silicon Macs. The converter documentation gives a narrower promise: it retargets and signs compatible inputs, then reports runtime_verified=false because it has not launched the result. Missing iOS APIs, hardware, services or app checks can still prevent operation. A signed conversion is a useful artifact; an app launch is the separate result to ask for. Social headline, converter documentation

The historical README's supported-build claim also needs its date attached. Issue #10 documents recovery failing on 26B118 at 41f064b despite that claim. A later commenter on 26B123 reported success after cafd14a. Those are different reports on different builds; neither becomes a blanket statement about every enrollment on current main. Issue #10

Questions people ask

UnfairPlay decrypts personalized IPAs using enrollment recovered from a Mac, without requiring a jailbroken iPhone for that recovery. It still needs lawfully acquired apps and an account and devices you control. Project description

What is UnfairPlay, and does it decrypt IPAs without a jailbreak?

Yes, its documented Mac-enrollment workflow avoids a jailbroken phone. It produces a private reusable model for IPAs personalized for that enrollment. Downloading and installing the resulting app are separate parts of the process. Dark Wire Labs used a jailbroken vphone VM as its installation destination. Documentation, reported vphone workflow

Which GitHub repository is the DrWhax UnfairPlay project?

Use github.com/DrWhax/unfairplay for the Go program reviewed here. The similarly named subdiox/UnFairPlay repository contains the older C tool, whose operating-system requirements belong to that project. Checking the owner is the quickest way to avoid following the wrong instructions. DrWhax documentation, namesake repository

Can UnfairPlay run opted-out iOS apps on Apple silicon Macs?

It documents a compatibility converter, rather than a promise that every app runs. The decrypted-IPA converter uses native codesign and changes loader and bundle metadata. Original account entitlements, push notifications, app groups, keychain groups and iCloud access are not preserved. Choose based on what the particular app needs. Conversion behavior

How can a signed iOS app be patched and re-signed after decryption?

Farina reports decrypting Kindle, changing its binary and re-signing with his developer account. His answer to the signing question identifies that final signing step explicitly. UnfairPlay supplies the decryption stage in this account; the patching and developer signing are additional work. Farina's post and reply

Can I use UnfairPlay on Windows through WSL?

The v0.4.0 release documents the Linux workflow in WSL, with the snapshot stored in the WSL home directory so Unix permissions apply. Native Windows decryption remains disabled. This is newer guidance than the unanswered WSL question in the supplied issue extract. Release instructions, issue #30

Can enrollment be extracted from an iPhone instead of a Mac?

The documented UnfairPlay collection path starts on an enrolled Mac. Issue #30 asks about using an iPhone, but its supplied replies do not provide an iPhone-enrollment procedure for this tool. A link to a different project's claims does not change UnfairPlay's documented starting point. Issue #30

Can I decrypt an IPA using a model file without permanent setup?

Yes, a saved model can be passed explicitly with --model. In #30, kopyl supplied a decrypt command using that option, and Infinitay acknowledged it solved the portability question. You still need a model matching the IPA's enrollment; pointing at a file does not create enrollment. Issue #30 exchange

Why does recovery fail even when doctor reports the capture ready or the platform supported?

Issue #4 demonstrates that preliminary checks can pass before recovery encounters an unsupported execution path. That report later received a successful retest. Issue #16 similarly moved from a sinf-entry failure to an account-entry failure before ilyasaftr confirmed success at 19a53bb. Record the actual failure phase and commit. Issue #4, issue #16

Why does an older app build fail decryption when the latest version works?

In peinniku's report, legacy __stub_helper data was miscounted as invalid ARM64 instructions. The maintainer changed its structural audit in 589ece1, and the reporter confirmed the main executable worked. That diagnosis belongs to this reported case, rather than every possible older-app failure. Issue #3

How do I resolve unsupported SIDB container sizes and class-precursor errors?

The sampled fixes replaced inferred flat SIDB geometry with native tree parsing. NalCol confirmed setup and decrypt at 19a53bb after class-precursor failures. Issue #19 separately shows why a genuine installed Mac App Store app matters to the app-based control. Start by matching the error and input path to the specific report. Issue #21, issue #19

How do I fix the unknown-block recovery failure on macOS build 26B118?

Issue #10 records a maintainer-proposed reference-binary route, followed by the replacement recovery branch. Its positive retest comes from bradleyCPA on 26B123 after cafd14a, rather than the original 26B118 reporter. Use the current documented setup path and report a redacted error if that enrollment still fails. Issue #10 history

How do I resolve the missing-model memory error on build 25G229?

Issue #14 records a missing data page and a reporter's reference-binary workaround that then reached a block-budget failure. The thread later closed after the replacement algorithm merged. Follow current setup instructions rather than copying a workaround for the old evaluator without checking which implementation you are running. Issue #14

What we have not tested yet

We have not reproduced Mac enrollment recovery, decrypted a licensed IPA, patched Kindle or launched a converted app in our lab. Our evidence covers source checks and CLI smoke behavior. The pack's usage step stopped before an app task, and it supplies no screenshot records, known-answer app questions or decryption throughput benchmark. The source-run timings therefore cannot tell you how fast a large IPA decrypts or how much memory that operation uses.

Recovery success, plaintext verification, signing success and runtime success must stay separate. The README allows a recovered model with plaintext_verified=false when an image lacks pre-encryption hashes. Its available hash checks establish consistency with embedded hashes, rather than Apple CMS signature trust or a malware assessment. Our review does not supply a security audit, a broad compatibility rate or independent confirmation of Farina's patch or the bot's deployment.

Some historical cases also lack final user confirmation. The small extension in #3, the separate 7180-byte capture in #19, and the original 26B118 report in #10 have no final successful retest in these extracts. Issues #9 and #17 closed after the branch merge without a supplied reporter success. Issue #14 has a historical workaround, rather than a final retest of the replacement. These gaps prevent counting closed tickets as a compatibility matrix. #3, #19, #10, #9, #17, #14

We have not exercised WSL, portable snapshots, the disassembler integrations or a competing decryptor. For your first evaluation, use one lawfully acquired app with matching enrollment, keep the model private, and record decryption, plaintext-check status, signing and actual launch separately. The result worth keeping is the one that answers your intended task.

Alternatives

ProjectWhat it isPick it when
fairplay-decryptAn alternative offline decryption path described with credential extraction from a supported jailbroken device.Pick this instead when your starting point is a supported jailbroken device rather than a Mac enrollment.
frida-ios-dumpPulls a decrypted IPA from a jailbroken device.Pick this instead when you already operate a jailbreak research environment and want that device-based workflow.

What people are saying

  1. [velocity-scout] DrWhax/unfairplay

Sources

  1. unfairplay module - github.com/DrWhax/unfairplay - Go Packages
  2. From an encrypted App Store app to a running app on vphone | Dark Wire Labs
  3. decrypt fails on older app build (3.20.1) while latest build of same app decrypts fine
  4. Recovery diverges identically for two different apps on 26A434 — account_entry CFG reaches an unpopulated dispatch slot
  5. Latest research branch problem
  6. [Question] Is it possible to use UnfairPlay on Windows via WSL?
  7. UnfairPlay v0.4.0 release
  8. GitHub repository facts

More dev tools reviews