iOS Messaging Apps: iMessage, WhatsApp, Signal, Telegram
Where iMessage, WhatsApp, Signal and Telegram keep their data on an iPhone, what each acquisition level reaches, time formats and deleted messages.
Messages are the first thing most investigators want from an iPhone, and the answer to "can we get them?" depends almost entirely on the app. Apple's own Messages app stores iMessage and SMS in a database that reaches every backup. WhatsApp keeps a plain SQLite database that also reaches a backup. Telegram encrypts a local cache of what is mostly server-side data. Signal encrypts everything with a key held in the keychain and refuses to be backed up at all.
This guide compares the four in the order you will usually meet them, explains what each acquisition level reaches, lists the system-wide traces that survive when an app's own data does not, and ends with how to merge everything into one defensible conversation timeline.
The four messengers at a glance
| App | Main store | Encrypted at rest by the app | In an iTunes / Finder backup | Minimum level | Time format |
|---|---|---|---|---|---|
| Messages (iMessage, SMS, RCS) | sms.db | No (iOS data protection only) | Yes | Unencrypted backup | Cocoa, nanoseconds |
| ChatStorage.sqlite | No | Yes | Unencrypted backup | Cocoa, seconds | |
| Telegram | postbox db_sqlite | Yes (SQLCipher, key in .tempkeyEncrypted) | Do not count on it | Full file system | Unix, seconds |
| Signal | signal.sqlite | Yes (SQLCipher, key in keychain) | No | Full file system with keychain | Unix, milliseconds |
"Encrypted at rest by the app" means an extra layer on top of iOS data protection. Every file on an iPhone is encrypted by the operating system; the question is whether the app adds its own key that a file system extraction does not automatically unlock.
Where third-party apps keep their data
Apple's Messages lives in /private/var/mobile/Library/SMS/. Third-party messengers live in containers:
- A data container per app under
/private/var/mobile/Containers/Data/Application/<UUID>/. - One or more app group containers under
/private/var/mobile/Containers/Shared/AppGroup/<UUID>/, shared between the app and its extensions. WhatsApp, Signal and Telegram all keep their main databases here, because the notification and share extensions need them.
UUIDs differ per device and change on reinstall. Map them with the hidden .com.apple.mobile_container_manager.metadata.plist in each container, whose MCMMetadataIdentifier names the bundle or group. In a backup, the equivalent is the domain name in Manifest.db: AppDomain-<bundle ID> for data containers and AppDomainGroup-<group ID> for groups.
Before analysing, list which messaging apps are installed and which were removed, using the sources on the installed apps page. An app that was deleted before seizure takes its containers with it, but not its traces elsewhere.
iMessage and SMS
sms.db is covered in detail on its own page. Points that matter in a multi-app case:
- It reaches every backup. Even an unencrypted backup contains
sms.dband attachments. That makes it the baseline for comparison. - Messages in iCloud can make the local database partial and propagates deletions between devices. Record whether it was enabled.
- The body is often in
attributedBody, a typedstream blob, withtextempty. Tools that only readtextwill report empty messages. - Edits and unsends (iOS 16+) leave traces in
message_summary_infoand in the WAL. Recently Deleted keeps deleted messages for about 30 days. - RCS appears as a service on iOS 18 and later.
Remember that the same Apple Account on a Mac or iPad can send and receive the same iMessages. "From me" means from this account, not necessarily from this phone.
WhatsApp's ChatStorage.sqlite is a Core Data database in the group container group.net.whatsapp.WhatsApp.shared. It holds ZWAMESSAGE (messages), ZWACHATSESSION (chats), ZWAMEDIAITEM (attachments and shared locations) and ZWAGROUPMEMBER (group participants). Media files are under Message/Media/ in the same container.
Because the database is not encrypted by the app, a standard backup is enough to read it, and parsers are mature. Three current complications:
- LIDs. WhatsApp increasingly identifies participants by opaque "LID" identifiers instead of phone numbers. The mapping sits in a
ZWAPHONENUMBERLIDPAIRtable, either inChatStorage.sqliteor in a separateLID.sqlitedepending on the version. Resolve LIDs before reporting. - Linked devices. WhatsApp can run on a computer or tablet linked to the phone. Messages sent from a companion appear in the phone's database.
- Chat backups. WhatsApp's own backup to iCloud is a separate archive, which the user can end-to-end encrypt. It is not part of an iPhone backup and is not the same evidence.
Parse with iLEAPP, a commercial suite, or Messaging Forensics, which reads ChatStorage.sqlite and sms.db in the browser and merges them. Validate message type codes with known test messages on the same WhatsApp version.
Telegram
Telegram's iOS client stores its cache in Postbox, a key-value layer over SQLite. The file telegram-data/account-<id>/postbox/db/db_sqlite has numbered tables (t2 peers, t7 messages, t9 chat list...) with binary keys and values, and on current versions it is encrypted with SQLCipher. The key and salt are wrapped in telegram-data/.tempkeyEncrypted. Published research shows that when no Telegram passcode is set, that file is encrypted with a key derived from a default value, so the database can be opened; with a Telegram passcode, you need the passcode.
Two properties shape what you can conclude:
- Cloud chats are a cache. The device holds what the app downloaded. Absence of a message locally says nothing about the server.
- Secret chats are device-only. They are end-to-end encrypted and not stored on Telegram's servers, so the phone may hold the only copy. Self-destruct timers can remove them.
Media is cached in postbox/media, with _partial files for interrupted downloads. iLEAPP decodes messages, peers and chat lists from a decrypted database; commercial suites handle decryption for supported versions.
Signal
Signal is designed to leave as little as possible to an examiner. Its database, grdb/signal.sqlite in the group container, is SQLCipher-encrypted with a random key stored in the keychain under Signal's keychain access group, with an accessibility class that makes it available only on that device after first unlock. Signal also excludes its data from iPhone backups.
The consequence is simple: Signal needs a full file system extraction from an AFU device that includes the keychain. Most commercial tools and some agent-based methods export the keychain as a separate file; iLEAPP accepts it with --keychain and decrypts the database. Signal stores timestamps in Unix milliseconds, and the sender's timestamp doubles as a message identifier across devices, which helps when matching with the other party's phone.
Disappearing messages are common in Signal cases. Expired messages are removed from the database; fragments may remain in the WAL or freelist of the decrypted copy, but do not promise recovery.
Traces outside the apps
When an app's own store is out of reach, or was deleted with the app, system databases can still show that communication happened:
- interactionC.db records interactions donated by apps (who, which app, direction, time), and reaches a backup. It is often the best substitute for an encrypted messenger, depending on what the app donates.
- Notifications and Biome
Notification.Usagestreams record notifications delivered by an app, sometimes with sender names or previews depending on the user's preview setting. - App focus in Biome and knowledgeC shows when a messenger was in the foreground. Screen Time gives hourly totals.
- DataUsage.sqlite shows that an app used the network and when it was first seen.
- Photos.sqlite can record the app that saved an image to the library, linking media to a messenger.
- Call history includes calls made through apps that integrate with CallKit, depending on version and settings.
None of these give you message content reliably, but together they can establish that a conversation took place, with whom and when.
Deleted messages
Recovery depends on the store and the acquisition level:
| Store | Where deleted data can survive | Needs |
|---|---|---|
| sms.db | Recently Deleted (about 30 days), WAL, freelist pages | Backup for Recently Deleted; full file system for WAL |
| WAL, freelist, "message deleted" placeholders, interactionC | Full file system for WAL | |
| Telegram | Decrypted database WAL and freelist | Full file system, decryption |
| Signal | Decrypted database WAL and freelist | Full file system with keychain |
Always work on copies, never open a live database in place (SQLite may checkpoint the WAL and destroy recoverable records), and report recovered fragments as fragments, with their source offsets.
Building one conversation timeline
Merging messengers is where most errors creep in. A reliable order of operations:
- Convert every timestamp to UTC with the right epoch and unit: sms.db Cocoa nanoseconds (divide by 10^9, add 978307200), WhatsApp Cocoa seconds (add 978307200), Telegram Unix seconds, Signal Unix milliseconds (divide by 1000). See Mac Absolute Time.
- Normalise identities. Convert phone numbers to E.164, resolve WhatsApp LIDs and JIDs, map Signal ACIs to phone numbers through its recipient table, and match against AddressBook.
- Keep the source on every row: app, database, table, primary key. A merged timeline without provenance cannot be checked.
- Mark direction and device. Flag messages that may have come from a linked device or another Apple device.
- Test with known events where possible, such as messages the investigator sent to the device during the case.
The timeline analysis guide covers merging with other sources.
Copies beyond the phone
The phone is rarely the only copy of a conversation, and sometimes it is the worst one.
- iMessage syncs to the owner's Mac and iPad through Messages in iCloud. A Mac's
~/Library/Messages/chat.dbuses the same schema assms.dband is often easier to acquire. Apple can provide iCloud data through legal process unless Advanced Data Protection is enabled. - WhatsApp can hold older history in its own chat backup (iCloud Drive on iOS) and on linked devices such as WhatsApp Desktop. The chat backup can be end-to-end encrypted by the user, in which case only the password or key opens it.
- Telegram cloud chats are on Telegram's servers, and Telegram Desktop on a computer holds its own cache. Secret chats are not on the server or on other devices.
- Signal Desktop holds its own encrypted database, keyed from the desktop's keystore. Signal keeps no message content on its servers.
- The other party. The counterpart's phone is an independent copy with its own clock, often the best way to confirm or complete a thread.
Older iPhone backups on the owner's computers can also predate deletions, for the apps that reach backups. Ask for them early.
What to write in the report
State, for each messenger: whether it was installed, which acquisition level you had, whether its data was readable (and if not, why: no keychain, BFU, app deleted, backup only), the date range present, and any system-wide traces you used instead. "No Signal messages were found" and "Signal data could not be decrypted because the extraction did not include the keychain" are very different findings.
Common mistakes
- Reporting empty iMessages because
textwas NULL andattributedBodywas not decoded. - Reading Signal timestamps as seconds and placing messages tens of thousands of years in the future.
- Treating a Telegram cache as the complete conversation.
- Attributing WhatsApp messages to the phone when a linked desktop session was active.
- Opening a live
ChatStorage.sqlitein a GUI tool and losing the WAL. - Missing that a messenger was deleted before seizure, and never checking interactionC.db for its traces.