CVE-2026-33620: PinchTab API Bearer Token Exposed Vulnerability

MODERATE
Advisory Identifier: GHSA-mrqc-3276-74f8
CVSS 4.3
CWE-598
Published
Advisory Summary

CVE-2026-33620 is a MODERATE (CVSS 4.3) api bearer token exposed vulnerability (CWE-598: Use of HTTP Request With Sensitive Query String) affecting PinchTab libraries in the Go ecosystem. The issue involves api bearer token exposed in url query parameter via server logs and intermediary systems. Remediation is available by upgrading affected packages to version 0.8.4.

CVE-2026-33620 at a Glance

CVE Identifier CVE-2026-33620
GHSA Identifier GHSA-mrqc-3276-74f8
Severity MODERATE
CVSS v3.1 Base Score 4.3
CWE Classification CWE-598: Use of HTTP Request With Sensitive Query String
Affected Product PinchTab
Package Ecosystem Go
Published Date
Last Updated

Security Impact

CVSS: 4.3

The security impact metrics below are parsed directly from the CVSS v3.1 vector string (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N).

Attack Vector Network (AV:N)
Attack Complexity Low (AC:L)
Privileges Required None (PR:N)
User Interaction Required (UI:R)
Scope Unchanged (S:U)
Confidentiality Low (C:L)
Integrity None (I:N)
Availability None (A:N)

How to Fix CVE-2026-33620

To remediate this vulnerability, upgrade all affected PinchTab dependencies to a patched release. Both direct and transitive dependencies should be checked, as frameworks or security libraries may pull in vulnerable versions transitively.

github.com/pinchtab/pinchtab fixed: 0.8.4
Upgrade github.com/pinchtab/pinchtab to 0.8.4
Verify Direct and Transitive Dependencies

Run the following command in your project directory to verify that all resolved dependencies use the patched release:

inspect dependencies for github.com/pinchtab/pinchtab

How to Check if You Are Affected

To determine whether your application is affected by CVE-2026-33620, inspect your project dependencies for PinchTab:

inspect dependencies for github.com/pinchtab/pinchtab

Analyze the terminal output to locate any version of PinchTab in your dependency tree. If any resolved version matches the vulnerable ranges listed in the table below (for example, versions earlier than 0.8.4), your application is affected.

Note: Verify declared build manifests and deployed runtime container environments.

Technical Details

Vulnerability Mechanism & Technical Analysis

This vulnerability is classified under CWE-598: Use of HTTP Request With Sensitive Query String, where the web application uses an http method to process a request, but the request includes sensitive information in the query string. In PinchTab, software state validation or input boundaries are circumvented during processing. Review the official source advisory statement below for specific affected components, classes, and reproduction details.

Source Advisory Statement

