« Volver al listado

CVE-2025-47934

Estado: AplazadaAlta (8.7)—

OpenPGP.js is a JavaScript implementation of the OpenPGP protocol. Startinf in version 5.0.1 and prior to versions 5.11.3 and 6.1.1, a maliciously modified message can be passed to either `openpgp.verify` or `openpgp.decrypt`, causing these functions to return a valid signature verification result while returning data that was not actually signed.

Leer descripción completaMostrar menos

This flaw allows signature verifications of inline (non-detached) signed messages (using `openpgp.verify`) and signed-and-encrypted messages (using `openpgp.decrypt` with `verificationKeys`) to be spoofed, since both functions return extracted data that may not match the data that was originally signed. Detached signature verifications are not affected, as no signed data is returned in that case. In order to spoof a message, the attacker needs a single valid message signature (inline or detached) as well as the plaintext data that was legitimately signed, and can then construct an inline-signed message or signed-and-encrypted message with any data of the attacker's choice, which will appear as legitimately signed by affected versions of OpenPGP.js. In other words, any inline-signed message can be modified to return any other data (while still indicating that the signature was valid), and the same is true for signed+encrypted messages if the attacker can obtain a valid signature and encrypt a new message (of the attacker's choice) together with that signature. The issue has been patched in versions 5.11.3 and 6.1.1. Some workarounds are available. When verifying inline-signed messages, extract the message and signature(s) from the message returned by `openpgp.readMessage`, and verify the(/each) signature as a detached signature by passing the signature and a new message containing only the data (created using `openpgp.createMessage`) to `openpgp.verify`. When decrypting and verifying signed+encrypted messages, decrypt and verify the message in two steps, by first calling `openpgp.decrypt` without `verificationKeys`, and then passing the returned signature(s) and a new message containing the decrypted data (created using `openpgp.createMessage`) to `openpgp.verify`.

CVSS

Probabilidad de explotación (EPSS)

EPSS (Exploit Prediction Scoring System, de FIRST) estima la probabilidad de que una vulnerabilidad sea explotada en 30 días. Complementa a CVSS (impacto) y a CISA KEV (explotación confirmada).

🎯 Técnicas ATT&CK

Cómo se explota esta vulnerabilidad y qué consigue el atacante, en el lenguaje de MITRE ATT&CK.

Vulnerabilidad remota (AV:N, PR:N, UI:N) en librería OpenPGP.js que permite falsificar verificaciones de firma pasando mensajes maliciosos a funciones públicas expuestas. Atacante puede devolver datos no firmados mientras indica validez de firma, violando integridad criptográfica.

Inferido por nuestro agente de análisis a partir de la descripción oficial, el vector CVSS y la CWE, y comprobado por un supervisor. Puede contener errores.

🛡️ Mitigaciones ATT&CK que cubren estas técnicas

Restrict File and Directory PermissionsVulnerability ScanningRestrict Registry PermissionsPrivileged Account ManagementRemote Data StorageNetwork Segmentation

Tecnologías afectadas (1)

⚠ Inferidas por IA a partir de la descripción — NVD aún no ha analizado esta CVE; no son CPE verificados.

Openpgp — Openpgp.jsAI

CWE

Referencias

JSON original (NVD)

