Comparing WeChat and Telegram MiniApp Security Architectures: Toward Cross-Platform Analysis
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: I'm Nadia.
Elias: And I'm Elias, here with Priya.
Nadia: We're looking at the paper: "Comparing WeChat and Telegram MiniApp Security Architectures".
Elias: Here's the gist of the paper. MiniApps are increasingly central to super-app ecosystems, yet architectural differences complicate the transfer of security analysis techniques across platforms The paper presents a qualitative comparison of WeChat Mini Programs and Telegram MiniApps, grounded in official documentation, prior research, and manual analysis of a specific Telegram Android source revision Using a shared taxonomy of security controls, assets, and threat sources, the study examines execution environments, communication paths, and trust boundaries Both WeChat provides a dedicated MiniApp runtime; Telegram combines web execution with host controls Architectural Comparison The paper establishes a structured architectural comparison of WeChat’s App-in-App model and Telegram’s bot-centric web-based MiniApp framework The comparison is grounded in official documentation, prior literature, and manual inspection of the Telegram Android client The two ecosystems are characterized across shared dimensions including execution environments, bridge communication channels, and credential custody Security Model Analysis The study analyzes the security assumptions, trust boundaries, and attack surfaces of both ecosystems WeChat’s security model is characterized by runtime isolation (S02) and layered permission mediation (S06) Telegram MiniApps operate through four core components including the Telegram Client, Telegram Server, Bot, and MiniApp The security controls and assets are annotated using a taxonomy that distinguishes platform or developer mechanisms from application properties Analytical Requirements Derived The comparison derives requirements for cross-platform security analysis through two worked examples The first example concerns credential roles and validation boundaries, distinguishing between application credentials and user-bound session material The second example focuses on context-dependent permission mediation, requiring association of host capabilities with concrete execution contexts and permission handlers The study concludes that WeChat provides a MiniApp-specific runtime and platform services, whereas Telegram combines web execution with host-mediated interactions and developer-operated infrastructure These differences determine which components can enforce particular controls, rather than establishing an unconditional security ranking The findings inform future automated analysis without ranking the ecosystems by security or claiming validated vulnerability detection The comparison provides a qualitative architectural systematization supported by official documentation, prior work, and a manual inspection of the Telegram Android client source code The study does not report a MiniApp corpus, instrumentation traces, or an evaluation of an automated detector The comparison does not measure vulnerability prevalence or establish behavior across client versions and platforms The architectural relationships reconstructed here from static sources could be validated dynamically, confirming which code paths are exercised at runtime and under which client and device configurations The comparison could be extended to other App-in-App ecosystems, such as Alipay (Alipay, 2026) and Baidu (Baidu, 2026) Tooling that operationalizes the taxonomy would help transfer these findings into automated cross-platform analysis pipelines The authors used ChatGPT (OpenAI, GPT5.5) and Grammarly (Grammarly Premium, web version accessed in 2026) solely for language refinement, including grammar, spelling, clarity, paraphrasing, and stylistic revision The study uses official developer documentation, published literature, and the publicly available Telegram Android source code The authors report there are no competing interests to declare.
Nadia: The work was partially supported by the European Union – NextGenerationEU under the Italian NRRP (MUR) program, project SERICS (PE00000014).
Elias: The paper is 2611.13965.
Nadia: Page 23 --- References Alipay.
Paper summary: Nadia: To wrap up, we’re talking about "Comparing WeChat and Telegram MiniApp Security Architectures: Toward Cross-Platform Analysis." The authors are Luca Ferrari, Billel Habbati, and Luca Verderame.
Elias: They establish a basis for future automated vulnerability detection methods by providing a structured architectural comparison grounded in official documentation and manual inspection of the Telegram Android source code.
Priya: It boils down to recognizing that WeChat has a dedicated MiniApp runtime, while Telegram uses web execution combined with host controls, and this fundamental split is what makes transferring security analysis techniques difficult.
Nadia: The paper shows that we need to identify key abstractions—like credential roles and context-dependent permission mediation—that automated analysis frameworks must capture to reason across these different models.
Elias: Ultimately, the paper concludes that because of these structural differences, you can't establish a single security ranking; instead, you determine which specific controls can be enforced in each environment.
Priya: What does this mean for the long term? It means we stop looking for one universal fix and start building analysis tools that understand the specific execution context they are analyzing.
Nadia: It suggests that future automated analysis pipelines should leverage this architectural knowledge to target specific control enforcement mechanisms within each platform's model.
Conclusion: Nadia: So we're wrapping up this look at WeChat versus Telegram MiniApps by discussing the main points and who wrote this paper.
Elias: It’s titled "Comparing WeChat and Telegram MiniApp Security Architectures: Toward Cross-Platform Analysis," and it comes from Luca Ferrari, Billel Habbati, and Luca Verderame.
Priya: What does that actually mean for us? Basically, the authors are comparing two totally different ways these apps are built—WeChat's dedicated runtime versus Telegram's web execution mixed with host controls.
Nadia: Exactly. It shows how those structural differences make it hard to just take one security analysis method and use it everywhere.
Elias: The core idea is that you have to define a shared way to look at things, a common set of rules for controls and threats, before you can compare them properly.
Priya: And they did this by creating a taxonomy—a shared vocabulary—to map out the execution environments and the communication paths in both systems.
Nadia: It’s about setting up those specific examples to show how you figure out who holds a credential or what kind of permission bypass looks like in each setup.
Elias: They stress that this isn't about ranking which system is "safer," but rather figuring out which specific security controls can be enforced where they are.
Priya: That distinction is key. It tells us that automated analysis needs to understand the platform, not just the code itself, to work across different ecosystems.
Nadia: Right. So it moves us away from trying to find one universal detector and toward building tools that adapt based on the architecture they're looking at.
Elias: This architectural understanding is what lets us start thinking about how we can actually build those cross-platform analysis pipelines moving forward.
Priya: Next up, we’re going to talk about how this structural comparison might affect future work on super-app security and whether other platforms share these same fundamental differences.
Luca Ferrari, Billel Habbati, Luca Verderame
IMT School for Advanced Studies Lucca · University of Genoa
cs.CR
Submitted: 2026-11-10
Updated: 2026-11-10
Code: https://github.com/DrKLO/Telegram
Project page: https://w3c.github.io/miniapp-white-paper/Wang
License: http://creativecommons.org/licenses/by-nc-nd/4.0/
Importance score: 73/100
The gist: MiniApps are increasingly central to super-app ecosystems, yet architectural differences complicate the transfer of security analysis techniques across platforms The paper presents a qualitative…
Key concepts
- Architectural Comparison
- This involves structuring a detailed comparison of two different app models: WeChat's App-in-App structure versus Telegram's bot-centric web framework. It focuses on shared dimensions like where code runs (execution environments), how components talk to each other (bridge communication), and who manages sensitive information (credential custody).
- Security Model Analysis
- This examines the inherent security assumptions, trust boundaries, and potential attack surfaces for both ecosystems. WeChat uses runtime isolation and layered permissions, while Telegram's model involves four core components: the client, server, bot, and MiniApp. Security controls are mapped against these specific platform mechanisms.
- Analytical Requirements
- The comparison generates concrete needs for tools designed to analyze security across different platforms. This is demonstrated through two worked examples: one focusing on identifying credential roles and validation boundaries, and another targeting context-dependent permission mediation, like checking if a navigation request properly passes through an SDK handler.
- Transferability Conclusion
- The study concludes that the fundamental difference—WeChat having a dedicated runtime versus Telegram's web execution with host controls—means controls cannot be universally ranked. Instead, it provides a qualitative architectural map to inform future automated analysis pipelines and identify which specific code paths are exercised under different client configurations.
Terminology
Summary
MiniApps are increasingly central to super-app ecosystems, yet architectural differences complicate the transfer of security analysis techniques across platforms The paper presents a qualitative comparison of WeChat Mini Programs and Telegram MiniApps, grounded in official documentation, prior research, and manual analysis of a specific Telegram Android source revision Using a shared taxonomy of security controls, assets, and threat sources, the study examines execution environments, communication paths, and trust boundaries Both WeChat provides a dedicated MiniApp runtime; Telegram combines web execution with host controls
Architectural Comparison
The paper establishes a structured architectural comparison of WeChat’s App-in-App model and Telegram’s bot-centric web-based MiniApp framework The comparison is grounded in official documentation, prior literature, and manual inspection of the Telegram Android client The two ecosystems are characterized across shared dimensions including execution environments, bridge communication channels, and credential custody
Security Model Analysis
The study analyzes the security assumptions, trust boundaries, and attack surfaces of both ecosystems WeChat’s security model is characterized by runtime isolation (S02) and layered permission mediation (S06) Telegram MiniApps operate through four core components including the Telegram Client, Telegram Server, Bot, and MiniApp The security controls and assets are annotated using a taxonomy that distinguishes platform or developer mechanisms from application properties
Analytical Requirements Derived
The comparison derives requirements for cross-platform security analysis through two worked examples The first example concerns credential roles and validation boundaries, distinguishing between application credentials and user-bound session material The second example focuses on context-dependent permission mediation, requiring association of host capabilities with concrete execution contexts and permission handlers
Conclusion on Transferability
The study concludes that WeChat provides a MiniApp-specific runtime and platform services, whereas Telegram combines web execution with host-mediated interactions and developer-operated infrastructure These differences determine which components can enforce particular controls, rather than establishing an unconditional security ranking The findings inform future automated analysis without ranking the ecosystems by security or claiming validated vulnerability detection The comparison provides a qualitative architectural systematization supported by official documentation, prior work, and a manual inspection of the Telegram Android client source code The study does not report a MiniApp corpus, instrumentation traces, or an evaluation of an automated detector The comparison does not measure vulnerability prevalence or establish behavior across client versions and platforms The architectural relationships reconstructed here from static sources could be validated dynamically, confirming which code paths are exercised at runtime and under which client and device configurations The comparison could be extended to other App-in-App ecosystems, such as Alipay (Alipay, 2026) and Baidu (Baidu, 2026) Tooling that operationalizes the taxonomy would help transfer these findings into automated cross-platform analysis pipelines The authors used ChatGPT (OpenAI, GPT5.5) and Grammarly (Grammarly Premium, web version accessed in 2026) solely for language refinement, including grammar, spelling, clarity, paraphrasing, and stylistic revision The study uses official developer documentation, published literature, and the publicly available Telegram Android source code The authors report there are no competing interests to declare. p. 3 The evidence basis is asymmetric. The WeChat characterization primarily relies
on official documentation and prior peer-reviewed literature, whereas the Telegram
characterization additionally relies on manual inspection of a specific revision of the
Android client source code. To avoid terminology ambiguity, we use MiniApp as the generic cross-platform
term throughout the paper. When discussing WeChat-specific artifacts or prior work
that uses Tencent’s naming, we use Mini Program; when discussing Telegram, we use
Telegram MiniApp. ferrari@imtlucca. it
arXiv:2611.Where the paper says it
Where the paper says it
Where the paper says it
--- Page 23 ---
References
Alipay. (2026). Alipay. Retrieved May 25, 2026, from https://mobile. p. 9 The MiniApp Frontend executes inside the
client’s WebView and uses the JavaScript SDK to request supported host interactions
through the local bridge (Telegram, 2026). It may also exchange application data with
a developer-operated MiniApp Backend over HTTPS. The MiniApp Frontend executes inside the
client’s WebView and uses the JavaScript SDK to request supported host interactions
through the local bridge (Telegram, 2026). It may also exchange application data with
a developer-operated MiniApp Backend over HTTPS. Accordingly, source-code-backed statements are scoped to
the inspected revision and should not be assumed to hold unchanged across Telegram
1https://github. com/DrKLO/Telegram
4 Telegram Bot
API
authentication
and MiniApp
initialization-data
validation protect
different
boundaries. Telegram Bot API:
“Authorizing your
bot” and “Making
requests”; Telegram
Mini Apps (Telegram,
2026): “Validating
data received via the
Mini App”. The closest prior study to
our work is Mohammadi, Moradi, and Atani (2025), who compares Telegram MiniApps
and WeChat Mini Programs while focusing primarily on Telegram attack chains,
TON/blockchain-specific risks, unproxied frontend–backend communication, insecure
configuration practices, limited WebView isolation, and a Telegram-oriented mitigation framework based on QuickJS sandboxing, mandatory HTTPS, MLS encryption,
and wallet verification. While their study catalogs empirical attacks and practical mitigations, it motivates Telegram security by citing known WeChat vulnerabilities from
prior literature, without analyzing WeChat’s architectural specifications or developer
documentation. RESEARCH ARTICLE
Comparing WeChat and Telegram MiniApp Security Architectures:
Toward Cross-Platform Analysis
Luca Ferrari a
, Billel Habbati b and Luca Verderame b
a
IMT School for Advanced Studies Lucca, Lucca, Italy; bUniversity of Genoa, Genoa, Italy
ABSTRACT
MiniApps are increasingly central to super-app ecosystems, yet architectural differences complicate the transfer of security analysis techniques across platforms. Existing WeChat analyzers rely on packaged applications and platform-specific APIs, limiting their direct applicability to Telegram’s web-based MiniApps. While their study catalogs empirical attacks and practical mitigations, it motivates Telegram security by citing known WeChat vulnerabilities from
prior literature, without analyzing WeChat’s architectural specifications or developer
documentation. More recently, Ferrari, Ceccato, and Verderame (2026) present TeleGapper, a black-box dynamic analysis framework for investigating the privacy practices of Telegram MiniApps. RESEARCH ARTICLE
Comparing WeChat and Telegram MiniApp Security Architectures:
Toward Cross-Platform Analysis
Luca Ferrari a
, Billel Habbati b and Luca Verderame b
a
IMT School for Advanced Studies Lucca, Lucca, Italy; bUniversity of Genoa, Genoa, Italy
ABSTRACT
MiniApps are increasingly central to super-app ecosystems, yet architectural differences complicate the transfer of security analysis techniques across platforms. Existing WeChat analyzers rely on packaged applications and platform-specific APIs, limiting their direct applicability to Telegram’s web-based MiniApps. While their study catalogs empirical attacks and practical mitigations, it motivates Telegram security by citing known WeChat vulnerabilities from
prior literature, without analyzing WeChat’s architectural specifications or developer
documentation. More recently, Ferrari, Ceccato, and Verderame (2026) present TeleGapper, a black-box dynamic analysis framework for investigating the privacy practices of Telegram MiniApps. ferrari@imtlucca. it
arXiv:2611. Related Work
Several papers have addressed MiniApp ecosystems, particularly in the WeChat domain. Han, Ji, Wang, and Zhang (2023) identify nine major categories of issues: logic
vulnerabilities, XSS, privilege escalation, SQL injection, arbitrary file uploads, weak
password security, sensitive information leakage, CSRF, and insecure integration of
third-party technologies. While their study catalogs empirical attacks and practical mitigations, it motivates Telegram security by citing known WeChat vulnerabilities from
prior literature, without analyzing WeChat’s architectural specifications or developer
documentation. More recently, Ferrari, Ceccato, and Verderame (2026) present TeleGapper, a black-box dynamic analysis framework for investigating the privacy practices of Telegram MiniApps. Introduction
Mini Applications, hereafter MiniApps, have become an essential component of digital services in China, supporting applications ranging from mobile commerce to public administration. Before 2020, MiniApp ecosystems generally followed the App-inApp model (Schreieck, Ou, & Krcmar, 2023), where the host application acts as a
lightweight app store, enabling third-party developers to deploy apps within the host’s
environment. MiniApp ecosystems are rapidly expanding (Schreieck et al. , 2023), and prior security analyses at scale
(Meng et al. Meng et al. (2023) present WEMINT, a static taint-analysis framework for detecting sensitive data leaks; in a large-scale evaluation over 20K suspicious MiniApps, they found that 7,585 apps, or 36. These findings inform future automated analysis without
ranking the ecosystems by security or claiming validated vulnerability detection. KEYWORDS
MiniApps; WeChat; Telegram; super-app ecosystems; Android; software security
1. This model is largely platform-controlled and has been the focus of standardization efforts such as the W3C MiniApp Standardization White Paper (W3C
MiniApps Working Group, 2022). Telegram introduced its own MiniApp model in 2022, targeting its base, which
crossed 1 billion monthly active users in 2025 (Mehta, 2025). This model is largely platform-controlled and has been the focus of standardization efforts such as the W3C MiniApp Standardization White Paper (W3C
MiniApps Working Group, 2022). Telegram introduced its own MiniApp model in 2022, targeting its base, which
crossed 1 billion monthly active users in 2025 (Mehta, 2025). This model is largely platform-controlled and has been the focus of standardization efforts such as the W3C MiniApp Standardization White Paper (W3C
MiniApps Working Group, 2022). Telegram introduced its own MiniApp model in 2022, targeting its base, which
crossed 1 billion monthly active users in 2025 (Mehta, 2025). The study therefore provides a qualitative architectural
comparison rather than an empirical assessment of vulnerability prevalence. WeChat Mini Program Execution Ecosystem & Communication
WeChat Mini Programs are lightweight software applications, accessed directly within
the WeChat client, that are distributed as a single compressed package retrieved from
the platform’s registry. This model is largely platform-controlled and has been the focus of standardization efforts such as the W3C MiniApp Standardization White Paper (W3C
MiniApps Working Group, 2022). Telegram introduced its own MiniApp model in 2022, targeting its base, which
crossed 1 billion monthly active users in 2025 (Mehta, 2025). As described by Baskaran et al. (2023) and Tencent (2026a), CloudBase
provides developers with native cloud support integrated into WeChat and reduces
the need for backend and Operation & Maintenance. Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. Developers are free to implement their apps using raw HTML,
CSS, and JavaScript, or popular web frameworks such as React (React, 2026). This convention also separates the generic abstraction studied in
this paper from platform-specific packaging and runtime names. In this paper, we present a comparative study of WeChat Mini Programs and Telegram MiniApps, characterizing their architectural and security differences and establishing a basis for future automated vulnerability-detection methods. Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. Developers are free to implement their apps using raw HTML,
CSS, and JavaScript, or popular web frameworks such as React (React, 2026). Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. Developers are free to implement their apps using raw HTML,
CSS, and JavaScript, or popular web frameworks such as React (React, 2026). Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. Developers are free to implement their apps using raw HTML,
CSS, and JavaScript, or popular web frameworks such as React (React, 2026). Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. Developers are free to implement their apps using raw HTML,
CSS, and JavaScript, or popular web frameworks such as React (React, 2026). Zhang et al. , 2024) rely
on WeChat’s package structure and client APIs, so they cannot be applied directly
to Telegram’s web execution model. Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. Developers are free to implement their apps using raw HTML,
CSS, and JavaScript, or popular web frameworks such as React (React, 2026). Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. Developers are free to implement their apps using raw HTML,
CSS, and JavaScript, or popular web frameworks such as React (React, 2026). Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. Developers are free to implement their apps using raw HTML,
CSS, and JavaScript, or popular web frameworks such as React (React, 2026). Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. Developers are free to implement their apps using raw HTML,
CSS, and JavaScript, or popular web frameworks such as React (React, 2026). These apps are invoked via Telegram bots (Telegram, 2026),
which act as entry points for their execution. Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. It exposes server-side APIs (hosted at api. com) that
are called by the developer’s backend rather than by the MiniApp, for example to
obtain an access token or to exchange a login code for a session. It exposes server-side APIs (hosted at api. com) that
are called by the developer’s backend rather than by the MiniApp, for example to
obtain an access token or to exchange a login code for a session. Introduction
Mini Applications, hereafter MiniApps, have become an essential component of digital services in China, supporting applications ranging from mobile commerce to public administration. Before 2020, MiniApp ecosystems generally followed the App-inApp model (Schreieck, Ou, & Krcmar, 2023), where the host application acts as a
lightweight app store, enabling third-party developers to deploy apps within the host’s
environment. Due to the absence of a standardized packaging format or framework enforcement,
the structure of a Telegram MiniApp is entirely dependent on the developer’s choice of
tools and build systems. Developers are free to implement their apps using raw HTML,
CSS, and JavaScript, or popular web frameworks such as React (React, 2026). Telegram adopts a
bot-oriented approach in which MiniApps are associated with bot identities and delivered as web applications built using standard web technologies. This differs from
WeChat’s model, in which platform-specific application packages execute within the
host’s MiniApp framework. Zhang et al. (2024) propose MiniCAT, an automated analysis framework that crawls and unpacks WeChat Mini Programs and reconstructs
attack paths across logic-layer JavaScript and render-layer WXML. Each page is composed of four files:
(1) A . wxml file, written in Tencent’s proprietary WXML markup language, used to
define UI structures such as buttons and input fields (Tencent, 2026e). js file, containing JavaScript logic executed in response to user interactions. wxss file, which specifies styling rules using WXSS, a variant of CSS customized
for WeChat (Tencent, 2026f). Accordingly, source-code-backed statements are scoped to
the inspected revision and should not be assumed to hold unchanged across Telegram
1https://github. com/DrKLO/Telegram
4 Before 2020, MiniApp ecosystems generally followed the App-inApp model (Schreieck, Ou, & Krcmar, 2023), where the host application acts as a
lightweight app store, enabling third-party developers to deploy apps within the host’s
environment. This model is largely platform-controlled and has been the focus of standardization efforts such as the W3C MiniApp Standardization White Paper (W3C
MiniApps Working Group, 2022). Before 2020, MiniApp ecosystems generally followed the App-inApp model (Schreieck, Ou, & Krcmar, 2023), where the host application acts as a
lightweight app store, enabling third-party developers to deploy apps within the host’s
environment. This model is largely platform-controlled and has been the focus of standardization efforts such as the W3C MiniApp Standardization White Paper (W3C
MiniApps Working Group, 2022). Before 2020, MiniApp ecosystems generally followed the App-inApp model (Schreieck, Ou, & Krcmar, 2023), where the host application acts as a
lightweight app store, enabling third-party developers to deploy apps within the host’s
environment. This model is largely platform-controlled and has been the focus of standardization efforts such as the W3C MiniApp Standardization White Paper (W3C
MiniApps Working Group, 2022). Before 2020, MiniApp ecosystems generally followed the App-inApp model (Schreieck, Ou, & Krcmar, 2023), where the host application acts as a
lightweight app store, enabling third-party developers to deploy apps within the host’s
environment. This model is largely platform-controlled and has been the focus of standardization efforts such as the W3C MiniApp Standardization White Paper (W3C
MiniApps Working Group, 2022). Before 2020, MiniApp ecosystems generally followed the App-inApp model (Schreieck, Ou, & Krcmar, 2023), where the host application acts as a
lightweight app store, enabling third-party developers to deploy apps within the host’s
environment. This model is largely platform-controlled and has been the focus of standardization efforts such as the W3C MiniApp Standardization White Paper (W3C
MiniApps Working Group, 2022). Meng et al. (2023) present WEMINT, a static taint-analysis framework for detecting sensitive data leaks; in a large-scale evaluation over 20K suspicious MiniApps, they found that 7,585 apps, or 36. Moreover,
existing literature already characterizes its execution model, permission mechanisms,
token lifecycle, and known vulnerability classes in depth. Consequently, our WeChat
characterization synthesizes official documentation and peer-reviewed studies, establishing an architectural baseline without direct client reverse engineering. , 2023), and prior security analyses at scale
(Meng et al. , 2023; Wang, Ko, Zhang, Yang, & Lin, 2023; Z. (2024) propose MiniCAT, an automated analysis framework that crawls and unpacks WeChat Mini Programs and reconstructs
attack paths across logic-layer JavaScript and render-layer WXML. Yang, Zhang,
and Lin (2022) introduce Cross-MiniApp Request Forgery (CMRF), where a malicious MiniApp forges requests to another MiniApp by exploiting missing checks on
the sender’s appId (the platform-assigned identifier for a registered Mini Program,
see Section 6). RESEARCH ARTICLE
Comparing WeChat and Telegram MiniApp Security Architectures:
Toward Cross-Platform Analysis
Luca Ferrari a
, Billel Habbati b and Luca Verderame b
a
IMT School for Advanced Studies Lucca, Lucca, Italy; bUniversity of Genoa, Genoa, Italy
ABSTRACT
MiniApps are increasingly central to super-app ecosystems, yet architectural differences complicate the transfer of security analysis techniques across platforms. Existing WeChat analyzers rely on packaged applications and platform-specific APIs, limiting their direct applicability to Telegram’s web-based MiniApps. , 2023), and prior security analyses at scale
(Meng et al. , 2023; Wang, Ko, Zhang, Yang, & Lin, 2023; Z. (2024) propose MiniCAT, an automated analysis framework that crawls and unpacks WeChat Mini Programs and reconstructs
attack paths across logic-layer JavaScript and render-layer WXML. Yang, Zhang,
and Lin (2022) introduce Cross-MiniApp Request Forgery (CMRF), where a malicious MiniApp forges requests to another MiniApp by exploiting missing checks on
the sender’s appId (the platform-assigned identifier for a registered Mini Program,
see Section 6). More recently, Ferrari, Ceccato, and Verderame (2026) present TeleGapper, a black-box dynamic analysis framework for investigating the privacy practices of Telegram MiniApps. The framework captures runtime network traffic, identifies communications with third parties, and compares observed data flows with the
applications’ disclosed privacy information. , 2023), and prior security analyses at scale
(Meng et al. , 2023; Wang, Ko, Zhang, Yang, & Lin, 2023; Z. (2024) propose MiniCAT, an automated analysis framework that crawls and unpacks WeChat Mini Programs and reconstructs
attack paths across logic-layer JavaScript and render-layer WXML. Yang, Zhang,
and Lin (2022) introduce Cross-MiniApp Request Forgery (CMRF), where a malicious MiniApp forges requests to another MiniApp by exploiting missing checks on
the sender’s appId (the platform-assigned identifier for a registered Mini Program,
see Section 6). More recently, Ferrari, Ceccato, and Verderame (2026) present TeleGapper, a black-box dynamic analysis framework for investigating the privacy practices of Telegram MiniApps. The framework captures runtime network traffic, identifies communications with third parties, and compares observed data flows with the
applications’ disclosed privacy information. , 2023), and prior security analyses at scale
(Meng et al. , 2023; Wang, Ko, Zhang, Yang, & Lin, 2023; Z. (2023), and Wang, Zhang, and Lin (2023) further show that WeChat security
depends on subtle interactions among packaging, identity, APIs, and platform-version
differences, consistent with related measurement work (Y. Zhang, Turkistani, Yang,
Zuo, & Lin, 2021). , 2023), and prior security analyses at scale
(Meng et al. , 2023; Wang, Ko, Zhang, Yang, & Lin, 2023; Z. This convention also separates the generic abstraction studied in
this paper from platform-specific packaging and runtime names. In this paper, we present a comparative study of WeChat Mini Programs and Telegram MiniApps, characterizing their architectural and security differences and establishing a basis for future automated vulnerability-detection methods. Zhang, Yang, and Lin (2023), Baskaran, Zhao, Mannan, and Youssef (2023), Wang,
Ko, et al. (2023), and Wang, Zhang, and Lin (2023) further show that WeChat security
depends on subtle interactions among packaging, identity, APIs, and platform-version
differences, consistent with related measurement work (Y. (2024) propose MiniCAT, an automated analysis framework that crawls and unpacks WeChat Mini Programs and reconstructs
attack paths across logic-layer JavaScript and render-layer WXML. Yang, Zhang,
and Lin (2022) introduce Cross-MiniApp Request Forgery (CMRF), where a malicious MiniApp forges requests to another MiniApp by exploiting missing checks on
the sender’s appId (the platform-assigned identifier for a registered Mini Program,
see Section 6). More recently, Ferrari, Ceccato, and Verderame (2026) present TeleGapper, a black-box dynamic analysis framework for investigating the privacy practices of Telegram MiniApps. The framework captures runtime network traffic, identifies communications with third parties, and compares observed data flows with the
applications’ disclosed privacy information. , 2023), and prior security analyses at scale
(Meng et al. , 2023; Wang, Ko, Zhang, Yang, & Lin, 2023; Z.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
--- Page 18 ---
Table 4. Comparison of MiniApp architectures and security responsibilities. p. 0 RESEARCH ARTICLE
Comparing WeChat and Telegram MiniApp Security Architectures:
Toward Cross-Platform Analysis
Luca Ferrari a
, Billel Habbati b and Luca Verderame b
a
IMT School for Advanced Studies Lucca, Lucca, Italy; bUniversity of Genoa, Genoa, Italy
ABSTRACT
MiniApps are increasingly central to super-app ecosystems, yet architectural differences complicate the transfer of security analysis techniques across platforms. Existing WeChat analyzers rely on packaged applications and platform-specific APIs, limiting their direct applicability to Telegram’s web-based MiniApps. Telegram MiniApps are less mature as a research target. The closest prior study to
our work is Mohammadi, Moradi, and Atani (2025), who compares Telegram MiniApps
and WeChat Mini Programs while focusing primarily on Telegram attack chains,
TON/blockchain-specific risks, unproxied frontend–backend communication, insecure
configuration practices, limited WebView isolation, and a Telegram-oriented mitigation framework based on QuickJS sandboxing, mandatory HTTPS, MLS encryption,
and wallet verification. Telegram MiniApps are less mature as a research target. The closest prior study to
our work is Mohammadi, Moradi, and Atani (2025), who compares Telegram MiniApps
and WeChat Mini Programs while focusing primarily on Telegram attack chains,
TON/blockchain-specific risks, unproxied frontend–backend communication, insecure
configuration practices, limited WebView isolation, and a Telegram-oriented mitigation framework based on QuickJS sandboxing, mandatory HTTPS, MLS encryption,
and wallet verification. We evaluate both platforms across shared dimensions, including execution environments, bridge communication channels, and credential custody,
distinguishing the component that enforces a security control from the component
responsible for using it correctly. This distinction separates platform properties, such
as bridge-mediated access to host capabilities, from application properties, such as
backend authorization and credential storage. We evaluate both platforms across shared dimensions, including execution environments, bridge communication channels, and credential custody,
distinguishing the component that enforces a security control from the component
responsible for using it correctly. This distinction separates platform properties, such
as bridge-mediated access to host capabilities, from application properties, such as
backend authorization and credential storage. By comparing WeChat’s App-in-App paradigm
with Telegram’s bot-centric model, we identify the key abstractions that automated
analysis frameworks must capture to support cross-platform reasoning. Our contributions are as follows: i) we provide a structured architectural comparison
of WeChat’s App-in-App model and Telegram’s bot-centric web-based MiniApp framework; ii) we analyze the security assumptions, trust boundaries, and attack surfaces
of both ecosystems; iii) we derive requirements for cross-platform security analysis
and illustrate their application through two worked examples concerning credential
roles and context-dependent permission mediation. By comparing WeChat’s App-in-App paradigm
with Telegram’s bot-centric model, we identify the key abstractions that automated
analysis frameworks must capture to support cross-platform reasoning. Our contributions are as follows: i) we provide a structured architectural comparison
of WeChat’s App-in-App model and Telegram’s bot-centric web-based MiniApp framework; ii) we analyze the security assumptions, trust boundaries, and attack surfaces
of both ecosystems; iii) we derive requirements for cross-platform security analysis
and illustrate their application through two worked examples concerning credential
roles and context-dependent permission mediation. By comparing WeChat’s App-in-App paradigm
with Telegram’s bot-centric model, we identify the key abstractions that automated
analysis frameworks must capture to support cross-platform reasoning. Our contributions are as follows: i) we provide a structured architectural comparison
of WeChat’s App-in-App model and Telegram’s bot-centric web-based MiniApp framework; ii) we analyze the security assumptions, trust boundaries, and attack surfaces
of both ecosystems; iii) we derive requirements for cross-platform security analysis
and illustrate their application through two worked examples concerning credential
roles and context-dependent permission mediation. By comparing WeChat’s App-in-App paradigm
with Telegram’s bot-centric model, we identify the key abstractions that automated
analysis frameworks must capture to support cross-platform reasoning. Our contributions are as follows: i) we provide a structured architectural comparison
of WeChat’s App-in-App model and Telegram’s bot-centric web-based MiniApp framework; ii) we analyze the security assumptions, trust boundaries, and attack surfaces
of both ecosystems; iii) we derive requirements for cross-platform security analysis
and illustrate their application through two worked examples concerning credential
roles and context-dependent permission mediation. First, we used official Tencent developer pages
as authoritative sources for platform mechanisms such as package structure, cloud communication, authentication, permission checks, and publication controls. Second, we included peer-reviewed papers returned by searches for WeChat Mini Program security,
MiniApp privacy analysis, taint analysis, cross-MiniApp request forgery, and MiniApp
unpacking, prioritizing studies that reported concrete vulnerabilities, tool implementations, or empirical datasets. First, we used official Tencent developer pages
as authoritative sources for platform mechanisms such as package structure, cloud communication, authentication, permission checks, and publication controls. Second, we included peer-reviewed papers returned by searches for WeChat Mini Program security,
MiniApp privacy analysis, taint analysis, cross-MiniApp request forgery, and MiniApp
unpacking, prioritizing studies that reported concrete vulnerabilities, tool implementations, or empirical datasets.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
--- Page 21 ---
Table 5. Comparison with Mohammadi et al. (2025) across shared security aspects and analytical scope Worked Example 1 (Credential Roles and Backend Authorization). Consider an analysis that encounters a credential in a MiniApp deployment. It must identify the credential’s holder, the principal represented by its use, the receiving component, and the operation being validated Worked Example 2 (Navigation and Context-Dependent Permission Mediation). Consider a tool that flags window.open as a permission bypass because the request does not pass through a MiniApp SDK handler The comparison does not measure vulnerability prevalence or establish behavior across client versions and platforms
--- Page 22 ---
Data availability statement
This study uses official developer documentation, published literature, and the publicly available Telegram Android source code The architectural diagrams, comparative taxonomy, and worked examples are presented in the paper The examples are analytical illustrations, not runtime experiments
--- Page 21 ---
Declaration of AI usage
During the preparation of this manuscript, the authors used ChatGPT (OpenAI, GPT5.5) and Grammarly (Grammarly Premium, web version accessed in 2026) solely for language refinement, including grammar, spelling, clarity, paraphrasing, and stylistic revision The authors reviewed and edited all AI-assisted suggestions, verified the originality and accuracy of the manuscript
--- Page 21 ---
Data availability statement
This study uses official developer documentation, published literature, and the publicly available Telegram Android source code The architectural diagrams, comparative taxonomy, and worked examples are presented in the paper The examples are analytical illustrations, not runtime experiments
--- Page 21 ---
Declaration of AI usage
During the preparation of this manuscript, the authors used ChatGPT (OpenAI, GPT5.5) and Grammarly (Grammarly Premium, web version accessed in 2026) solely for language refinement, including grammar, spelling, clarity, paraphrasing, and stylistic revision The authors reviewed and edited all AI-assisted suggestions
--- Page 21 ---
Declaration of AI usage
During the preparation of this manuscript, the authors used ChatGPT (OpenAI, GPT5.
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Automated analysis frameworks can be developed that distinguish between platform properties, such as
bridge-mediated access to host capabilities,
and application properties, such asbackend authorization and credential storage.
This allows for more accurate modeling of security controls by separating what enforces a control from what uses it correctly. -
Cross-platform analysis systems can incorporate requirements derived from worked examples to perform credential role analysis, identifying
the principal represented by its use
in both WeChat and Telegram contexts. This enables the system to tracethe authenticated identity to the resource-authorization decision, separately from checks on platform credentials.
-
Systems can be designed for context-dependent permission mediation by associating
host capabilities with concrete execution contexts and permission handlers.
This involves mapping specific bridge names or navigation events to their underlying bot context mode, as noted in the paper's discussion ofTelegramWebviewProxy
versusWebViewProxy.
Abstract
MiniApps are increasingly central to super-app ecosystems, yet architectural differences complicate the transfer of security analysis techniques across platforms. Existing WeChat analyzers rely on packaged applications and platform-specific APIs, limiting their direct applicability to Telegram's web-based MiniApps. We present a qualitative comparison of WeChat Mini Programs and Telegram MiniApps, grounded in official documentation, prior research, and manual analysis of a specific Telegram Android source revision. Using a shared taxonomy of security controls, assets, and threat sources, we examine execution environments, communication paths, and trust boundaries. WeChat provides a dedicated MiniApp runtime; Telegram combines web execution with host controls. Both retain developer responsibilities for backend authentication and resource authorization. Two worked examples derive requirements for cross-platform analysis: distinguishing credential roles and validation boundaries, and associating host capabilities with concrete execution contexts and permission handlers. These findings inform future automated analysis without ranking the ecosystems by security or claiming validated vulnerability detection.
Sources
Related papers
- From Strategy Search to Policy Learning: MCTS-Guided Adversarial Co-Evolution for LLM Safety Alignment
- Privacy Leakage from Recurrent State in LLM Inference
- Incrementally Verifiable Oracle Aided Computation
- Privilege and confidentiality in generative AI workflows
- BadMoE: Backdooring Mixture-of-Experts LLMs via Routing-Aware Triggers and Task-Underutilized Experts
- CoVault: Secure, Scalable Analytics of Personal Data