8.7 KiB
Threat model
What Telegram Desktop is and where untrusted input enters
Telegram Desktop is the official desktop client for Telegram, written in C++20 with Qt 6, for Windows, macOS and
Linux. It speaks MTProto 2.0 to Telegram's servers itself (Telegram/SourceFiles/mtproto/), keeps an encrypted local
cache (Telegram/SourceFiles/storage/), and renders everything that users, bots and channels send. The desktop-app
libraries are submodules under Telegram/lib_* (UI and text layout in lib_ui, Lottie in lib_lottie, TL
serialization in lib_tl, webviews in lib_webview, call glue in lib_webrtc, and more). They are part of this
project and in scope. Paths below are relative to Telegram/SourceFiles/ unless they start with Telegram/.
The main attacker is any other Telegram user, bot or channel. Anyone can message the victim, add them to a group or post in a channel they read. Everything such a party controls is untrusted, even though it arrives from Telegram's servers over an authenticated MTProto session:
- message text, entities and formatting (
api/api_text_entities.cpp,Telegram/lib_ui/ui/text/), rich messages and Instant View pages, including markdown and formulas (iv/,iv/markdown/); - names, usernames, bios, file names, captions, polls, contacts, locations, reply and inline keyboards, inline bot
results (
inline_bots/), and link previews (data/data_web_page.cpp); - media: photos, videos, GIFs, voice and video messages, documents, stickers in every format (Lottie TGS through
lib_lottie, WebM, WebP), custom emoji, wallpapers and patterns, themes (window/themes/), and cloud language packs (lang/). Much of this is downloaded and decoded automatically, without a click (media/,ffmpeg/,history/view/media/); - links:
tg://andt.melinks handled incore/local_url_handlers.cpp, including proxy links that change network settings; - bot Mini Apps, payment forms and Instant View webviews. They load web pages written by arbitrary bot or site
owners, which talk to the client through the JavaScript bridge in
ui/chat/attach/attach_bot_webview.cpp,inline_bots/bot_attach_web_view.cpp,iv/andTelegram/lib_webview; - calls and group calls (
calls/,tde2e/,Telegram/ThirdParty/tgcalls): the other party's signaling and media; - received files that the user saves or opens:
core/file_utilities.cpp,data/data_document_resolver.cpp, andcore/mime_type.cpp(Core::DetectNameType, which decides when to warn that a file may be dangerous to open).
The second attacker is on the network: a malicious MTProxy, SOCKS5 or HTTP proxy, or anyone on the path. It sees
only MTProto ciphertext but controls everything before decryption: the transports and the fake-TLS handshake
(mtproto/connection_*.cpp, mtproto/details/mtproto_tls_socket.cpp, mtproto/details/mtproto_tcp_socket.cpp),
auth key creation and server RSA key checks (mtproto/details/mtproto_dc_key_creator.cpp,
mtproto/details/mtproto_rsa_public_key.cpp), and decryption and integrity checks of incoming packets
(mtproto/session_private.cpp).
The third is the update channel. core/update_checker.cpp, core/update_verify.cpp and core/update_unpack.cpp
download, verify and unpack signed update packages.
Lower priority: other local programs that talk to the single-instance socket in core/sandbox.cpp or start the app
with a tg:// link on the command line, and attacker content written into Export Chat History output (export/),
which the user later opens in a browser.
We treat Telegram's servers as honest relays. Data that only the server controls (configuration, data center options, fields no other user can set) is less important than data another user controls, and a report that needs a malicious Telegram server should say so. The local user, the operating system and the files in the user's profile are trusted.
Components that matter most and least
Most important:
mtproto/: everything before and around decryption, and session state;api/,data/,history/: turning server updates into client objects, and rendering messages;media/,ffmpeg/,Telegram/lib_lottie,Telegram/lib_ui(text layout, images, emoji): decoding and drawing attacker-supplied content;iv/,inline_bots/,ui/chat/attach/,payments/,Telegram/lib_webview: webviews and their bridges to native code;core/(link handlers, file opening, the updater),window/themes/,lang/;storage/(local encrypted storage and serialization),passport/(Telegram Passport decryption),calls/,tde2e/,webauthn/(passkeys, including the caBLE tunnel).
Lower priority: settings, boxes and other UI layout code, info/, statistics/, intro/, export/. Code in
platform/win/ and platform/mac/ is in scope for review, but it isn't built in this Linux image.
Out of scope:
- the libraries prebuilt in the base image (Qt, FFmpeg, OpenSSL, WebRTC, OpenAL and others), except where Telegram Desktop misuses them;
- vendored code in
Telegram/ThirdParty/, unless content from Telegram reaches the bug. Then name the upstream project; Telegram/SourceFiles/test/and anything else under#ifdef _DEBUG. This image is a Debug build, but that code is not in release builds;Telegram/build/,docs/, andTelegram/SourceFiles/tests/.
How to exercise it
/src/out/Debug/Telegramis built with-O0 -gand AddressSanitizer. The image setsASAN_OPTIONS=detect_leaks=0. The build tree uses Ninja Multi-Config:cmake --build /src/out --config Debug --target Telegramrebuilds incrementally, and/src/out/compile_commands.jsonhas the exact flags for every source file.- The app needs a display and Telegram's servers, and the scan has neither. The practical way to reproduce a bug is
a small harness that feeds the crafted input to the function in question. Build it with the flags from
compile_commands.jsonand link it against the static libraries in/src/out(find /src/out -name '*.a'). The generated TL (de)serialization code is under/src/outtoo (find /src/out -name 'scheme*'). out/Debug/test_update_verifyandout/Debug/test_update_unpackare standalone harnesses of this kind. Their sources are inTelegram/SourceFiles/tests/and their CMake inTelegram/cmake/test_update_*.cmake.- For received content, show the TL object (constructor and fields) another user can get delivered, and say whether the server is likely to relay it unchanged. Entity offsets, file names and sizes may be validated server-side. For network issues, show the bytes the proxy or network attacker sends.
How we rate severity
- Critical: code execution or memory corruption from content another user, bot or channel sends, with no interaction beyond receiving it or opening the chat (auto-downloaded media, sticker, emoji and link preview rendering). Getting an attacker's file executed without the dangerous-file warning. Bypassing update signature verification. Reading or forging MTProto traffic, or obtaining the auth key, as a proxy or network attacker. Remotely reading local files or session keys.
- High: memory corruption that needs one ordinary action, such as opening a file, playing media, or opening an Instant View page, a Mini App or a link. A Mini App or web page reaching native features without the confirmation the user normally sees: sending messages, sharing the phone number, reading local files, or opening other URL schemes. Writing outside the chosen folder through an attacker-chosen file name. Out-of-bounds reads that send memory contents back to the attacker. A received message that crashes the client on every launch.
- Medium: crashes from received content that go away after a restart (null dereference, uncaught exception, or a
failed
Assert,ExpectsorUnexpected, which stay fatal in release builds). Leaking the user's IP address to a third party without a click or around the configured proxy. UI spoofing that hides a link's real target or a file's real extension. - Low: resource exhaustion without a crash. Script injection into Export Chat History output. Issues that need a malicious Telegram server rank one level below the same issue from a field another user controls.
A buffer overflow, use-after-free or double free reachable from received content is High at least, even without a demonstrated exploit.
Anything to leave alone
- Memory leaks. LeakSanitizer is off on purpose.
api_idandapi_hashvalues in the source, which are public by design (docs/api_credentials.md).- Attacks by someone who already has the user's local account or files, including reading the profile folder of an account without a local passcode.
- Bugs in the prebuilt libraries listed above, unless Telegram Desktop's use of them is the problem.