This policy explains how to report vulnerabilities in Download Engine, what the application trusts, and where its protections end. It covers the Windows, macOS and Linux desktop app, download engine, CLI, local MCP server, browser extensions, native messaging host, installer, packaging, and bundled integrations.
Report suspected vulnerabilities privately. Do not publish exploit details, credentials, private URLs, or profile data in an issue or pull request.
- Supported versions
- Report a vulnerability
- Handling and disclosure
- Security model
- Browser permissions and native messaging
- Automation and custom site readers
- Local MCP access
- Local data and credentials
- Packages and dependencies
- Testing and report scope
| Version | Security maintenance |
|---|---|
| Latest released version | Target for security fixes. |
| Older releases | No separate security-update branch; upgrade to the latest release. |
| Development and locally modified builds | Useful for reproductions, but not a separately maintained release line. |
Check Help → About or de-cli.exe --version for the app version, and the
browser's extension details for its version. Keep the app and extension aligned;
reload developer-loaded extensions after updating their files. A changed extension
identity, such as Firefox's 3.0 migration, requires a fresh installation rather
than just a reload. See the changelog and
upgrade guidance.
On the project's GitHub repository, open Security and quality (or Security) and choose Report a vulnerability, when available. This requires the repository owner to enable private vulnerability reporting; this policy does not enable it. See GitHub's private reporting guide.
If that option is unavailable, open an issue asking only for a private security contact, without describing the vulnerability or attaching files. Wait for a private channel before sharing details. Ordinary bugs and feature requests can use public issues.
Include enough information to understand the problem and reproduce it safely. A complete exploit is not required:
- Environment: app and extension versions, OS/browser versions, installed or portable mode, and the affected component.
- Preconditions: enabled features, permissions, proxy mode, script access, or user interaction needed to trigger the issue.
- Reproduction: minimal steps and a harmless fixture or synthetic input, with expected and actual results.
- Impact: what an attacker controls, what they can gain, and which security boundary is crossed.
- Evidence: redacted errors, logs, screenshots, or a small proof of concept. State whether the latest release is affected if you can check safely.
For a malicious media file, archive, script, or manifest, first describe the input and its effect in the private report. Arrange safe sharing with the maintainer instead of posting it publicly or sending someone an unlabelled executable.
Remove passwords, cookies, authentication headers, MCP access tokens, signed download URLs, account identifiers, and personal file paths. Query strings and referrers can contain secrets even when no password is visible.
Do not upload your real queue database, portable profile, browser profile, exported download list, or private downloaded files. Use a separate test profile and synthetic data. Automatic log redaction is useful but is not a substitute for reviewing everything you share, especially script output and screenshots.
The intended process is to review the affected version and impact, reproduce the issue, agree on a mitigation or fix, and validate it before coordinating public disclosure. Maintainers may ask for a smaller fixture or more environment details. Security fixes target the latest release, with relevant user-facing changes in the changelog and an advisory when appropriate.
Response and fix times depend on availability and severity; there is no guaranteed response time. Please coordinate disclosure through the private report so affected users can receive a fix or mitigation first. If you plan to publish findings, tell the maintainer your proposed timeline in that channel.
Download Engine runs under your user account. It treats remote pages, server responses, filenames, manifests, archives, and browser handoffs as untrusted input. Its validation is intended to prevent that input from gaining unintended access to local files, credentials, or app control.
These are application controls, not operating-system isolation. A program already running as your user can have access to the same files and OS credential facilities. The app does not protect a compromised user account.
- HTTPS uses certificate validation. Plain HTTP and FTP do not provide encrypted transport; prefer HTTPS or FTPS when the source supports it.
- New Windows downloads and recovered publications receive Mark of the Web before completion. Older completed files are not retroactively marked. The marker supports Windows handling of internet files; it is not a safety verdict.
- File handling rejects unsafe filenames and linked destinations in protected write paths. Temporary-file and publication checks aim to prevent unintended overwrites and writes through links.
- A checksum verifies bytes against an expected digest. It is useful only when that expected value comes from a source you trust.
- Antivirus scanning is optional and requires a configured, working scanner. A clean result is not a guarantee; some integrations require manual result review in the scanner's own app.
- Treat downloaded files and offline websites as untrusted even after a successful transfer. Opening or running them gives their content to another application.
Read the security reference and antivirus guide for implementation details and scanner behavior.
Torrents are off by default, and only a person using the desktop window can turn them on.
Scripts, the browser extension, MCP and the command line can't add a torrent, even when
torrents are on. While they're off, de-torrent.exe doesn't start.
Everything a torrent brings comes from strangers, including its file names, tracker addresses and peers' messages. That's why this code runs in a separate program:
- The helper runs only while a torrent needs it. Incoming connections are off by default. Windows limits the helper process to 1 GiB of committed memory. Downloads stop uploading at completion; continued sharing requires an explicit sharing session.
- Incoming and outgoing connections share a per-torrent limit, including queued sockets, with a separate limit per source IP. Disconnects, failed handshakes and cancellation release capacity. Incoming sockets cannot fill the queue used for download completion.
- A piece counts only after its SHA-1 hash matches, and a peer that sends bad pieces is dropped and banned.
- File names can't leave the torrent's folder, and the app checks the helper's paths again before using them.
- Each new torrent gets a newly created staging directory. The desktop records its filesystem identity in the profile. The helper verifies that identity and opens each path component relative to an open directory, refusing linked directories and hard-linked payload files. On Windows the helper also rejects reparse points and marks payload files as Internet downloads.
- Completed torrents move into place without replacing existing entries. Resume, cleanup and recovery check the recorded identity. When upgrading an older partial download, the app can copy hash-verified pieces into fresh staging and leaves the original folder intact.
- Tracker addresses can't lead to this computer or its local network, and trackers can't redirect the helper anywhere else. Stranger-supplied peer addresses and DHT nodes use the same public-address policy, including mapped IPv6, link-local and CGNAT addresses.
- A magnet's privacy status is unknown until its metadata is hash-checked. Metadata
discovery uses only its trackers; private or unknown torrents never query public DHT.
A trackerless magnet requires cached metadata or a
.torrentfile. - Metainfo decoding limits files, path components and aggregate filename bytes. Tracker lists, response bodies, concurrent requests and polling rates are bounded. Metadata collectors reserve per-torrent and process-wide memory budgets before accepting data, allocate chunks only as they arrive, and reject repeated metadata handshakes.
- Trackers can supply at most 200 peer results per response. Discovery uses a bounded queue and a shared limit of 5,000 unique addresses across trackers, DHT and peer exchange. Once that limit is reached, tracker announcements continue without adding more peers.
A verified torrent can still contain harmful files, because a hash only proves that the file is the one the torrent describes. Treat files from a torrent as you would any other download from an unknown source.
Torrents contact many addresses, so security software may report blocked connections while one runs. Keep those blocks in place. Anything your security software stops only means fewer peers.
The extension passes supported download requests to the local native messaging host, which hands them to the desktop app. Registered hosts restrict extension identities, and native messages have a fixed action schema and a 1 MiB size limit. Extension pages use packaged scripts/styles with a restrictive content security policy; the extension does not execute downloaded files.
The permissions correspond to these features:
| Capability | What it is used for |
|---|---|
| Native messaging | Connect the extension to the installed or portable desktop copy. |
| Download access | Capture eligible file downloads and manage the browser side of a handoff. |
HTTP/HTTPS site access and webRequest |
Discover supported media response URLs and metadata across pages and media CDNs. |
| Active tab and scripting | Inspect the selected page for supported links/media and provide on-page controls. |
| Local/session storage and alarms | Retain settings and bounded pending handoff or discovery state. |
| Optional cookies | Copy matching cookies only through the browser-login workflow after permission and review. |
File capture and passive media detection default to on after installation permissions are accepted. Saved off choices are preserved within the same extension identity; Firefox's new 3.0 identity starts with fresh settings. Passive detection reads response URLs, MIME types, and reported sizes, not request headers, cookies, or response bodies. It does not automatically preview or download a detected video. Its bounded discovery list is held in browser session storage and can include signed URLs. Turning a feature off does not necessarily revoke permissions shared with another feature; review permissions in the browser's extension settings.
An explicitly requested HLS/DASH review may include the browser's own User-Agent. It is bounded to 512 printable ASCII bytes and kept with the selected stream for preview and resume. No arbitrary header map is accepted. The desktop retains its origin-only Referer and existing DNS, redirect, HTTPS and proxy restrictions; reviewed browser streams can retry HTTP 403 once with Origin derived from that same sanitized page origin. Successful choices are reused per media-server origin in memory; a later 403 can retry without Origin. HTTP 401 is not retried, and explicit site headers are not replaced by this fallback. Neither page header is sent on an HTTPS-page-to-HTTP-request downgrade, and this does not grant browser-session access. Diagnostics report only whether the browser identity was included and whether an Origin retry occurred, never the header values.
After desktop HTTP 403, a reviewed stream may use browser_video_relay_v1.
The extension binds its connection to the reviewed top-level tab/document,
page and at most 16 media origins. An ephemeral UUID capability authenticates
framed IPC on literal 127.0.0.1; it is not an HTTP proxy endpoint. GETs omit
credentials, refuse redirects, and retain normal browser TLS/CORS enforcement.
Native frames stay below 1 MiB, chunks at most 48 KiB, and responses at most
256 MiB (or the requested byte-range length). Pull-based delivery, eight active
requests per connection, cancellation and six-hour expiry bound resource use.
Desktop validation still checks destination addresses, playlist format, encryption,
range responses and saved-part hashes. However, the browser owns its DNS and
connection: desktop DNS preflight is not connection IP pinning. Consequently
strict public-only jobs and explicit Direct/Custom proxy routes never use this
fallback. Remote media requires HTTPS; an explicitly reviewed loopback HTTP page
can fetch only its own origin. No arbitrary script HTTP API can use this transport.
Browser-login handoffs are separate. For supported direct downloads, they copy matching cookies from the reviewed site into an encrypted per-download snapshot. They do not read browser passwords or profile databases. Ordinary capture, page link batches, and media scanning remain anonymous. Private browsing is unsupported for these capture/login workflows, and built-in video readers do not inherit your browser login. See browser-login details and browser integration.
Only enable scripts and automatic triggers you have reviewed and trust.
| Mechanism | Access and limits |
|---|---|
| Routing and completion rules | Supported app actions such as assigning queues or starting another queue; no shell execution. |
| Lua automation | Restricted app API for reading state and permitted download/queue actions. It has application-level limits, not an OS sandbox. |
| PowerShell scripts | Normal file, network, and program access under your account. App API restrictions do not confine the PowerShell process. macOS/Linux require an existing PowerShell 7 installation. |
| Custom scanner commands | External programs with your account's permissions; trust both the executable and its arguments. |
| Lua site readers | A separate API for fetching public pages and returning supported files/streams; they cannot inspect or change existing downloads through the automation API. |
| Extensions | Packages of Lua jobs, each in its own worker with the limits of its kind. Rust holds xd.fetch and xd.add to the hosts a package declares. These are application-level limits, not an OS sandbox, and publishers are not verified, so install only from people you trust. See Extensions. |
Custom readers' network requests and returned downloads are restricted to public destinations, including redirects and stream segments. The reader path validates and pins resolved addresses and requires Direct connection; system and custom proxies are refused rather than used as an unchecked fallback. Browser cookies and saved logins are not supplied to readers. On cross-origin redirects, script-supplied headers are removed and forwarding a POST body is refused.
These public-only rules apply specifically to custom-reader traffic; ordinary user-added downloads retain their documented network/proxy behavior. Reader jobs created before 1.21.2 did not retain this distinction and must be re-added to gain the persisted restriction. See site-reader limits and script permissions.
MCP is an optional authenticated Streamable HTTP server on loopback, normally
http://127.0.0.1:17842/mcp. The listener checks the local Host/Origin and requires
the profile's bearer token. It is intended for trusted clients on the same computer,
not public hosting or remote access through a tunnel or port forward.
- The desktop server starts disabled; new desktop settings use View only.
- Allow changes lets a client perform exposed mutations, including running saved PowerShell scripts. Treat this as authority to run those scripts under your account, not just permission to view downloads.
- The terminal command
de-cli.exe mcpallows changes by default. Usede-cli.exe mcp --read-onlyfor a read-only terminal server; it hides mutation tools and rejects attempts to call them. - View only still exposes information available through read tools. Only connect clients you trust with that information, and consider where an AI client sends the responses it receives.
- Copied client configuration and access headers contain the token. Do not post them in chat, logs, issues, screenshots, or shared configuration files.
- Closing the MCP popup or disconnecting an AI client does not stop the server. Use Stop server for the desktop server or stop the separate CLI server. Work already accepted by the app can continue after the server stops.
If a token is exposed, stop all MCP servers for that profile and follow the token rotation instructions. Rotate only the token; do not delete your database or downloads. See the MCP guide for profiles, access modes, and connection troubleshooting.
Windows installed profiles normally use %LOCALAPPDATA%\Download Engine; portable
copies use their configured data directory. macOS uses
~/Library/Application Support/Download Engine. Linux uses
$XDG_DATA_HOME/Download Engine or ~/.local/share/Download Engine.
DOWNLOAD_ENGINE_HOME can select a separate profile.
Protected blobs use Windows user-scoped DPAPI or, on macOS/Linux, AES-GCM with a random key held in macOS Keychain or the Linux Secret Service keyring. The native keyring must be available and unlocked; there is no plaintext fallback. A Windows DPAPI blob cannot be decrypted after copying a profile to macOS/Linux.
| Data | Protection and sharing considerations |
|---|---|
| Queue database and command records | Not encrypted; may contain URLs, signed query parameters, filenames, local paths, and download history. |
| Supported saved site/proxy credentials | Stored using Windows Credential Manager, macOS Keychain or Linux Secret Service. Other programs under the same account remain outside the isolation boundary. |
| Browser-login snapshots | Encrypted using the protected-blob mechanism above before database storage and scoped to the associated download/origin. |
| MCP access token | Stored as a protected blob in the profile's mcp-token.dpapi (the filename is retained on native platforms); copied client configuration contains the usable token. |
| Saved scripts and script output | Stored locally; source and output can contain anything the script author includes. Review before sharing. |
| Extension settings | Plain settings are stored locally. secret and aes_key settings use protected blobs. A secret reaches the job as text, so its code could still write it to a run log. |
| Diagnostics and exported lists | Can expose operational details or private URLs. Redact them manually; an export is not a safe anonymized profile. |
Keep the application, portable folder, and profile writable only by accounts you trust. Credential protection does not encrypt the whole profile, prevent access by another program running as you, or guarantee portable secrets will work under another account or operating system. Secure backups of profiles and downloads separately.
Current Windows release packages use explicit Unsigned / UnsignedSetup filenames and have no verified Authenticode publisher signature. Release checksums help detect changed bytes when compared with a trusted copy of the checksum list; they are not a substitute for code signing or an independent security review.
macOS bundles are ad-hoc signed for local integrity, not Developer ID signed or Apple-notarized. Linux is distributed as an x64 archive with documented runtime requirements. See the native-platform guide for signing, desktop integration and validation limits.
Use the project's published release assets rather than repackaged binaries. Keep the app, extension, and bundled media helper from the matching release together. The supplied browser ZIPs are not proof of store approval; permanent Firefox installation requires Mozilla signing.
Bundled FFmpeg processes untrusted media through a controlled local-file workflow. It remains third-party native code that needs security maintenance. The original app code and bundled dependencies have separate licenses and source obligations; see third-party notices.
Maintainers should follow the release workflow, verify the source inventory and package contents, run relevant regressions, and check dependencies against current advisories. A clean dependency audit means no matching published advisory was found at that time; it does not establish that the app has no vulnerabilities. Publishing this policy does not certify an audit or enable GitHub's private reporting setting.
Test only on systems, accounts, and data you own or are authorized to assess. Prefer isolated profiles, loopback fixtures, and synthetic files. Do not access other users' data, use stolen credentials, disrupt services, or test third-party video platforms on the project's behalf.
Useful security reports include unexpected file writes or path escapes, credential leaks, unsafe cross-origin forwarding, unintended private-network access from a restricted reader, unauthorized native/MCP actions, and exploitable media or archive parsing failures. Include the attacker-controlled input and any permissions or user actions required.
A trusted PowerShell script intentionally using its documented account access, or a website refusing an unsupported video, is not by itself evidence of a boundary bypass. Unexpected access outside documented permissions is still worth reporting. Ordinary compatibility failures, unavailable qualities, and feature requests can use public issues with private details removed.
These boundaries do not exclude reports of bypasses or unexpected access caused by untrusted input. If you are unsure whether a finding is security-sensitive, start with a private report.