Skip to content
OpenAdvisories

Ecosystem

crates.io

2,056 known vulnerabilities.

610 results · Clear filters · Feed

  • Medium 5.6

    mediasoup: SCTP state cookie lacks cryptographic authentication, enabling unauthorized association establishment (RFC 9260 violation)

    mediasoup is a WebRTC video conferencing system. From version 3.20.0 until 3.20.6 for the npm package and from 0.22.0 until 0.22.5 for the Rust crate, mediasoup's built-in SCTP stack authenticates state cookies using only the hardcoded msworker and 0xAD81 mag…

  • Medium —

    vibeio-http has a DoS vulnerability in HTTP/1.x chunked encoding parser triggered by maliciously crafted chunk lengths

    When using the affected versions of the `vibeio-http` crate, an attacker could craft a malicious HTTP/1.x request with a large chunk length (between `usize::MAX - 1` and `usize::MAX` inclusive) and send it, causing the server to crash (integer overflow panic …

  • Medium —

    tokio-postgres: Panic on a `DataRow` with fewer fields than columns allows denial of service

    A malicious or compromised server can send a row containing fewer fields than its row description declares columns. Reading one of the missing columns then panics with an out-of-bounds index, aborting the calling task. This affects even the otherwise non-pani…

  • Medium —

    postgres-protocol: Panic decoding a malformed `hstore` value allows denial of service

    A malicious or compromised server can return a binary `hstore` value with an invalid internal length field, causing the client to panic while decoding it. Applications that connect only to a trusted database are not exposed; the risk applies to clients that m…

  • Medium 6.9

    ratex-parser has unbounded parser recursion that leads to stack overflow (process abort)

    RaTeX is a KaTeX-compatible math rendering engine written in Rust. Prior to version 0.1.11, RaTeX’s recursive-descent parser recurses one (or more) native stack frame per nesting level at `{`, `\left`, `\sqrt{`, `^{`, etc, with no maximum depth limit. A short…

  • Medium —

    Zoo Design Studio: Memory-corruption in memory handling of lib-kcl

    A race condition in kcl-lib can result in a use-after-free when accessing environments concurrently. During Vec reallocation, the previous buffer containing Box pointers is freed and replaced. A concurrent get_env operation that has already loaded a pointer t…

  • Medium —

    Zoo Design Studio: Recursive KCL parsing is vulnerable to denial-of-service

    ### Impact Feeding a KCL program that wraps an expression in deep, unnecessary parentheses triggers the parser’s recursive `expression` -> `unnecessarily_bracketed` -> `expression` path. With enough nesting, the call stack grows until it exceeds the process s…

  • Medium 5.1

    Windmill: Resource-scoped API tokens can read script contents outside their allowed path via scripts/list_search

    Windmill is an open-source developer platform for internal code: APIs, background jobs, workflows and UIs. Prior to 1.715.0, a resource-scoped API token could read script contents outside its allowed path scope through GET /api/w/{workspace}/scripts/list_sear…

  • Medium 6.9

    Hurl: Cookies in Cookies section leak when redirecting to a different host

    Hurl is a command line tool that runs and tests HTTP requests defined in plain text files. In version 8.0.1 and earlier, the redirect handling in packages/hurl/src/http/client.rs strips Authorization and Cookie headers and basic-auth credentials when a redire…

  • Medium —

    block_buffer: panic corrupts inline buffer position

    ### Summary A caught panic may leave the cursor position of `EagerBuffer` or `ReadBuffer` in a corrupted state; this in turn allows out-of-bounds reads/writes. ### Details & PoC The following two tests fail miri: ```rust #[cfg(miri)] #[test] fn eager_digest_b…

  • Medium —

    Triton VM Soundness Vulnerability due to Missing Constraint

    The instruction `sponge_absorb_mem` Triton VM fails to verify that hashed values come from the claimed memory location. Malicious provers can substitute arbitrary data instead of actual memory contents. Any application using instruction `sponge_absorb_mem` to…

  • Medium 5.3

    ZEBRA: Mempool transaction admission denial via single-peer inbound queue saturation

    ZEBRA is a Zcash node written entirely in Rust. Prior to 4.5.0, one unauthenticated P2P peer can monopolize all 25 MAX_INBOUND_CONCURRENCY slots in Zebra's inbound mempool download and verification pipeline. In zebrad/src/components/mempool/downloads.rs, the …

  • Medium 6.5

    ZEBRA: Full node denial of service via non-ASCII LongPollId in getblocktemplate

    ZEBRA is a Zcash node written entirely in Rust. Prior to 4.5.0, an attacker authenticated to an enabled Zebra RPC endpoint can terminate zebrad by supplying a getblocktemplate LongPollId containing multi-byte UTF-8 characters. In zebra-rpc/src/methods/types/l…

  • Medium 6.5

    ZEBRA: Persistent on-disk corruption of Sapling/Orchard subtree roots after chain fork via pop_tip

    ZEBRA is a Zcash node written entirely in Rust. Prior to 4.5.0, a natural or attacker-influenced chain fork can leave stale Sapling and Orchard note-commitment subtree roots in Zebra state. In zebra-state/src/service/non_finalized_state/chain.rs, Chain::pop_t…

  • Medium 6.9

    ZEBRA: Finalized address balance credit-first overflow on consensus-valid blocks

    ZEBRA is a Zcash node written entirely in Rust. Prior to 4.5.0, a consensus-valid block containing a long chain of transparent self-spends to one address can permanently halt Zebra nodes. In zebra-state/src/service/finalized_state/zebra_db/transparent.rs, the…

  • Medium 5.9

    ZEBRA: Repeated Non-Finalized Shielded Transaction Aborts Zebra Before Duplicate-Nullifier Rejection

    ZEBRA is a Zcash node written entirely in Rust. Prior to 4.5.0, a malicious block producer can terminate zebrad by placing the same shielded transaction in a non-finalized parent block and its child. In zebra-state/src/service/non_finalized_state/chain.rs, Ch…

  • Medium 5.3

    ZEBRA: Unbounded memory leak in mempool download pipeline via timeout path cancel_handles retention

    ZEBRA is a Zcash node written entirely in Rust. Prior to 4.5.0, an unauthenticated P2P peer can cause the mempool download pipeline to retain transactions after verification reaches the outer RATE_LIMIT_DELAY timeout. In zebrad/src/components/mempool/download…

  • Medium 5.3

    ZEBRA: Sync restart poisoning from single unauthenticated peer via above-lookahead block

    ZEBRA is a Zcash node written entirely in Rust. Prior to 4.5.0, a malicious unauthenticated P2P peer can answer Zebra's outbound getblocks or FindBlocks request with a small two-hash inventory and then serve a syntactically valid block whose coinbase height i…

  • Medium 6.5

    Legacy `azure_core` writes the `authorization` header value to logs

    Applications built on the legacy Azure SDK for Rust (`azure_core` 0.21.0 and earlier) write the value of the outgoing `authorization` header to their logs whenever debug-level logging is enabled, and in every affected version also at trace level. The leaked v…

  • Medium 6.3

    actix-http before 3.12.1 HTTP Request Smuggling via CL.TE

    actix-http versions before 3.12.1 contain an HTTP request smuggling vulnerability in the HTTP/1.1 parser that accepts requests with both Content-Length and Transfer-Encoding: chunked headers. Unauthenticated remote attackers can exploit this through a front-e…

  • Medium 6.3

    actix-files before 0.6.10 Information Disclosure via Files

    The actix-files crate (actix_files) before version 0.6.10 contains an information exposure vulnerability. When a non-existing folder is passed as the serve_from argument to Files::new(), the mount path defaults to an empty path; the service then joins the req…

  • Medium 6.9

    actix-files before 0.6.10 Denial of Service via empty Range header

    actix-files before 0.6.10 contains a denial of service vulnerability triggered by an empty Range header in GET requests for static files. When panic is set to abort, remote attackers can crash the process on-demand by sending a GET request with an empty Range…

  • Medium 4.3

    Russh: Post-auth remote panic via pty-req with more than 130 terminal-mode records

    Russh is a Rust SSH client & server library. Prior to 0.62.4, an authenticated SSH client can cause a denial of service by sending a pty-req channel request with more than 130 terminal-mode records. The parser in russh/src/server/encrypted.rs stores terminal …

  • Medium 5.3

    Russh: Pre-auth remote panic via all-zero Curve25519 peer public value (encode_mpint OOB)

    Russh is a Rust SSH client & server library. Prior to 0.62.4, an unauthenticated SSH client can cause a denial of service by sending SSH_MSG_KEX_ECDH_INIT with a 32-byte all-zero Q_C value. Curve25519Kex::server_dh in russh/src/kex/curve25519.rs accepts the a…

  • Medium 5.3

    Russh: client wrong-length X25519 `clone_from_slice` panic (pre-auth DoS)

    Russh is a Rust SSH client & server library. Prior to 0.62.4, a malicious SSH server can crash a russh client session with a malformed KEX_ECDH_REPLY containing a server ephemeral value that is not 32 bytes long. The client-side Curve25519Kex::compute_shared_…

  • Medium 4.6

    Inverted bitmap validation in `invalidate_l2_cached_ept`

    Incorrect comparison for some Intel(R) TDX Guest software before version 0.3.1 within Ring 3: User Applications may allow an escalation of privilege. System software adversary with a privileged user combined with a low complexity attack may enable escalation …

  • Medium 4.6

    `enter_l2_vcpu` passes the wrong RCX operand to `TDG.VP.ENTER`

    Incorrect calculation for some Intel(R) TDX Guest software before version 0.3.1 within Ring 3: User Applications may allow an escalation of privilege. System software adversary with a privileged user combined with a low complexity attack may enable escalation…

  • Medium 6.1

    SWC HTML minifier may allow script element breakout when minifying embedded JSON

    SWC is a TypeScript / JavaScript compiler written in Rust. Prior to @swc/html 1.15.47-nightly-20260729.1 and swc_html_minifier 59.0.0, the minifyJson processing in crates/swc_html_minifier/src/lib.rs parsed and serialized attacker-controlled JSON in applicati…

  • Medium 6.5

    Russh: Channel-scoped server callbacks can be reached without an open channel

    Russh is a Rust SSH client & server library. Prior to 0.62.5, russh dispatches channel-scoped Handler callbacks for recipient channel IDs that were never opened or confirmed in russh/src/server/encrypted.rs, server_read_authenticated, and the exec_request cal…

  • Medium 4.3

    NIP-04 parsing amplifies malformed ciphertext memory use

    The NIP-04 decryption parser split attacker-controlled content on every `?iv=` separator and collected all resulting segments before checking that the message had the expected two parts. It also Base64-decoded the complete IV text before checking that it repr…

  • Medium 5.5

    Debug output exposes NIP-46 and NIP-60 credentials

    Several NIP-46 and NIP-60 types used derived `Debug` implementations even though their fields contained credentials or decrypted application data. Formatting these values exposed NIP-46 connection secrets and request parameters, as well as NIP-60 private keys…

  • Medium —

    zaino-state has a Non-Finalized State Reorg — No Cycle Detection or Depth Limit

    ### Summary `NonFinalizedState::handle_reorg` is a recursive, unbounded async function that traverses parent blocks until it finds a common ancestor on the main chain. It has **no recursion depth limit** and **no cycle detection**. A malicious or buggy valida…

  • Medium 6.5

    skilo add follows symbolic links, allowing arbitrary local file disclosure from a malicious skill source

    ### Impact `skilo add` installs a skill by recursively copying the skill directory into the target skills directory. The copy routine (`copy_dir_all`) classified each entry with `std::fs::DirEntry::file_type()` — which does **not** follow symlinks — and then …

  • Medium 6.6

    nono-cli'scregistry pack verification can fail open when provenance metadata is absent

    ## Summary Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant: - `~/.config/nono/packages/lockfile.json` - `~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle` Testi…

  • Medium —

    Hubuum client library (Rust): Configured custom transports may be bypassed, exposing credentials and network traffic

    ## Summary When an application configures hubuum_client with ClientBuilder::with_transport, several client operations still use the built-in reqwest client directly. The bypass includes password login, bearer-token validation, authentication-provider discover…

  • Medium —

    Hubuum client library (Rust): Authenticated requests may escape the configured base path through redirects

    ## Impact The built-in async and blocking clients used reqwest's default redirect policy. `BaseUrl` constrains the initial request to the configured origin and path prefix, but redirect processing occurs after that validation. reqwest retains sensitive header…

  • Medium 6.9

    Rattler vulnerable to entry-point path traversal in noarch:python install (arbitrary file write)

    Rattler is a library that provides common functionality used within the conda ecosystem. Prior to version 0.43.2, `EntryPoint::FromStr` in `rattler_conda_types` performs only `.trim()` on the `command` field before the linker joins it onto the install prefix …

  • Medium 5.5

    Shamefile has an arbitrary file read via shamefile.yaml in shame next

    Shamefile is a linter for undocumented linter warnings. Prior to version 0.1.7, a path traversal vulnerability in `shame next` allows an attacker-controlled `shamefile.yaml` to disclose contents of files outside the repository, one line at a time, to the term…

  • Medium 6.1

    nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

    nono is software that allows users to run AI agents in a zero-latency sandbox. Prior to version 0.55.0, the nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the …

  • Medium 4.4

    Rust OneNote File Parser: Path traversal in `Parser::parse_notebook` allows reading files outside the notebook directory

    Rust OneNote File Parser is a parser for Microsoft OneNote files implemented in Rust. Prior to version 1.1.1, a maliciously crafted `.onetoc2` table-of-contents file can cause `Parser::parse_notebook` to open arbitrary files on the host filesystem outside the…