What Is Inside an IPA Before You Install It

An .ipa file is a ZIP archive holding one iOS app bundle — and most of what matters about the app is written down before a line of its code ever runs. Rename the file to .zip and any unzip tool will open it: a Payload folder, one .app bundle, and inside it the app’s executable, its resources, its frameworks and its signature. Two property lists carry the story. Info.plist is the app’s identity card — name, bundle ID, versions, the oldest iOS it installs on, and the exact words it will show when it asks for your camera or your location. embedded.mobileprovision is the provisioning profile: who may sign the code, which devices may run it, when it expires, and which capabilities it is allowed to claim. This article teaches you to read both, plus the frameworks and the signature hashes beside them — and the IPA Analyzer reads them for you, in your browser, without uploading the file.

What an .ipa is — a ZIP with one Payload

Every iOS app you have ever installed arrived as an .ipa, whether it came from the App Store, TestFlight, or a developer’s build folder. The format has no mystery to it: it is a ZIP archive, and its layout is fixed by convention. At the top sits a folder called Payload, and inside it exactly one directory ending in .app — the application bundle. Everything the app needs to run lives in that bundle: the Mach-O executable, the Info.plist, the asset catalog, the localised strings, any frameworks it links, and the _CodeSignature directory that holds the signature’s hash inventory. App Store packages add a few siblings — SwiftSupport, Symbols, Watch — but the Payload bundle is the app, and it is the same shape in every distribution channel.

The ZIP part matters because it makes the package inspectable without any Apple tooling. You do not need Xcode, a Mac, or an Apple ID to look inside: any unzip tool opens the archive, and the interesting files are property lists — Apple’s key-value format, stored either as XML you can read or as a compact binary form that needs a reader. That is the whole premise of the analyser on this site: the file is already an open book, and the only work is reading the two property lists, the framework directory, and the signature hashes, all locally. Nothing about the package is encrypted — the executable is code-signed, not scrambled — so what you see when you open it is what iOS sees when it decides whether the app may install and launch.

Info.plist: the app’s identity card

The first file iOS reads is Info.plist, and it answers the questions you would ask about any app before trusting it. CFBundleIdentifier is the bundle ID — the reverse-domain name, such as com.sysosx.ipa-analyzer-demo, that identifies the app for updates, for the keychain, and for the provisioning profile. Two version fields travel together and mean different things: CFBundleShortVersionString is the marketing version people see (“1.2.3”), while CFBundleVersion is the build number developers track (“42”) — the build is what increments on every upload, so two builds can share a marketing version and still be different software. MinimumOSVersion states the oldest iOS the app claims to install on, and UIDeviceFamily says which hardware it is built for, as numbers: 1 is iPhone, 2 is iPad.

The rest of the identity card is about behaviour before launch. CFBundleExecutable names the Mach-O binary iOS will run; LSRequiresIPhoneOS confirms the bundle is an iOS app at all; UIRequiredDeviceCapabilities lists the hardware the app refuses to run without, such as arm64; UIBackgroundModes lists the background work it may do, such as fetching content or receiving remote notifications; CFBundleURLTypes lists the URL schemes the app answers to — the custom links other apps can use to open it. The build metadata rides along too: DTPlatformName, DTSDKName and DTXcodeBuild record which platform, SDK and Xcode build produced the binary, which is how you tell a build made last week from one made two years ago without asking the developer.

The permission prompts you will see

The most consequential keys in Info.plist are the ones users actually meet: the NS*UsageDescription strings. Every time an iOS app asks for a protected resource — the camera, the photo library, the microphone, location, contacts, calendars — iOS shows the app’s own description string in the prompt, and the app cannot change that text at runtime. NSCameraUsageDescription is the sentence under “Allow Demo App to access your camera?”; NSLocationWhenInUseUsageDescription is the one under the location prompt. These strings are not decoration. They are the app’s stated reason, written by the developer, shown verbatim by the system — and reading them before installing is the cheapest privacy review there is.

The rule that makes them worth reading is strict: on modern iOS, a permission with no usage description string cannot be requested at all, and Apple rejects the build at review time if a protected API is used without one. So a permission table with four entries — camera, photo library, location while in use, microphone — tells you exactly which prompts the app is prepared to show, and a missing entry tells you the app cannot ask for that thing even if its code tries. The demo app on this site declares exactly those four, with plain-language reasons: the camera scans documents, the photo library attaches pictures, location shows nearby places while you use the app, the microphone records voice notes. A torch app with a microphone description, or a calculator with a location description, would stand out in the same table — the prompt text is the place where overreach is written down in the developer’s own words.

The provisioning profile, in five questions

Every iOS app ships with a second property list, embedded.mobileprovision, and it answers a different set of questions — not what the app is, but whether Apple authorises it to run. Apple’s own technote on the subject, TN3125, describes the profile as the answer to five questions. Who may sign the code: the DeveloperCertificates property holds the certificates of each developer allowed to sign code covered by the profile, and the build must be signed by one of them. What they may sign: one App ID, encoded in Entitlements as application-identifier — a team prefix plus the bundle ID. Where it may run: ProvisionedDevices lists the device identifiers allowed to install it; App Store profiles have no device list at all, because that build is uploaded, never installed directly.