### Summary PinchTab `v0.7.8` through `v0.8.3` accepted the API token from a `token` URL query parameter in addition to the `Authorization` header. When a valid API credential is sent in the URL, it can be exposed through request URIs recorded by intermediaries or client-side tooling, such as reverse proxy access logs, browser history, shell history, clipboard history, and tracing systems that capture full URLs. This issue is an unsafe credential transport pattern rather than a direct authentication bypass. It only affects deployments where a token is configured and a client actually uses the query-parameter form. PinchTab's security guidance already recommended `Authorization: Bearer <token>`, but `v0.8.3` still accepted `?token=` and included first-party flows that generated and consumed URLs containing the token. This was addressed in v0.8.4 by removing query-string token authentication and requiring safer header- or session-based authentication flows. ### Details **Issue 1 — Query-string token accepted in `v0.7.8` through `v0.8.3` (`internal/handlers/middleware.go`):** The `v0.8.3` authentication middleware accepted credentials from the URL query string: ``` // internal/handlers/middleware.go — v0.8.3 auth := r.Header.Get("Authorization") qToken := r.URL.Query().Get("token") if auth == "" && qToken == "" { web.ErrorCode(w, 401, "missing_token", "unauthorized", false, nil) return } provided := strings.TrimPrefix(auth, "Bearer ") if provided == auth { if qToken != "" { provided = qToken } else { provided = auth } } if subtle.ConstantTimeCompare([]byte(provided), []byte(cfg.Token)) != 1 { web.ErrorCode(w, 401, "bad_token", "unauthorized", false, nil) return } ``` This means any client sending `GET /health?token=<secret>` in `v0.8.3` would authenticate successfully without using the `Authorization` header. I verified the same query-token auth pattern is present in the historical tag range starting at `v0.7.8`, and it is removed in `v0.8.4`. **Issue 2 — First-party setup and dashboard flows in `v0.8.3` generated and consumed `?token=` URLs:** The `v0.8.3` setup flow generated dashboard URLs containing the token in the query string: ``` // cmd/pinchtab/cmd_wizard.go — v0.8.3 func dashboardURL(cfg *config.FileConfig, path string) string { host := orDefault(cfg.Server.Bind, "127.0.0.1") port := orDefault(cfg.Server.Port, "9867") url := fmt.Sprintf("http://%s:%s%s", host, port, path) if cfg.Server.Token != "" { url += "?token=" + cfg.Server.Token } return url } ``` The `v0.8.3` dashboard frontend also supported one-click login from that same query-string token: ``` // dashboard/src/App.tsx — v0.8.3 const params = new URLSearchParams(window.location.search); const urlToken = params.get("token"); if (urlToken) { setStoredAuthToken(urlToken); clean.searchParams.delete("token"); window.history.replaceState({}, "", clean.pathname + clean.hash); window.location.reload(); } ``` That combination materially increased the chance that users would open, copy, paste, bookmark, or log URLs containing live credentials before the token was scrubbed from the visible address bar. **Issue 3 — Exposure depends on surrounding systems recording the URL:** PinchTab's own request logger records `r.URL.Path`, not the full raw query string, so the leak is not primarily through PinchTab's structured application log. The risk comes from surrounding systems or client tooling that record the full request URI, such as: 1. reverse proxies and load balancers 2. browser history or bookmarks 3. shell history containing full `curl` commands 4. clipboard or terminal history when the wizard prints and copies a tokenized URL 5. tracing or monitoring systems that capture full request URLs ### PoC **Step 1 — Confirm auth is required** ```bash curl -i http://localhost:9867/health ``` Expected in token-protected affected deployments: ```http HTTP/1.1 401 Unauthorized ``` **Step 2 — Authenticate using the vulnerable query-parameter pattern** ```bash curl -i "http://localhost:9867/health?token=supersecrettoken" ``` Expected: ```http HTTP/1.1 200 OK ``` This demonstrates that the token is accepted from the URL. **Step 3 — Observe the exposure vector** If the request traverses a system that records the full URI, the token may appear in logs or local history, for example: ```text GET /health?token=supersecrettoken HTTP/1.1 ``` In `v0.8.3`, a first-party reproduction path also exists without any external proxy: run the setup wizard, copy the printed dashboard URL containing `?token=...`, and note that the live credential is now present in clipboard history and any place that URL is pasted. ### Impact 1. Exposure of a valid API token through unsafe URL-based transport when a client uses the `?token=` authentication form. 2. Lower barrier for credential compromise where reverse proxies, browser history, shell history, clipboard history, or tracing systems retain full request URIs. 3. The `v0.8.3` wizard/dashboard flow increased the practical likelihood of this exposure by generating and consuming tokenized URLs as a first-party login pattern. 4. Practical risk depends on actual use of the query-token pattern; deployments that use only `Authorization: Bearer <token>` are not affected by this issue in practice. 5. This is not a direct authentication bypass. An attacker still needs access to a secondary source that captured the URL containing the token. ### Suggested Remediation 1. Reject query-string token authentication and accept credentials only through the `Authorization` header or controlled session mechanisms. 2. Avoid generating user-facing URLs that contain live credentials. 3. Document header-based auth as the only supported non-browser API authentication pattern. 4. Recommend token rotation for users who may previously have used query-parameter authentication. **Screenshot Capture** <img width="1162" height="164" alt="ภาพถ่ายหน้าจอ 2569-03-18 เวลา 12 46 08" src="https://github.com/user-attachments/assets/e68b4469-dafd-400d-a6e1-f74d368cc8ac" />

CVE-2026-33620 Affected PinchTab Versions

1 component(s)
Fixed Versions:
0.8.4
Product / Package Ecosystem Affected Versions Fixed Version
github.com/pinchtab/pinchtab
Go
≥ 0.7.8
< 0.8.4
0.8.4

References

Frequently Asked Questions

