Skip to navigation

Threat reportVulnerabilityTL-2026-2744

GitHub Security Lab AI Agent Uncovers 24 Android App Vulnerabilities, Including OsmAnd Location-Tracking Flaw and Wikipedia Account Takeover

mediumACTIVE

GitHub Security Lab used its open-source Taskflow Agent, an LLM-driven structured security-auditing framework, to discover 24 vulnerabilities across Android applications. Two are detailed: an OsmAnd (10M+ downloads) flaw where an exported MapActivity handling deeplinks and settings files lets a malicious app harvest a victim's precise location via unvalidated intent extras, and a logic bug in the Wikipedia Android app's deeplink handler enabling phishing and session hijacking via cookie theft across Wikimedia projects.

Key facts

IdentifiersTL-2026-2744
SeverityMEDIUM
Affected productsOsmAnd OsmAnd (Android); Wikimedia Foundation Wikipedia (Android)
Weaknesses (CWE)CWE-940, CWE-925, CWE-183
ToolsGitHub Codespaces, GitHub Copilot, GitHub Security Lab Taskflow Agent
MITRE ATT&CK techniquesT1204.001 Malicious Link, T1409 Stored Application Data, T1430 Location Tracking, T1437.001 Web Protocols, T1516 Input Injection, T1539 Steal Web Session Cookie, T1559 Inter-Process Communication, T1635.001 URI Hijacking, T1660 Phishing
MotivationUNKNOWN
Target sectorsconsumer, technology
Target regionsGlobal
Detection rules9 (1 shown free)
Sources10 cited sources

Detection coverage

As of 2026-09-28, Threadlinqs Intelligence publishes 9 detection rule(s) for TL-2026-2744 across Splunk SPL, Microsoft KQL and Sigma, covering 15 indicator(s) of compromise. The whole corpus is readable without an account. Every threat comes with one complete detection in Splunk SPL, Microsoft KQL and Sigma, free for everyone; a free account adds daily TL Creds to unlock the rest. Paid plans add a larger daily allowance, correlation and the MCP server. Threadlinqs MCP server · View plans.

Free detection: Android Map-Tile Exfiltration via Non-Allowlisted Tile Server (OsmAnd Intent Injection)

Detects outbound requests from a managed Android device to a host outside the known-good OSM tile-server allowlist, matching the /tiles/{z}/{x}/{y}.png URL pattern used by OsmAnd's map-rendering engine. This pattern is the network-layer signature of the disclosed OsmAnd MapActivity exported-Activity flaw: a malicious co-installed app sends an Intent with settings_version/silent_import/replace/export_type_list_key extras to handleOsmAndSettingsImport(), silently importing a malicious tile-source config that redirects all subsequent tile requests to {ATTACKER_DOMAIN}/tiles/{z}/{x}/{y}.png, leaking the victim's precise coordinates and route history.

  • Languages: Splunk SPL, Microsoft KQL, Sigma
  • ATT&CK: T1559, T1516, T1430
  • Data sources: mobile threat defense network telemetry (Defender for Endpoint on Android / equivalent MTD), corporate web proxy logs, DNS resolution logs, MDM managed-app inventory
  • Severity: high
  • Confidence: high

Splunk SPL

index=proxy OR index=mtd sourcetype IN ("zscaler:web", "defender_atp:mobile:network", "pan:threat")
| eval tile_url_match=if(match(url, "(?i)\/tiles\/\d{1,2}\/\d{1,7}\/\d{1,7}\.(png|jpg|jpeg|webp)"), 1, 0)
| where tile_url_match=1
| lookup osm_tile_allowlist.csv host AS dest_host OUTPUT is_allowlisted
| where isnull(is_allowlisted) OR is_allowlisted=0
| eval app=coalesce(app_package, "net.osmand.plus")
| where match(app, "(?i)osmand")
| stats count min(_time) as first_seen max(_time) as last_seen values(dest_host) as attacker_hosts values(url) as sample_urls by device_id, src_ip
| where count > 3
| table device_id, src_ip, attacker_hosts, sample_urls, count, first_seen, last_seen