When it may run: every profile carries an ExpirationDate, typically not more than a year out, and only seven days on a free Personal Team — an expired profile means the app will not launch, however recently it was installed. How it may be entitled: the Entitlements property is an allowlist of the capabilities the app may claim — push notifications (aps-environment), keychain groups, App Groups, associated domains — and every entitlement the app claims must be in it. Two details matter when you read one. First, the file is a property list wrapped in a CMS signature, so reading it means unwrapping that signature — on a Mac, security cms -D does it; the analyser on this site does the same unwrapping in the browser. Second, since iOS 15 the profile also carries a DER-Encoded-Profile that is the new source of truth, while the XML plist stays readable; the analyser notes when one is present and shows the values from the XML plist in the same file.

Frameworks and the file list: what ships inside

Beyond the two property lists, the bundle is a manifest of what the app is made of. The Frameworks directory holds the dynamic frameworks the app links — often third-party libraries such as Alamofire or SnapKit, sometimes the developer’s own shared code. Each framework is itself a small bundle, and its presence tells you what the app depends on without decompiling anything: a networking library, a database, an analytics SDK. The full file list adds the rest: the asset catalog (Assets.car) with the app’s images, the icon files, the localised .lproj strings, app extensions (.appex) such as widgets or share sheets, and the executable itself. A file list is also where size goes: the total is the download you are accepting, and a single framework larger than the app’s own code is a fact worth noticing.

The file list is most useful when read against the signature. _CodeSignature/CodeResources is a property list that records a hash for every file in the bundle — hash is SHA-1, hash2 is SHA-256 — so iOS can verify that nothing changed after signing. The analyser cross-checks the two: every app file should appear in CodeResources, and any file that does not is reported rather than silently assumed. That check is about integrity, not safety — a correctly signed malicious file is still correctly signed — but it is the check that catches a package that was tampered with after it left the signer, or a bundle that was assembled by hand and never properly signed at all.

What the IPA Analyzer shows — and what it cannot

Drop the demo .ipa on the IPA Analyzer and the page reads the package the way this article does: the app summary (Demo App, 1.2.3, build 42, minimum iOS 17.0, iPhone and iPad), the four permission texts verbatim, the entitlements from the profile (production push, a keychain group, get-task-allow false — a release build, not a debuggable one), the two linked frameworks, the provisioning profile with its 2027-11-21 expiry, the signing certificate with its SHA-256 fingerprint, and the CodeResources coverage — eight files hashed, eight listed. The file never leaves your device: the ZIP, the plists and the CMS wrapper are all parsed in the page, and the three CSV exports (file list, permissions, frameworks) are generated locally as downloads.

What it cannot do matters just as much. It does not verify the code signature cryptographically — it reads the hash inventory and the certificates, but it does not re-check the hashes against the files or the signature against Apple’s servers, so an expired or revoked profile is reported from its own dates, not from a live lookup. It does not parse the Mach-O binary’s embedded code-signature superblob; the certificates shown come from the provisioning profile’s DeveloperCertificates, which are the signing identities the profile authorises. It does not decompile code, execute the app, or judge whether the app is malware — a clean result here means “nothing declared looks wrong”, never a safety certificate. For the Android sibling of this check, the APK Analyzer reads Android packages the same way, and to open any plist by hand — binary or XML — the Plist Workbench reads and edits both formats.

The demo app’s Info.plist, as XML

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
  <dict>
    <key>CFBundleDisplayName</key>
    <string>Demo App</string>
    <key>CFBundleName</key>
    <string>DemoApp</string>
    <key>CFBundleIdentifier</key>
    <string>com.sysosx.ipa-analyzer-demo</string>
    <key>CFBundleShortVersionString</key>
    <string>1.2.3</string>
    <key>CFBundleVersion</key>
    <string>42</string>
    <key>CFBundleExecutable</key>
    <string>DemoApp</string>
    <key>CFBundlePackageType</key>
    <string>APPL</string>
    <key>MinimumOSVersion</key>
    <string>17.0</string>
    <key>UIDeviceFamily</key>
    <array>
      <integer>1</integer>
      <integer>2</integer>
    </array>
    <key>LSRequiresIPhoneOS</key>
    <true/>
    <key>NSCameraUsageDescription</key>
    <string>Demo App uses the camera to scan documents.</string>
    <key>NSPhotoLibraryUsageDescription</key>
    <string>Demo App accesses your photo library so you can attach pictures.</string>
  </dict>
</plist>

Sources

Frequently asked questions

Can I open an .ipa without a Mac or Xcode?

Yes. An .ipa is a ZIP archive: rename it to .zip and any unzip tool opens it, and the Info.plist inside is either XML you can read directly or a binary plist that needs a reader — the Plist Workbench on this site reads both, and the IPA Analyzer reads the whole package at once. The only file that needs unwrapping is embedded.mobileprovision, a property list inside a CMS signature, which the analyser unwraps in the browser.

Why does the profile expiry matter if the app already installed?

Because iOS checks the profile every time the app launches, not just at install time. A development or ad-hoc profile typically expires within a year — seven days on a free Personal Team — and when it does, the app stops launching even though nothing about the app itself changed. That is the most common reason a sideloaded or beta app suddenly refuses to open, and the expiry date is printed in the profile for exactly that reason.

What does get-task-allow false mean?

It means the build is not debuggable: the entitlement that allows a debugger to attach to the process is switched off, which is what a release build should carry. A build with get-task-allow true can be inspected and modified while it runs, so it should never be the build you install from an untrusted source — and it is one of the first rows worth checking in the entitlements table.