Mostrar
{
  "id": "CVE-2025-47934",
  "cveTags": [],
  "metrics": {
    "ssvcV203": [
      {
        "source": "134c704f-9b21-4f2e-91b3-4a467353bcc0",
        "ssvcData": {
          "id": "CVE-2025-47934",
          "role": "CISA Coordinator",
          "options": [
            {
              "exploitation": "none"
            },
            {
              "automatable": "yes"
            },
            {
              "technicalImpact": "partial"
            }
          ],
          "version": "2.0.3",
          "timestamp": "2025-05-20T13:02:53.093390Z"
        }
      }
    ],
    "cvssMetricV40": [
      {
        "type": "Secondary",
        "source": "security-advisories@github.com",
        "cvssData": {
          "Safety": "NOT_DEFINED",
          "version": "4.0",
          "Recovery": "NOT_DEFINED",
          "baseScore": 8.7,
          "Automatable": "NOT_DEFINED",
          "attackVector": "NETWORK",
          "baseSeverity": "HIGH",
          "valueDensity": "NOT_DEFINED",
          "vectorString": "CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N/E:X/CR:X/IR:X/AR:X/MAV:X/MAC:X/MAT:X/MPR:X/MUI:X/MVC:X/MVI:X/MVA:X/MSC:X/MSI:X/MSA:X/S:X/AU:X/R:X/V:X/RE:X/U:X",
          "exploitMaturity": "NOT_DEFINED",
          "providerUrgency": "NOT_DEFINED",
          "userInteraction": "NONE",
          "attackComplexity": "LOW",
          "attackRequirements": "NONE",
          "privilegesRequired": "NONE",
          "subIntegrityImpact": "NONE",
          "vulnIntegrityImpact": "HIGH",
          "integrityRequirement": "NOT_DEFINED",
          "modifiedAttackVector": "NOT_DEFINED",
          "subAvailabilityImpact": "NONE",
          "vulnAvailabilityImpact": "NONE",
          "availabilityRequirement": "NOT_DEFINED",
          "modifiedUserInteraction": "NOT_DEFINED",
          "modifiedAttackComplexity": "NOT_DEFINED",
          "subConfidentialityImpact": "NONE",
          "vulnConfidentialityImpact": "NONE",
          "confidentialityRequirement": "NOT_DEFINED",
          "modifiedAttackRequirements": "NOT_DEFINED",
          "modifiedPrivilegesRequired": "NOT_DEFINED",
          "modifiedSubIntegrityImpact": "NOT_DEFINED",
          "modifiedVulnIntegrityImpact": "NOT_DEFINED",
          "vulnerabilityResponseEffort": "NOT_DEFINED",
          "modifiedSubAvailabilityImpact": "NOT_DEFINED",
          "modifiedVulnAvailabilityImpact": "NOT_DEFINED",
          "modifiedSubConfidentialityImpact": "NOT_DEFINED",
          "modifiedVulnConfidentialityImpact": "NOT_DEFINED"
        }
      }
    ]
  },
  "affected": [
    {
      "source": "security-advisories@github.com",
      "affectedData": [
        {
          "vendor": "openpgpjs",
          "product": "openpgpjs",
          "versions": [
            {
              "status": "affected",
              "version": ">= 5.0.1, < 5.11.3"
            },
            {
              "status": "affected",
              "version": ">= 6.0.0-alpha.0, < 6.1.1"
            }
          ]
        }
      ]
    }
  ],
  "published": "2025-05-19T19:15:52.330",
  "references": [
    {
      "url": "https://github.com/openpgpjs/openpgpjs/commit/43f5f4e2bd67d0514d06acc60b6ee571a049c229",
      "source": "security-advisories@github.com"
    },
    {
      "url": "https://github.com/openpgpjs/openpgpjs/commit/bd54e8535ca29b3bef58a8c02296892e408be356",
      "source": "security-advisories@github.com"
    },
    {
      "url": "https://github.com/openpgpjs/openpgpjs/releases/tag/v5.11.3",
      "source": "security-advisories@github.com"
    },
    {
      "url": "https://github.com/openpgpjs/openpgpjs/releases/tag/v6.1.1",
      "source": "security-advisories@github.com"
    },
    {
      "url": "https://github.com/openpgpjs/openpgpjs/security/advisories/GHSA-8qff-qr5q-5pr8",
      "source": "security-advisories@github.com"
    }
  ],
  "vulnStatus": "Deferred",
  "weaknesses": [
    {
      "type": "Secondary",
      "source": "security-advisories@github.com",
      "description": [
        {
          "lang": "en",
          "value": "CWE-347"
        }
      ]
    }
  ],
  "descriptions": [
    {
      "lang": "en",
      "value": "OpenPGP.js is a JavaScript implementation of the OpenPGP protocol. Startinf in version 5.0.1 and prior to versions 5.11.3 and 6.1.1, a maliciously modified message can be passed to either `openpgp.verify` or `openpgp.decrypt`, causing these functions to return a valid signature verification result while returning data that was not actually signed. This flaw allows signature verifications of inline (non-detached) signed messages (using `openpgp.verify`) and signed-and-encrypted messages (using `openpgp.decrypt` with `verificationKeys`) to be spoofed, since both functions return extracted data that may not match the data that was originally signed. Detached signature verifications are not affected, as no signed data is returned in that case. In order to spoof a message, the attacker needs a single valid message signature (inline or detached) as well as the plaintext data that was legitimately signed, and can then construct an inline-signed message or signed-and-encrypted message with any data of the attacker's choice, which will appear as legitimately signed by affected versions of OpenPGP.js. In other words, any inline-signed message can be modified to return any other data (while still indicating that the signature was valid), and the same is true for signed+encrypted messages if the attacker can obtain a valid signature and encrypt a new message (of the attacker's choice) together with that signature. The issue has been patched in versions 5.11.3 and 6.1.1. Some workarounds are available. When verifying inline-signed messages, extract the message and signature(s) from the message returned by `openpgp.readMessage`, and verify the(/each) signature as a detached signature by passing the signature and a new message containing only the data (created using `openpgp.createMessage`) to `openpgp.verify`.  When decrypting and verifying signed+encrypted messages, decrypt and verify the message in two steps, by first calling `openpgp.decrypt` without `verificationKeys`, and then passing the returned signature(s) and a new message containing the decrypted data (created using `openpgp.createMessage`) to `openpgp.verify`."
    },
    {
      "lang": "es",
      "value": "OpenPGP.js es una implementación en JavaScript del protocolo OpenPGP. A partir de la versión 5.0.1 y anteriores a las versiones 5.11.3 y 6.1.1, se puede pasar un mensaje modificado maliciosamente a `openpgp.verify` o `openpgp.decrypt`, lo que provoca que estas funciones devuelvan un resultado de verificación de firma válido, pero que devuelvan datos no firmados. Esta falla permite falsificar las verificaciones de firma de mensajes firmados en línea (no separados) (mediante `openpgp.verify`) y de mensajes firmados y cifrados (mediante `openpgp.decrypt` con `verificationKeys`), ya que ambas funciones devuelven datos extraídos que podrían no coincidir con los datos firmados originalmente. Las verificaciones de firma separadas no se ven afectadas, ya que en ese caso no se devuelven datos firmados. Para falsificar un mensaje, el atacante necesita una única firma de mensaje válida (en línea o separada), así como los datos de texto plano firmados legítimamente. Posteriormente, puede construir un mensaje firmado en línea o firmado y cifrado con cualquier dato que elija, que aparecerá como firmado legítimamente en las versiones afectadas de OpenPGP.js. En otras palabras, cualquier mensaje firmado en línea puede modificarse para que devuelva cualquier otro dato (sin dejar de indicar que la firma era válida). Lo mismo ocurre con los mensajes firmados y cifrados si el atacante puede obtener una firma válida y cifrar un nuevo mensaje (a elección del atacante) junto con esa firma. El problema se ha corregido en las versiones 5.11.3 y 6.1.1. Existen algunas workarounds. Al verificar mensajes firmados en línea, extraiga el mensaje y las firmas del mensaje devuelto por `openpgp.readMessage` y verifique cada firma como una firma independiente. Para ello, pase la firma y un nuevo mensaje que contenga solo los datos (creado con `openpgp.createMessage`) a `openpgp.verify`. Al descifrar y verificar mensajes firmados y cifrados, descifre y verifique el mensaje en dos pasos: primero, llame a `openpgp.decrypt` sin `verificationKeys` y, a continuación, pase las firmas devueltas y un nuevo mensaje que contenga los datos descifrados (creado con `openpgp.createMessage`) a `openpgp.verify`."
    }
  ],
  "lastModified": "2026-06-17T09:28:51.587",
  "sourceIdentifier": "security-advisories@github.com"
}