What is CVE-2026-33620?
CVE-2026-33620 is a security vulnerability in PinchTab involving API Bearer Token Exposed in URL Query Parameter via Server Logs and Intermediary Systems under CWE-598: Use of HTTP Request With Sensitive Query String.
Which PinchTab versions are affected?
Affected versions include releases prior to 0.8.4 across affected packages: github.com/pinchtab/pinchtab.
What version fixes CVE-2026-33620?
Upgrading to 0.8.4 (or the latest patched release for your respective branch) resolves the vulnerability.
Is github.com/pinchtab/pinchtab affected?
Yes, github.com/pinchtab/pinchtab is affected in releases prior to 0.8.4. Upgrade your dependency to 0.8.4 or later.
What is the CVSS score of CVE-2026-33620?
CVE-2026-33620 has a CVSS v3.1 base score of 4.3 (MODERATE) with vector string CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N.
What CWE is associated with CVE-2026-33620?
CVE-2026-33620 is classified under CWE-598: Use of HTTP Request With Sensitive Query String (The web application uses an HTTP method to process a request, but the request includes sensitive information in the query string.).
How can I check Go dependencies for CVE-2026-33620?
Run the dependency tree command: 'inspect dependencies for github.com/pinchtab/pinchtab'. This command lists direct and transitive dependencies in your build configuration so you can verify if a vulnerable version is resolved.
Machine-readable OSV JSON OSV v1.5 Schema
Normalized schema output
{
  "schema_version" : "1.4.0",
  "id" : "GHSA-mrqc-3276-74f8",
  "modified" : "2026-03-27T21:18:50Z",
  "published" : "2026-03-24T19:33:23Z",
  "aliases" : [ "CVE-2026-33620" ],
  "summary" : "PinchTab: API Bearer Token Exposed in URL Query Parameter via Server Logs and Intermediary Systems",
  "details" : "### Summary\nPinchTab `v0.7.8` through `v0.8.3` accepted the API token from a `token` URL query parameter in addition to the `Authorization` header. When a valid API credential is sent in the URL, it can be exposed through request URIs recorded by intermediaries or client-side tooling, such as reverse proxy access logs, browser history, shell history, clipboard history, and tracing systems that capture full URLs.\n\nThis issue is an unsafe credential transport pattern rather than a direct authentication bypass. It only affects deployments where a token is configured and a client actually uses the query-parameter form. PinchTab's security guidance already recommended `Authorization: Bearer <token>`, but `v0.8.3` still accepted `?token=` and included first-party flows that generated and consumed URLs containing the token.\n\nThis was addressed in v0.8.4 by removing query-string token authentication and requiring safer header- or session-based authentication flows.\n\n### Details\n**Issue 1 — Query-string token accepted in `v0.7.8` through `v0.8.3` (`internal/handlers/middleware.go`):**\nThe `v0.8.3` authentication middleware accepted credentials from the URL query string:\n\n```\n// internal/handlers/middleware.go — v0.8.3\nauth := r.Header.Get(\"Authorization\")\nqToken := r.URL.Query().Get(\"token\")\n\nif auth == \"\" && qToken == \"\" {\n    web.ErrorCode(w, 401, \"missing_token\", \"unauthorized\", false, nil)\n    return\n}\n\nprovided := strings.TrimPrefix(auth, \"Bearer \")\nif provided == auth {\n    if qToken != \"\" {\n        provided = qToken\n    } else {\n        provided = auth\n    }\n}\n\nif subtle.ConstantTimeCompare([]byte(provided), []byte(cfg.Token)) != 1 {\n    web.ErrorCode(w, 401, \"bad_token\", \"unauthorized\", false, nil)\n    return\n}\n```\n\nThis means any client sending `GET /health?token=<secret>` in `v0.8.3` would authenticate successfully without using the `Authorization` header. I verified the same query-token auth pattern is present in the historical tag range starting at `v0.7.8`, and it is removed in `v0.8.4`.\n\n**Issue 2 — First-party setup and dashboard flows in `v0.8.3` generated and consumed `?token=` URLs:**\nThe `v0.8.3` setup flow generated dashboard URLs containing the token in the query string:\n\n```\n// cmd/pinchtab/cmd_wizard.go — v0.8.3\nfunc dashboardURL(cfg *config.FileConfig, path string) string {\n    host := orDefault(cfg.Server.Bind, \"127.0.0.1\")\n    port := orDefault(cfg.Server.Port, \"9867\")\n    url := fmt.Sprintf(\"http://%s:%s%s\", host, port, path)\n    if cfg.Server.Token != \"\" {\n        url += \"?token=\" + cfg.Server.Token\n    }\n    return url\n}\n```\n\nThe `v0.8.3` dashboard frontend also supported one-click login from that same query-string token:\n\n```\n// dashboard/src/App.tsx — v0.8.3\nconst params = new URLSearchParams(window.location.search);\nconst urlToken = params.get(\"token\");\nif (urlToken) {\n    setStoredAuthToken(urlToken);\n    clean.searchParams.delete(\"token\");\n    window.history.replaceState({}, \"\", clean.pathname + clean.hash);\n    window.location.reload();\n}\n```\n\nThat combination materially increased the chance that users would open, copy, paste, bookmark, or log URLs containing live credentials before the token was scrubbed from the visible address bar.\n\n**Issue 3 — Exposure depends on surrounding systems recording the URL:**\nPinchTab's own request logger records `r.URL.Path`, not the full raw query string, so the leak is not primarily through PinchTab's structured application log. The risk comes from surrounding systems or client tooling that record the full request URI, such as:\n\n1. reverse proxies and load balancers\n2. browser history or bookmarks\n3. shell history containing full `curl` commands\n4. clipboard or terminal history when the wizard prints and copies a tokenized URL\n5. tracing or monitoring systems that capture full request URLs\n\n### PoC\n**Step 1 — Confirm auth is required**\n\n```bash\ncurl -i http://localhost:9867/health\n```\n\nExpected in token-protected affected deployments:\n\n```http\nHTTP/1.1 401 Unauthorized\n```\n\n**Step 2 — Authenticate using the vulnerable query-parameter pattern**\n\n```bash\ncurl -i \"http://localhost:9867/health?token=supersecrettoken\"\n```\n\nExpected:\n\n```http\nHTTP/1.1 200 OK\n```\n\nThis demonstrates that the token is accepted from the URL.\n\n**Step 3 — Observe the exposure vector**\nIf the request traverses a system that records the full URI, the token may appear in logs or local history, for example:\n\n```text\nGET /health?token=supersecrettoken HTTP/1.1\n```\n\nIn `v0.8.3`, a first-party reproduction path also exists without any external proxy: run the setup wizard, copy the printed dashboard URL containing `?token=...`, and note that the live credential is now present in clipboard history and any place that URL is pasted.\n\n### Impact\n1. Exposure of a valid API token through unsafe URL-based transport when a client uses the `?token=` authentication form.\n2. Lower barrier for credential compromise where reverse proxies, browser history, shell history, clipboard history, or tracing systems retain full request URIs.\n3. The `v0.8.3` wizard/dashboard flow increased the practical likelihood of this exposure by generating and consuming tokenized URLs as a first-party login pattern.\n4. Practical risk depends on actual use of the query-token pattern; deployments that use only `Authorization: Bearer <token>` are not affected by this issue in practice.\n5. This is not a direct authentication bypass. An attacker still needs access to a secondary source that captured the URL containing the token.\n\n### Suggested Remediation\n1. Reject query-string token authentication and accept credentials only through the `Authorization` header or controlled session mechanisms.\n2. Avoid generating user-facing URLs that contain live credentials.\n3. Document header-based auth as the only supported non-browser API authentication pattern.\n4. Recommend token rotation for users who may previously have used query-parameter authentication.\n\n**Screenshot Capture**\n<img width=\"1162\" height=\"164\" alt=\"ภาพถ่ายหน้าจอ 2569-03-18 เวลา 12 46 08\" src=\"https://github.com/user-attachments/assets/e68b4469-dafd-400d-a6e1-f74d368cc8ac\" />",
  "severity" : [ {
    "type" : "CVSS_V3",
    "score" : "CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N"
  } ],
  "affected" : [ {
    "package" : {
      "ecosystem" : "Go",
      "name" : "github.com/pinchtab/pinchtab"
    },
    "ranges" : [ {
      "type" : "ECOSYSTEM",
      "events" : [ {
        "introduced" : "0.7.8"
      }, {
        "fixed" : "0.8.4"
      } ]
    } ]
  } ],
  "references" : [ {
    "type" : "WEB",
    "url" : "https://github.com/pinchtab/pinchtab/security/advisories/GHSA-mrqc-3276-74f8"
  }, {
    "type" : "ADVISORY",
    "url" : "https://nvd.nist.gov/vuln/detail/CVE-2026-33620"
  }, {
    "type" : "PACKAGE",
    "url" : "https://github.com/pinchtab/pinchtab"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/pinchtab/pinchtab/releases/tag/v0.8.4"
  } ],
  "database_specific" : {
    "cwe_ids" : [ "CWE-598" ],
    "severity" : "MODERATE",
    "github_reviewed" : true,
    "github_reviewed_at" : "2026-03-24T19:33:23Z",
    "nvd_published_at" : "2026-03-26T21:17:06Z"
  }
}