Microsoft KQL

DeviceNetworkEvents
| where Timestamp > ago(24h)
| where RemoteUrl matches regex @"(?i)/tiles/\d{1,2}/\d{1,7}/\d{1,7}\.(png|jpg|jpeg|webp)"
| where ActionType in ("ConnectionSuccess", "ConnectionRequest")
| join kind=leftanti (
    OsmTileAllowlist_CL | project RemoteUrlHost = Host
) on $left.RemoteUrl has $right.RemoteUrlHost
| summarize RequestCount = count(), DistinctTiles = dcount(RemoteUrl), FirstSeen = min(Timestamp), LastSeen = max(Timestamp) by DeviceId, DeviceName, RemoteUrl
| where RequestCount > 3
| project DeviceId, DeviceName, RemoteUrl, RequestCount, DistinctTiles, FirstSeen, LastSeen

Sigma

title: Android Map-Tile Exfiltration via Non-Allowlisted Tile Server
id: 7c9e3f4a-2b1d-4e6f-9a3c-1d5e8f2b4a71
status: experimental
description: Detects outbound requests matching a map-tile URL pattern (/tiles/{z}/{x}/{y}.png) to a host outside the known-good OSM tile-server allowlist, consistent with location-coordinate exfiltration following a malicious settings-import Intent sent to an exported mobile mapping-app Activity (e.g. OsmAnd MapActivity).
references:
    - https://github.blog/security/how-we-found-24-android-vulnerabilities-using-our-open-source-ai-security-agent/
author: Threadlinqs Team
date: 2026-09-28
tags:
    - attack.collection
    - attack.discovery
    - attack.execution
    - attack.t1430
    - attack.t1559
    - attack.t1516
logsource:
    category: proxy
detection:
    selection_tile_pattern:
        c-uri|re: '(?i)/tiles/\d{1,2}/\d{1,7}/\d{1,7}\.(png|jpg|jpeg|webp)'
    filter_allowlist:
        cs-host:
            - 'tile.osmand.net'
            - 'tile.openstreetmap.org'
            - '*.tile.osmand.net'
    condition: selection_tile_pattern and not filter_allowlist
falsepositives:
    - Legitimate self-hosted or third-party OSM-compatible tile servers not yet added to the allowlist
    - Offline-map cache prefetching against an approved CDN mirror
level: high

Known false positives:

  • Legitimate self-hosted or third-party OSM-compatible tile servers not yet added to the allowlist
  • Offline-map cache prefetching against an approved CDN mirror before the allowlist is updated

Tuning notes: Seed and continuously maintain the tile-server allowlist lookup (osm_tile_allowlist.csv / OsmTileAllowlist_CL) from the vendor's documented official endpoints; raise the count threshold in low-traffic environments to reduce noise from a single stray request, and correlate with MDM app-inventory data confirming OsmAnd is installed on the alerting device.

8 more detection rules (Splunk SPL, Microsoft KQL, Sigma) · unlock with TL Creds. Sign up free to unlock the detection rules or query them with the Threadlinqs MCP server (Purple)
  • Android Map-Tile Exfiltration via Non-Allowlisted Tile Server (OsmAnd Intent Injection) · unlock with TL Creds
  • Wikipedia Deeplink Authority Suffix-Bypass to Lookalike Domain · unlock with TL Creds
  • Cross-Wikimedia-Project Session Cookie Reuse (Possible CentralAuth Token Theft) · unlock with TL Creds
  • Android Map-Tile Exfiltration via Non-Allowlisted Tile Server (OsmAnd Intent Injection) · unlock with TL Creds
  • Wikipedia Deeplink Authority Suffix-Bypass to Lookalike Domain · unlock with TL Creds
  • Cross-Wikimedia-Project Session Cookie Reuse (Possible CentralAuth Token Theft) · unlock with TL Creds
  • Wikipedia Deeplink Authority Suffix-Bypass to Lookalike Domain · unlock with TL Creds
  • Cross-Wikimedia-Project Session Cookie Reuse (Possible CentralAuth Token Theft) · unlock with TL Creds

