Guido Vranken

A double-free issue exists in the `parse def()` function within `src/conf.c`. This occurs when the system parses nested compound or array configuration blocks and fails to check return values before proceeding. Consequently, the `snd config delete()` function is called twice on the same already-freed node, which can lead to memory corruption, a NULL-pointer write, or an invalid memory read if an attacker provides maliciously crafted ALSA configuration text.

A malicious server can exploit TLS OCSP stapling by delivering a crafted response through the `status request` extension. This triggers a double-free in the client's certificate verification path when the stapled response is checked. A double-free occurs when a program attempts to free the same memory location twice, which can corrupt heap memory. This may lead to a Denial of Service, attacker-controlled code execution, or other undefined behavior. OCSP stapling is not enabled by default.

An assertion failure occurs during the ECDSA (Elliptic Curve Digital Signature Algorithm) signature verification process.

Processing maliciously crafted web content may lead to an unexpected process crash due to improper memory handling.

The `CombinedMult` function within the `ecc/p384` package (secp384r1 curve) calculates an incorrect value for certain inputs. This issue does not affect ECDH and ECDSA signing operations that rely on this curve. The problem is resolved by implementing complete addition formulas.

The `html.Parse` function exhibits quadratic parsing complexity when handling specific inputs. This can result in a denial of service (DoS) if an attacker submits maliciously crafted HTML content.

The `html.Parse` function can enter an infinite parsing loop when processing specific HTML inputs. This can result in a denial of service (DoS) if an attacker provides crafted HTML content.

The issue is related to uncontrolled resource consumption in the Golang programming language. An attacker can craft an input to the Parse functions that would be processed non-linearly with respect to its length, resulting in extremely slow parsing. This could cause a denial of service. The estimated number of potentially affected devices worldwide is not available. There is no information about real-world incidents where this issue was exploited.

The issue arises from the `idna.encode()` function's handling of crafted input strings, which can lead to quadratic complexity and consequently, a denial of service condition. This is triggered by a crafted input that causes the `idna.encode()` function to process the input with considerable computational load, significantly increasing the processing time in a quadratic manner relative to the input size. The vulnerability may allow a remote attacker to cause a denial of service.

The issue is related to the ScalarMult and ScalarBaseMult methods of the P256 Curve in the Go programming language, which may return incorrect results when called with specific unreduced scalars. This could potentially allow a remote attacker to impact the integrity of protected information. The issue does not affect usages of crypto/ecdsa or crypto/ecdh.

The issue concerns the multiplication of certain unreduced P-256 scalars, which can produce incorrect results. However, there are no known protocols that can be attacked due to this issue. The problem arises because the P-256 assembly does not use complete addition formulas, which can lead to incorrect results when the two inputs are equal. This was previously mitigated by always reducing the scalar, but a change in the math/big rewrite removed this reduction, assuming it was not necessary.

The issue allows remote attackers to cause a denial of service (panic) via a large header to `ReadRequest` or `ReadResponse`. Server, Transport, and Client can each be affected in some configurations. A malicious HTTP server or client can cause the net/http client or server to panic. `ReadRequest` and `ReadResponse` can hit an unrecoverable panic when reading a very large header.

Name of the Vulnerable Software and Affected Versions: glibc versions prior to 2.32 Description: The issue is related to the functions cosl, sinl, sincosl, and tanl in the GNU C Library (glibc), which can cause a buffer overflow. This can lead to a denial of service by damaging the stack when calling trigonometric functions with a pseudo-zero argument. Specifically, the problem occurs when an input to an 80-bit long double function contains a non-canonical bit pattern, such as passing a 0x5d414141414141410000 value to sinl on x86 targets. Recommendations: For glibc versions prior to 2.32, update to version 2.32 or later to resolve the issue. As a temporary workaround, consider restricting the use of the vulnerable functions cosl, sinl, sincosl, and tanl until a patch is available. Avoid using non-canonical bit patterns as input to these functions to minimize the risk of exploitation.

An issue was discovered due to incorrect buffer management, allowing a remote client to cause a buffer overflow in a Squid instance acting as a reverse proxy. This can potentially impact the confidentiality, integrity, and availability of protected information.

A bug in the fork of the opkg package manager prevents correct parsing of embedded checksums in the signed repository index, allowing a man-in-the-middle attacker to inject arbitrary package payloads, which are installed without verification. This issue is related to a problem with the code that checks the SHA-256 checksums present in the signed digital signature index of packages, allowing an attacker to create conditions under which these checksums are ignored, thus bypassing the integrity checking mechanisms of the downloaded ipk resources.

The issue is related to a buffer overflow due to unbounded copying of user input. This could allow a remote attacker to access sensitive data, compromise its integrity, and potentially cause a denial of service. An attacker may also be able to execute arbitrary code or cause the application to crash by writing past the end of a buffer stored on the stack.

The issue is related to the `django.utils.text.Truncator` class, specifically the `chars()` and `words()` methods. When these methods are passed the `html=True` argument, they can be extremely slow to evaluate certain inputs due to a catastrophic backtracking vulnerability in a regular expression. This vulnerability can be exploited to cause a denial of service. The `chars()` and `words()` methods are used to implement the `truncatechars html` and `truncatewords html` template filters.

The issue is related to the HTMLParser function in django.utils.html.strip tags, which can be slow to evaluate large input sequences containing incomplete HTML entities. This can be exploited by a remote attacker to cause a denial of service.

The issue allows certain input files to cause the code to enter an infinite loop when parsed, potentially leading to a Denial of Service (DoS) attack.

The issue allows certain input files to cause the code to hang when parsed, potentially leading to a denial-of-service (DoS) attack. Note that Apache Sanselan was later renamed to Apache Commons Imaging.