Text of securitylab.github.com › advisories › GHSL-2026-102_Android_SignalApp as Styx crawled it on Nov 20, 2026. The page may have changed since. Only its words are kept, without pictures or layout, and only the first part of a long page.

Open the live page

GHSL-2026-102: Unauthorized exfiltration of decrypted attachments in Signal through Intent redirection | GitHub Security Lab

skip to content Resources Open Source Community Enterprise / Security Lab Research Advisories CodeQL Wall of Fame Resources Open Source Community Enterprise Events Get Involved Coordinated Disclosure Timeline 2026-03-28: Security at signal.org was notified about the vulnerability 2026-03-31: Signal team has informed that the fix was committed and the website apk was updated to v8.4.2 Summary Versions >= v6.38.0 and < v8.4.2 of the website flavor of Signal for Android (distributed at https://signal.org/android/apk ) allow another installed app without any permissions to exfiltrate decrypted attachments (photos, videos, documents, voice notes) by exploiting Intent redirection, potentially exposing sensitive user data.

Project Signal-Android Tested Version v8.4.1 Details Decrypted attachments exfiltration through Intent redirection ( GHSL-2026-102 ) Signal distributes its Android app through multiple channels: play - Google Play Store. Most users get it here. Google handles updates. website - Downloaded directly from https://signal.org/android/apk. For users who don’t have or don’t want to use Google Play (e.g., degoogled phones, some countries where Play isn’t available, privacy-conscious users who avoid Google services). github - GitHub releases.

Transparency. Reproducible builds. Signal’s website build handles its own APK updates (since there’s no Play Store to do it). Instead, it polls https://updates.signal.org/android/latest.json for new versions, downloads the APK itself, and uses Android’s PackageInstaller API to install it - which is exactly why ApkUpdatePackageInstallerReceiver exists and is exported in that variant. The Play Store and GitHub builds do not register this receiver.

The attack chain involves four components: an unprotected broadcast receiver, an unsanitized intent relaunch, a content provider that serves decrypted data, and a no-op access check in the default configuration. Part 1: The Entry Point - An Exported Receiver With No Protection To receive callbacks from Android’s PackageInstaller , website build registers a BroadcastReceiver in its AndroidManifest.xml : <receiver android:name= ".apkupdate.ApkUpdatePackageInstallerReceiver" android:exported= "true" /> Three things are missing here: No android:permission - any app can send it a broadcast, no special permission required No <intent-filter> - the receiver accepts any explicit intent targeting it No sender verification - the code inside never checks who sent the broadcast This means any app installed on the same device - even one with zero declared permissions - can craft an intent and trigger this receiver.

Part 2: The Vulnerable Code Path - Unsanitized Intent Relaunch When the broadcast arrives, the receiver’s onReceive() method reads the status code from the intent: override fun onReceive ( context : Context , intent : Intent ?) { val statusCode : Int = intent ?. getIntExtra ( PackageInstaller . EXTRA_STATUS , - 1 ) ?: - 1 val userInitiated = intent ?. getBooleanExtra ( EXTRA_USER_INITIATED , false ) ?: false when ( statusCode ) { // ...

PackageInstaller . STATUS_PENDING_USER_ACTION -> handlePendingUserAction ( context , userInitiated , intent !! ) // ... } } The default value for EXTRA_STATUS when the extra is absent is -1 , which matches STATUS_PENDING_USER_ACTION , routing execution into handlePendingUserAction() . Inside handlePendingUserAction() : private fun handlePendingUserAction ( context : Context , userInitiated : Boolean , intent : Intent ) { val downloadId = intent . getLongExtra ( EXTRA_DOWNLOAD_ID , - 2 ) if (! userInitiated ) { ApkUpdateNotifications . showInstallPrompt ( context , downloadId ) return // ← safe path: just shows a notification } val promptIntent : Intent ? = intent . getParcelableExtraCompat ( Intent .

EXTRA_INTENT , Intent :: class . java ) if ( promptIntent == null ) { ApkUpdateNotifications . showInstallPrompt ( context , downloadId ) return } promptIntent . apply { putExtra ( Intent . EXTRA_NOT_UNKNOWN_SOURCE , true ) putExtra ( Intent . EXTRA_INSTALLER_PACKAGE_NAME , "com.android.vending" ) addFlags ( Intent . FLAG_ACTIVITY_NEW_TASK ) } context . startActivity ( promptIntent ) // ← launches attacker's intent } There are three problems here: The userInitiated guard is trivially bypassed.

The value is read directly from the incoming broadcast ( EXTRA_USER_INITIATED ). An attacker simply sets it to true . The inner intent is completely attacker-controlled. The getParcelableExtraCompat() call is just a compatibility wrapper around getParcelableExtra() - it performs no validation: fun < T : Parcelable > Intent . getParcelableExtraCompat ( key : String , clazz : Class < T >): T ? { return if ( Build . VERSION .

SDK_INT >= 33 ) { this . getParcelableExtra ( key , clazz ) } else { this . getParcelableExtra ( key ) } } Whatever intent the attacker packed under Intent.EXTRA_INTENT is extracted as-is: target component, data URIs, ClipData, and flags are all preserved. addFlags() preserves the attacker’s flags. The code uses addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) , which performs a bitwise OR . If the attacker already set FLAG_GRANT_READ_URI_PERMISSION on the inner intent, that flag survives.

Had the code used setFlags() (which replaces all flags), the attacker’s grant flag would have been overwritten. The final context.startActivity(promptIntent) executes under Signal’s UID . The Android system sees Signal - the owner of its own content providers - requesting an activity launch with URI grants attached. The system honors the request. Part 3: The Target - Signal’s Attachment Provider The destination of those URI grants is Signal’s PartProvider , declared in AndroidManifest.xml : <provider android:name= ".providers.PartProvider" android:authorities= "${applicationId}.part" android:exported= "false" android:grantUriPermissions= "true" /> While exported="false" prevents direct access from other apps, grantUriPermissions="true" allows Signal’s own process to delegate per-URI read access to another app - which is exactly what FLAG_GRANT_READ_URI_PERMISSION does when attached to an intent with ClipData containing content://org.thoughtcrime.securesms.part/part/<id> URIs.

When the receiving app opens such a URI, PartProvider.openFile() is called: public ParcelFileDescriptor openFile ( @NonNull Uri uri , @NonNull String mode ) throws FileNotFoundException { if ( KeyCachingService . isLocked ( getContext ())) { Log . w ( TAG , "masterSecret was null, abandoning." ); return null ; } // ... if ( uriMatcher . match ( uri ) == SINGLE_ROW ) { final PartUriParser partUri = new PartUriParser ( uri ); return getParcelStreamProxyForAttachment ( partUri . getPartId ()); } throw new FileNotFoundException ( "Request for bad part." ); } This returns fully decrypted attachment bytes.

The only access check is isLocked() . The attachment IDs themselves are trivially enumerable. PartUriParser simply extracts the trailing numeric segment: class PartUriParser ( private val uri : Uri ) { val partId : AttachmentId get () = AttachmentId ( id ) private val id : Long get () = ContentUris . parseId ( uri ) } And AttachmentId is just a sequential database row ID: data class AttachmentId ( @JsonProperty ( "rowId" ) @JvmField val id : Long ) URIs follow the pattern content://org.thoughtcrime.securesms.part/part/1 , .../part/2 , .../part/3 , and so on.

An attacker can enumerate the entire attachment table. Part 4: The Lock Check The sole remaining defense is KeyCachingService.isLocked() : public static synchronized boolean isLocked ( Context context ) { boolean locked = masterSecret == null && (! SignalStore . settings (). getPassphraseDisabled () || SignalStore . settings (). getScreenLockEnabled ()); return locked ; } The two settings have these defaults in SettingsValues.java: public boolean getPassphraseDisabled () { return getBoolean ( PASSPHRASE_DISABLED , true ); // default: true (passphrase IS disabled) } public boolean getScreenLockEnabled ()

The rest of this page is on the live site.