llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Go · github.com/siyuan-note/siyuan/kernel

GHSA-RPX2-P6HP-X5GJ

SiYuan: Missing consistency check between packageName and repoURL/repoHash in bazaar package install allows overwriting an existing, trusted plugin

Parche disponible
Descargar PNG JSON
CVSS
—
medium
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versióncommit 26ccb40
Exposición27 dDesde la divulgación, 23 oct 2026, 1:38 p. m.
Detección24 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Modificada
Explotación
Remediación
Monitoreo
Detectada
23 oct 26
5 nov 26
17 nov 26
20 nov 26
23 oct 26
30 oct 26
6 nov 26
13 nov 26
20 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-RPX2-P6HP-X5GJ divulgada
Divulgación Modificada Última actualización del registro
Monitoreo Detectada Ingresó al índice
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

Summary

`installBazaarPlugin` (and the equivalent endpoints for widgets/icons/templates/themes) accept
`packageName`, `repoURL`, and `repoHash` as independent request fields with no validation that
they refer to the same package. `packageName` alone determines the install destination;
`repoURL`/`repoHash` alone determine what content gets downloaded and written there. A request
can name an already-installed, already-enabled plugin as `packageName` while pointing `repoURL`/
`repoHash` at different, attacker-influenced content, silently overwriting the existing plugin's
files.

Affected code

`kernel/api/bazaar.go`:

util.BindJsonArg("packageName", &packageName, true, true)
util.BindJsonArg("repoURL", &repoURL, true, true)
util.BindJsonArg("repoHash", &repoHash, true, true)
err := model.InstallBazaarPackage("plugins", repoURL, repoHash, packageName, 0)

`kernel/model/bazaar.go`:

func getPackageInstallPath(pkgType, packageName string) (string, string, error) {
    case "plugins":
        return filepath.Join(util.DataDir, "plugins", packageName), "plugin.json", nil

`kernel/bazaar/install.go`:

func installPackage(data []byte, installPath string) (err error) {
    ...
    if err = filelock.Copy(srcPath, installPath); err != nil { return }
    return
}

`installPath` is derived solely from `packageName`; the downloaded `data` is derived solely from
`repoURL`/`repoHash`; nothing cross-validates them, and `installPackage` performs no check for
whether `installPath` already contains an existing package before copying into it. The same
pattern applies to the widget/icon/template/theme install endpoints, which share
`getPackageInstallPath`.

This does not involve path traversal — `installPath` always resolves inside
`DataDir/plugins/` (or the corresponding directory for other package types), so this is not an
instance of "arbitrary file write outside the workspace path" (excluded by this project's
SECURITY.md). The issue is that the write lands in the *wrong, existing* location within the
intended directory, not outside it — an authorization/identity-verification gap, not a path
traversal.

Reachability / why this is not trivially remote

The bazaar endpoints are gated by `model.CheckAuth`, `model.CheckAdminRole`, `model.CheckReadonly`.
When no lock-screen password is configured (the common desktop default), `CheckAuth` still
enforces a same-origin check:

if !localhost || ... || ("" != origin && !util.IsLocalOrigin(origin)) || ... {
    // reject with 401
}

I verified `IsLocalOrigin`/`IsLocalHostname` correctly parse the `Origin` header via `url.Parse`
and check exact hostname / loopback IP:

func IsLocalOrigin(origin string) bool {
    if u, err := url.Parse(origin); err == nil {
        return IsLocalHostname(u.Hostname())
    }
    return false
}
func IsLocalHostname(hostname string) bool {
    if "localhost" == hostname || strings.HasSuffix(hostname, ".localhost") {
        return true
    }
    if ip := net.ParseIP(hostname); nil != ip {
        return ip.IsLoopback()
    }
    return false
}

This was tested against common bypass patterns (subdomain-suffix tricks like
`localhost.attacker.com`, and `Origin: null` as sent by sandboxed iframes) and found no bypass —
this is a correctly-implemented check. This means a purely remote attacker (e.g. a malicious
website) cannot invoke this endpoint via CSRF; a request must originate from SiYuan's own
renderer origin.

Realistic impact

Given SiYuan runs as an Electron app with `nodeIntegration: true` (per prior advisories in this
repository), a same-origin script-execution primitive (e.g. an XSS bug in the renderer, of which
several have been fixed in this repository recently) is typically already sufficient for direct
code execution. This bug's marginal value is persistence: a transient XSS-driven compromise
can use this endpoint to overwrite an existing, trusted, already-enabled plugin's `index.js`,
converting a one-time compromise into code that runs on every future launch of the application,
surviving after the original XSS vector is closed.

The overwrite does not effect immediately, via this specific
endpoint. `PushReloadPlugin` (the websocket event that triggers frontend hot-reload without
restart) is only called from the batch-update path (`InstallBazaarPackages`, used by
`batchUpdatePackage`), which explicitly checks `if petal != nil && petal.Enabled` before forcing
a reload via `SetPetalEnabled`. The single-package install endpoint (`installBazaarPlugin`) does
not call `PushReloadPlugin` at all — it only pushes a generic success toast. So an overwrite via
this endpoint activates on the next app restart or manual plugin toggle, rather than instantly
still a realistic and frequent event for a desktop application, but not an instant hot-reload.

Suggested fix

Verify that `packageName` matches the package name declared in the downloaded package's own
`plugin.json`/`theme.json`/etc. before copying into `installPath`, and/or refuse to install over
an existing, non-empty destination directory unless the request is explicitly an update of that
same package (matching by source repo identity, not just by request-supplied name).

Verification notes

Confirmed via static source review of `kernel/api/bazaar.go`, `kernel/model/bazaar.go`,
`kernel/bazaar/install.go`, `kernel/model/session.go` (CheckAuth), `kernel/util/net.go`
(IsLocalOrigin/IsLocalHostname), and `kernel/model/push_reload.go` /
`app/src/plugin/loader.ts` (reload trigger wiring). I do not have a running SiYuan instance
in this environment to execute an end-to-end proof of concept; findings are based on tracing
the actual, unmodified control flow across these files rather than assumption.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida
github.com/siyuan-note/siyuan/kernel< 0.0.0-20260808010544-26ccb40d390e
0.0.0-20260808010544-26ccb40d390e
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
Gogithub.com/siyuan-note/siyuan/kernel
Corregida commit 26ccb40 — —
Versiones corregidascommit 26ccb40
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://nvd.nist.gov/vuln/detail/CVE-2026-62204
Otrahttps://github.com/siyuan-note/siyuan/security/advisories/GHSA-rpx2-p6hp-x5gj
Otrahttps://github.com/siyuan-note/siyuan/commit/26ccb40d390eb7d9b04673629a58ab1d69cc7e53
Otrahttps://github.com/siyuan-note/siyuan
Otrahttps://github.com/siyuan-note/siyuan/releases/tag/v3.8.0
Otrahttps://www.vulncheck.com/advisories/siyuan-before-plugin-overwrite-via-bazaar-install

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.