Indicators of compromise

As of 2026-09-28, Threadlinqs Intelligence tracks 15 indicators of compromise for TL-2026-2744.

Sample indicators (1 of 15)

  • Domain: evil-wikipedia[.]org

Defanged, TLP:CLEAR. Full set of 15 indicators: unlock with TL Creds.

15 indicators of compromise · unlock with TL Creds. Compare plans

Technical analysis

GitHub Security Lab publicly detailed the results of running its open-source Taskflow Agent — a YAML-driven, LLM-backed structured security-auditing framework built on the OpenAI Agents SDK — against a set of Android applications, surfacing 24 vulnerabilities. The agent is invoked via `./scripts/audit/run_mobile.sh myorg/myrepo` inside GitHub Codespaces, requires a GitHub Copilot license for its premium model requests, and typically completes a medium-sized repository audit in 1-2 hours. Two Android-specific taskflows drove the analysis: `gather_mobile_entry_point_info.yaml`, which separates mobile from non-mobile entry points, and `classify_application_local.yaml`, which focuses the model on mobile-specific vulnerability classes such as intent confusion and insecure broadcasts.

The post details two findings with clear real-world impact. First, OsmAnd (10M+ downloads) exports an Activity, `MapActivity`, that handles both deeplinks and settings-file imports. Its `handleOsmAndSettingsImport()` handler accepts intent extras (`settings_version`, `silent_import`, `replace`, `export_type_list_key`) that were only ever meant to arrive from a trusted in-process AIDL service — but because the Activity is exported, any application installed on the device can send it an Intent carrying arbitrary extras. A malicious app can import a crafted malicious tile-source configuration pointing at an attacker-controlled domain (`{ATTACKER_DOMAIN}/tiles/{z}/{x}/{y}.png`); every subsequent map-tile request OsmAnd makes then leaks the tile coordinates (i.e., the victim's precise latitude/longitude), plus route origins, destinations, and timestamps, to the attacker's server — silently, with no user-visible indication of compromise.

Second, the Wikipedia Android app contains two chained logic bugs. Its deeplink handler validates the authority of a `wikipedia://` URI only by checking `endsWith(WikiSite.BASE_DOMAIN)` rather than exact-matching a trusted domain, so a deeplink such as `wikipedia://evil-wikipedia.org` passes validation and is rewritten to a standard `https://evil-wikipedia.org` URI that the app then opens. Separately, `SharedPreferenceCookieManager.kt` validates cookie domains using the same overly permissive `.endsWith()` comparison. Chained together, a victim who taps a single malicious deeplink has the Wikipedia app auto-open attacker-controlled content and leak cookies to it — yielding the victim's username, long-lived tokens, and session tokens valid across every Wikimedia project (all Wikipedias, Commons, Wikidata, Meta, and more), enabling account takeover.

GitHub Security Lab states the two detailed findings were 'already disclosed,' but the post supplies no CVE identifiers, CVSS scores, patch status, or remediation timeline for either issue, and gives only high-level categories (path traversal, cross-app scripting in WebView implementations, exposed JavaScript bridges) for the remaining 22 undetailed vulnerabilities, pointing readers to GitHub Security Lab's advisories page for further detail. The post also documents the Taskflow Agent's current limitations: LLMs struggle to estimate severity accurately, produce false positives requiring human security-researcher validation, and can misjudge complex mitigating factors (e.g., internal vs. external storage data-priority hierarchies) without explicit proof-of-concept prompting — while showing strong knowledge of platform API behavior across languages without needing source-code access.

MITRE ATT&CK techniques by tactic:

Execution

T1204.001 Malicious Link; T1559 Inter-Process Communication

Collection

T1409 Stored Application Data; T1430 Location Tracking

Discovery

T1430 Location Tracking

Command and Control

T1437.001 Web Protocols

Defense Evasion

T1516 Input Injection

Credential Access

T1539 Steal Web Session Cookie; T1635.001 URI Hijacking

Initial Access

T1660 Phishing

Remediation

Immediate actions

  • Remove or restrict android:exported="true" on Activities/components that process sensitive intent extras (e.g., settings-import handlers); require an explicit permission or verify the calling package/signature before acting on extras from an untrusted caller.
  • Replace suffix-based domain/authority checks (endsWith()) with exact string-equality or a validated allow-list when checking deeplink authorities and cookie domains in Android apps.
  • Treat any tile/asset-loading configuration importable via Intent as untrusted input; validate or pin the host before issuing outbound requests.
  • Monitor the OsmAnd and Wikipedia Android app store listings for security-patch updates and apply them promptly once released; no patch was confirmed at time of publication.

Workarounds

  • No public vendor patch confirmed at time of publication for either the OsmAnd or Wikipedia Android findings; avoid installing untrusted third-party Android apps alongside OsmAnd to reduce local intent-injection exposure.
  • Avoid tapping wikipedia:// deeplinks received from untrusted sources (SMS, email, third-party apps, QR codes) until the Wikipedia Android app is confirmed patched.

Longer-term hardening

  • Integrate AI-assisted structured security-auditing tools such as the GitHub Security Lab Taskflow Agent into the mobile app SDLC to systematically catch exported-component and intent-handling flaws before release.
  • Add automated CI linting for exported Android components that accept intent extras without caller verification (e.g., Android Lint exported-component checks, MobSF static analysis).
  • Adopt strict origin/domain equality checks across all URI-scheme handlers and cookie-domain validation logic, and add regression tests specifically for suffix-matching bypass patterns.
  • Independently review LLM-generated vulnerability severity/impact assessments from agentic security tooling with a human researcher before acting on them, per GitHub Security Lab's own documented limitation.

Affected and fixed versions

  • OsmAnd — OsmAnd (Android)
    Vulnerable versions: current app version at time of research (10M+ downloads); exact version range not disclosed
  • Wikimedia Foundation — Wikipedia (Android)
    Vulnerable versions: current app version at time of research; exact version range not disclosed

Timeline

  • Post references 22 additional, undetailed Android vulnerabilities (categorized only as path traversal, cross-app scripting in WebView implementations, and exposed JavaScript bridges) and directs readers to GitHub Security Lab's advisories page.
  • Blog notes the Taskflow Agent requires a GitHub Copilot license for premium model requests and runs via GitHub Codespaces (locked-ioc-4 myorg/myrepo), typically completing in 1-2 hours on a medium repository.
  • GitHub Security Lab points readers to its open-sourced Taskflow Agent repositories (seclab-taskflow-agent, seclab-taskflows) so others can run the same taskflows against their own projects.
  • GitHub Security Lab states the two detailed findings were 'already disclosed,' but the post provides no CVE identifiers, CVSS scores, patch status, or remediation timeline for either issue.
  • Wikipedia Android app's chained deeplink-authority-validation and cookie-domain-validation logic bugs, enabling phishing and cross-Wikimedia-project session hijacking, are publicly detailed.
  • OsmAnd's exported MapActivity location-tracking vulnerability (unvalidated settings-import intent extras leaking tile coordinates to an attacker server) is publicly detailed.
  • Blog details the Taskflow Agent's two Android-specific taskflows — locked-ioc-1 and locked-ioc-2 — used to conduct the audits.
  • GitHub Security Lab publishes 'How we found 24 Android vulnerabilities using our open source AI security agent' on the GitHub Blog.

Sources cited

Previous and next in vulnerability

Drafted by the Threadlinqs research pipeline from 10 sources; published ; last updated —.

Threadlinqs Intelligence — Real-Time Threat Detection Platform

// threat_feed
$ sort --newest
Showing all threats

Live intelligence console

Threat level

Latest Threats