Search: cs.at
222 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| High | 8.7 | EPSS 0.6% | CVE-2026-13474NetScaler ADC · Memory Leak High8.7EPSS 0.6%CVE Database V5CVE-2026-13474 Denial of service via malformed HTTP/2 requests in NetScaler ADC and NetScaler Gateway if HTTP/2 is enabled in HTTP Profile and associated with the virtual server (of type LB, CS, VPN) or the service configured on NetScaler | CVE Database V5 | ||
| Medium | 6.9 | EPSS 0.6% | CVE-2026-10817NetScaler ADC · Out-of-bounds Read Medium6.9EPSS 0.6%CVE Database V5CVE-2026-10817 Insufficient input validation leading to memory overread in NetScaler ADC and NetScaler Gateway if the TCP TimeStamp is enabled in TCP Profile and is associated with the virtual server (of type LB, CS, VPN) or the service configured on NetScaler | CVE Database V5 | ||
| Medium | 6.9 | Medium6.9GCVE Database ### Summary The `ExpressionDepthLimit` parser guard in Scriban does not actually stop parsing — it only logs a non-fatal error and lets recursive descent continue. As a result, a template containing a deeply nested expression (parentheses, array initializers, object initializers, or unary operators) drives the recursive-descent parser into a native stack overflow. The resulting `StackOverflowException` is **uncatchable** in .NET and **immediately terminates the host process**. Any application that parses an attacker-influenced template — or that passes attacker-controlled strings to `object.eval` / `object.eval_template` — can be crashed by a single small request (roughly an 8 KB payload). This is a denial-of-service. It affects both Scriban-native (`Template.Parse`) and Liquid (`Template.ParseLiquid`) syntax modes, which share the same expression parser. This re-opens two advisories that were reported as fixed: **GHSA-wgh7-7m3c-fx25** ("Uncontrolled recursion in parser → StackOverflow", reported fixed in 6.6.0) and **GHSA-p6q4-fgr8-vx4p** ("StackOverflow via nested array initializers bypasses ExpressionDepthLimit", reported fixed in 7.0.0). Both fixes are incomplete: the limit they rely on never halts recursion. **All releases 6.6.0 through 7.2.0 (current) are affected.** ### Details The depth guard is `EnterExpression()` in `src/Scriban/Parsing/Parser.Expressions.cs`: ```csharp // src/Scriban/Parsing/Parser.Expressions.cs:1209-1218 private void EnterExpression() { _expressionDepth++; var limit = Options.ExpressionDepthLimit; if (limit > 0 && !_isExpressionDepthLimitReached && _expressionDepth > limit) { LogError(GetSpanForToken(Previous), $"The statement depth limit `{limit}` was reached when parsing this statement"); _isExpressionDepthLimitReached = true; } } ``` When the limit is exceeded it calls `LogError(...)` and sets a flag. It does **not** throw, does **not** return a sentinel, and does **not** unwind the parse. `LogError` here uses the default `isFatal: false`, so it merely appends a message and sets `HasErrors` — parsing proceeds: ```csharp // src/Scriban/Parsing/Parser.cs:476-488 private void Log(LogMessage logMessage, bool isFatal = false) { Messages.Add(logMessage); if (logMessage.Type == ParserMessageType.Error) { HasErrors = true; if (isFatal) _hasFatalError = true; // not set on the depth-limit path } } ``` The flag `_isExpressionDepthLimitReached` is consulted **only** to avoid logging the same error more than once — no code path uses it to stop descending. Confirmed by full-repo search (`grep -rn "_isExpressionDepthLimitReached" src/`): it appears in exactly four places — the field declaration (`Parser.cs:40`), a reset to `false` (`Parser.cs:106`), and within `EnterExpression` the dedup test (`Parser.Expressions.cs:1213`) and its assignment to `true` (`:1216`). The only *read* is the dedup test on line 1213; nothing else reads it. `ParseExpression` calls `EnterExpression()` and then continues straight into the token switch with no flag check: ```csharp // src/Scriban/Parsing/Parser.Expressions.cs:113 + 181-182 EnterExpression(); try { ... case TokenType.OpenParen: leftOperand = ParseParenthesis(); // recurses back into ParseExpression ``` ```csharp // src/Scriban/Parsing/Parser.Expressions.cs:984-1001 private ScriptExpression ParseParenthesis() { var expression = Open<ScriptNestedExpression>(); ExpectAndParseTokenTo(expression.OpenParen, TokenType.OpenParen); expression.Expression = ExpectAndParseExpression(expression); // -> ParseExpression -> ParseParenthesis -> ... ... } ``` Both `Template.Parse` (Scriban-native) and `Template.ParseLiquid` (Liquid-compatibility) front-ends share this same expression parser, so both entry points are affected. So for input nested N levels deep, the parser recurses N levels deep regardless of `ExpressionDepthLimit`. There is no `RuntimeHelpers.EnsureSufficientExecutionStack()` call and no absolute recursion cap anywhere in the parser. Once the native thread stack is exhausted, the runtime raises `StackOverflowException`, which .NET does not allow to be caught and which tears down the entire process. The number of nesting levels required to overflow depends on the platform's thread-stack size (empirically around 4,000 levels on a default 1 MB stack); it is not a configurable mitigation. The same defective guard is what makes the array-initializer fix for GHSA-p6q4-fgr8-vx4p ineffective: `ParseArrayInitializer` was wrapped in `EnterExpression()/LeaveExpression()`, but because `EnterExpression()` only logs, the array path still overflows. The existing regression tests only assert `HasErrors == true` at a nesting depth of ~20 with a limit of 10 (`src/Scriban.Tests/TestParser.cs`); they never use a depth large enough to overflow the stack, so they pass while the protection does nothing against the actual DoS. **Runtime reachability without | GCVE Database | |||
| Medium | 6.9 | Medium6.9GCVE Database ### Summary The array multiplication operator (`array * integer`) in Scriban allocates a result whose size is the product of the attacker-controlled integer and the array length, with **no `LoopLimit` / `LimitToString` check and no overflow-safe arithmetic**. A ~40-byte template forces a multi-gigabyte allocation, producing a denial-of-service. This is the unguarded sibling of operations that *were* hardened against the same class of abuse: `string * integer` (gated by a `LimitToString` pre-check), `array.insert_at` (gated by `StepLoop`/`LoopLimit` — the **GHSA-24c8-4792-22hx** fix shipped in 7.2.0, scored 8.7 High), and the range/iteration paths covered by **GHSA-c875-h985-hvrc** ("Built-in operations bypass LoopLimit", fixed 7.0.0). The same `LoopLimit`-based hardening pattern was applied to those operations but never to `array * integer`. This can be observed directly in 7.0.0, the release where GHSA-c875 was patched: `(1..5) * 50000000` (and `1..N | array.size`) correctly throws `Exceeding number of iteration limit '1000'`, while `[1,2,3,4,5] * 50000000` allocates ~2 GB with no limit. The `LoopLimit` control is enforced on the iteration path but not on the `array * int` allocation path, side by side, in the same version. The bug has been present since the operator was introduced in **3.0.0**, survives all of the 6.6.0 / 7.0.0 / 7.2.0 DoS-hardening passes, and is still present in 7.2.0 (current) — i.e. it is both a missed sibling of GHSA-24c8 and an incomplete coverage of GHSA-c875's `LoopLimit` hardening. ### Details The `array * int` operator is handled in `ScriptArray<T>.TryEvaluate`: ```csharp // src/Scriban/Runtime/ScriptArray.cs:504-508 (Multiply case) var newArray = new ScriptArray<T>(intModifier * array.Count); for (int i = 0; i < intModifier; i++) { newArray.AddRange(array); } ``` `intModifier` is the attacker-supplied integer (`context.ToInt(...)`, `ScriptArray.cs:399`). Two problems: 1. **No resource limit.** Neither `new ScriptArray<T>(intModifier * array.Count)` nor the `AddRange` loop consults `LoopLimit`, `LimitToString`, or calls `context.StepLoop(...)`. A grep of the entire `TryEvaluate` method (`ScriptArray.cs:360-560`) finds no `StepLoop` / `LoopLimit` / `Limit` reference. `LoopLimit` (default 1000) is therefore not enforced: a template that requests 250,000,000 elements creates them all without any "iteration limit" error. 2. **Integer overflow in the capacity.** `intModifier * array.Count` is unchecked `int` arithmetic. The overflow-safe `long` cast used by the string sibling is absent here. The DoS-hardening passes guarded the two sibling operations but not this one: ```csharp // src/Scriban/Syntax/Expressions/ScriptBinaryExpression.cs:341 (string * int — GUARDED) if (context.LimitToString > 0 && value > 0 && leftText.Length > 0 && (long)leftText.Length * value > context.LimitToString) // long arithmetic, pre-check { throw new ScriptRuntimeException(spanMultiplier, $"String multiplication exceeds LimitToString `{context.LimitToString}`."); } ``` ```csharp // src/Scriban/Functions/ArrayFunctions.cs:414 (array.insert_at — GUARDED, GHSA-24c8 fix in 7.2.0) for (int i = array.Count; i < index; i++) { context.StepLoop(span, ref loopStep); // LoopLimit enforced array.Add(null); } ``` `array * int` (`ScriptArray.cs:504`) received neither guard. When the oversized allocation fails as a managed exception, it is wrapped by the binary-expression evaluator: ```csharp // src/Scriban/Syntax/Expressions/ScriptBinaryExpression.cs:241-243 catch (Exception ex) when (!(ex is ScriptRuntimeException)) { throw new ScriptRuntimeException(span, ex.Message); } ``` So a host that wraps `Render()` in `try/catch` sees a `ScriptRuntimeException` carrying the original `OutOfMemoryException` message (or `ArgumentOutOfRangeException` on the integer-overflow path). ### PoC A single console project reproduces it on the released NuGet package. `poc.csproj`: ```xml <Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <OutputType>Exe</OutputType> <TargetFramework>net8.0</TargetFramework> <!-- If only the .NET 9 SDK is installed, change to net9.0. Behavior is identical. --> </PropertyGroup> <ItemGroup> <PackageReference Include="Scriban" Version="7.2.0" /> </ItemGroup> </Project> ``` `Program.cs`: ```csharp using Scriban; // ~41-byte template requests 5 * 200,000,000 = 1,000,000,000 elements string tpl = "{{ x = [1,2,3,4,5] * 200000000; x.size }}"; System.Console.WriteLine("Rendering..."); var sw = System.Diagnostics.Stopwatch.StartNew(); var result = Template.Parse(tpl).Render(); // allocates ~7.7 GB System.Console.WriteLine($"size={result.Trim()} peakWS=" + System.Diagnostics.Process.GetCurrentProcess().PeakWorkingSet64 / (1024 * 1024) + "MB elapsed=" + sw.ElapsedMilliseconds + "ms"); ``` Run: ```sh dotnet run -c Release ``` Measured peak working set on Scriban 7.2.0 (net8.0, .NET 9 runtime, Linux), varying only the multip | GCVE Database | |||
| High | 7.5 | EPSS 0.5% | High7.5EPSS 0.5%CVE Database V5CVE-2026-36478 An issue in Technitium DNS Server v.14.3 and before allows a remote attacker to cause a denial of service via the DnsServerApp.exe, DnsServerApp.dll, TechnitiumLibrary.Net/Dns/DnsClient.cs components | CVE Database V5 | ||
| Critical | 9.8 | EPSS 0.3% | Critical9.8EPSS 0.3%GCVE DatabaseCVE-2026-53260 In the Linux kernel, the following vulnerability has been resolved: tcp: Add preempt_{disable,enable}_nested() in reqsk_queue_hash_req(). syzbot reported a weird reqsk->rsk_refcnt underflow in __inet_csk_reqsk_queue_drop(). The captured reqsk_put() in __inet_csk_reqsk_queue_drop() is called only when it successfully removes reqsk from ehash. Moreover, reqsk_timer_handler() calls another reqsk_put() after that. This indicates that the reqsk was missing both refcnts for ehash and the timer itself. Since all the syzbot reports had PREEMPT_RT enabled, the only possible scenario is that reqsk_queue_hash_req() is preempted after mod_timer() and before refcount_set(), and then the timer triggered after 1s aborts the reqsk due to its listener's close(). Let's wrap mod_timer() and refcount_set() with preempt_disable_nested() and preempt_enable_nested(). Note that inet_ehash_insert() holds the normal spin_lock() (mutex in PREEMPT_RT), so it must be called outside of preempt_disable_nested(), but this is fine. The lookup path just ignores 0 sk_refcnt entries in ehash and tries to create another reqsk, but this will fail at inet_ehash_insert(). [0]: refcount_t: underflow; use-after-free. WARNING: lib/refcount.c:28 at refcount_warn_saturate+0xb2/0x110 lib/refcount.c:28, CPU#0: ktimers/0/16 Modules linked in: CPU: 0 UID: 0 PID: 16 Comm: ktimers/0 Tainted: G L syzkaller #0 PREEMPT_{RT,(full)} Tainted: [L]=SOFTLOCKUP Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 04/18/2026 RIP: 0010:refcount_warn_saturate+0xb2/0x110 lib/refcount.c:28 Code: e4 7d d1 0a 67 48 0f b9 3a eb 4a e8 38 3d 23 fd 48 8d 3d e1 7d d1 0a 67 48 0f b9 3a eb 37 e8 25 3d 23 fd 48 8d 3d de 7d d1 0a <67> 48 0f b9 3a eb 24 e8 12 3d 23 fd 48 8d 3d db 7d d1 0a 67 48 0f RSP: 0000:ffffc90000157948 EFLAGS: 00010246 RAX: ffffffff84a1301b RBX: 0000000000000003 RCX: ffff88801ca98000 RDX: 0000000000000100 RSI: 0000000000000000 RDI: ffffffff8f72ae00 RBP: ffffffff99ae3b01 R08: ffff88801ca98000 R09: 0000000000000005 R10: 0000000000000100 R11: 0000000000000004 R12: ffff8880425ef568 R13: ffff8880425ef4f8 R14: ffff8880425ef578 R15: 0000000000000000 FS: 0000000000000000(0000) GS:ffff888126386000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00007f7b46710e9c CR3: 000000000dbb6000 CR4: 00000000003526f0 Call Trace: <TASK> __refcount_sub_and_test include/linux/refcount.h:400 [inline] __refcount_dec_and_test include/linux/refcount.h:432 [inline] refcount_dec_and_test include/linux/refcount.h:450 [inline] reqsk_put include/net/request_sock.h:136 [inline] __inet_csk_reqsk_queue_drop+0x3ce/0x440 net/ipv4/inet_connection_sock.c:1007 reqsk_timer_handler+0x651/0xdf0 net/ipv4/inet_connection_sock.c:1137 call_timer_fn+0x192/0x5e0 kernel/time/timer.c:1748 expire_timers kernel/time/timer.c:1799 [inline] __run_timers kernel/time/timer.c:2374 [inline] __run_timer_base+0x6a3/0x9f0 kernel/time/timer.c:2386 run_timer_base kernel/time/timer.c:2395 [inline] run_timer_softirq+0x67/0x170 kernel/time/timer.c:2403 handle_softirqs+0x1de/0x6d0 kernel/softirq.c:622 __do_softirq kernel/softirq.c:656 [inline] run_ktimerd+0x69/0x100 kernel/softirq.c:1151 smpboot_thread_fn+0x541/0xa50 kernel/smpboot.c:160 kthread+0x388/0x470 kernel/kthread.c:436 ret_from_fork+0x514/0xb70 arch/x86/kernel/process.c:158 ret_from_fork_asm+0x1a/0x30 arch/x86/entry/entry_64.S:245 </TASK> | GCVE Database | ||
| High | 8.3 | EPSS 0.1% | High8.3EPSS 0.1%CVE Database V5CVE-2026-12249 An issue was discovered in Canonical ADSys upstream versions through v0.16.2. During Active Directory Certificate Services (AD CS) certificate auto-enrollment via the vendored Samba client script (internal/policies/certificate/python/vendor_samba/gp/gp_cert_auto_enroll_ext.py), ADSys utilizes a plaintext HTTP connection (http://) instead of a secure HTTPS connection (https://) to request the CA certificate from the Active Directory Certificate Services server (GetCACert). An unauthenticated network attacker positioned between the managed Ubuntu host and the configured AD CS CA hostname can conduct a Man-in-the-Middle (MITM) attack. By intercepting the plaintext HTTP request, the attacker can supply an arbitrary, attacker-controlled Root CA certificate. Because the system automatically accepts this certificate and registers it into the local system trust store via update-ca-certificates, this results in system-wide trust store poisoning. Consequently, TLS clients utilizing the operating system trust store on the affected machine will accept rogue certificates for arbitrary domains, enabling persistent decryption and interception of subsequent TLS connections. This issue is resolved in version v0.16.3. | CVE Database V5 | ||
| High | – | EPSS 0.3% | CVE-2026-35271Oracle PeopleSoft Enterprise · Kwetsbaarheden Verholpen HighEPSS 0.3%GCVE DatabaseCVE-2026-35271 Oracle has released a Critical Security Patch Update (CSPU) in June 2026 addressing multiple vulnerabilities in Oracle PeopleSoft Enterprise products, including PeopleSoft PeopleTools versions 8.61 and 8.62, and PeopleSoft Enterprise CS Campus Community and Student Financials version 9.2.38. The update is part of a broader set of 245 security patches across various Oracle product families. Oracle strongly recommends applying these patches promptly to mitigate risks associated with these vulnerabilities. | GCVE Database | ||
| Medium | 6.5 | EPSS 0.3% | Medium6.5EPSS 0.3%CVE Database V5CVE-2026-46979 Vulnerability in the PeopleSoft Enterprise CS Campus Community product of Oracle PeopleSoft (component: Integration and Interfaces). The supported version that is affected is 9.2.38. Easily exploitable vulnerability allows high privileged attacker with network access via HTTPS to compromise PeopleSoft Enterprise CS Campus Community. Successful attacks of this vulnerability can result in unauthorized creation, deletion or modification access to critical data or all PeopleSoft Enterprise CS Campus Community accessible data as well as unauthorized access to critical data or complete access to all PeopleSoft Enterprise CS Campus Community accessible data. CVSS 3.1 Base Score 6.5 (Confidentiality and Integrity impacts). CVSS Vector: (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:N). | CVE Database V5 | ||
| High | 8.1 | EPSS 0.5% | High8.1EPSS 0.5%CVE Database V5CVE-2026-46851 Vulnerability in the PeopleSoft Enterprise CS Campus Community product of Oracle PeopleSoft (component: Security). The supported version that is affected is 9.2.38. Difficult to exploit vulnerability allows unauthenticated attacker with network access via HTTP to compromise PeopleSoft Enterprise CS Campus Community. Successful attacks of this vulnerability can result in takeover of PeopleSoft Enterprise CS Campus Community. CVSS 3.1 Base Score 8.1 (Confidentiality, Integrity and Availability impacts). CVSS Vector: (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H). | CVE Database V5 | ||
| High | 8.1 | EPSS 0.4% | High8.1EPSS 0.4%CVE Database V5CVE-2026-46849 Vulnerability in the PeopleSoft Enterprise CS Student Financials product of Oracle PeopleSoft (component: Other). The supported version that is affected is 9.2.38. Easily exploitable vulnerability allows low privileged attacker with network access via HTTP to compromise PeopleSoft Enterprise CS Student Financials. Successful attacks of this vulnerability can result in unauthorized creation, deletion or modification access to critical data or all PeopleSoft Enterprise CS Student Financials accessible data as well as unauthorized access to critical data or complete access to all PeopleSoft Enterprise CS Student Financials accessible data. CVSS 3.1 Base Score 8.1 (Confidentiality and Integrity impacts). CVSS Vector: (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N). | CVE Database V5 | ||
| Medium | 5.5 | EPSS 0.1% | Medium5.5EPSS 0.1%GCVE DatabaseCVE-2026-46220 In the Linux kernel, the following vulnerability has been resolved: drm/amdgpu/sdma4: replace BUG_ON with WARN_ON in fence emission sdma_v4_0_ring_emit_fence() contains two BUG_ON(addr & 0x3) assertions that verify fence writeback addresses are dword-aligned. These assertions can be reached from unprivileged userspace via crafted DRM_IOCTL_AMDGPU_CS submissions, causing a fatal kernel panic in a scheduler worker thread. Replace both BUG_ON() calls with WARN_ON() to log the condition without crashing the kernel. A misaligned fence address at this point indicates a driver bug, but crashing the kernel is never the correct response when the assertion is reachable from userspace. The CS IOCTL path is the correct place to filter invalid submissions; the ring emission callback is too late to do anything about it. (cherry picked from commit b90250bd933afd1ba94d86d6b13821997b22b18e) | GCVE Database | ||
| Medium | – | EPSS 0.1% | MediumEPSS 0.1%CVE Database V5CVE-2026-46148 A vulnerability in the Linux kernel's microchip-core-qspi driver related to chip select (CS) control has been resolved. The coreQSPI IP supports only a single chip select that is automatically controlled by hardware, which caused issues when multiple devices were attached using GPIOs for chip selects. The automatic control set the built-in CS low during access, interfering with devices requiring different CS behavior. The driver was modified to manually control the chip select, improving compatibility and safety for multiple devices. EPSS 0.1%Vulnerability | CVE Database V5 | ||
| –Not rated | – | Palo Alto Unit 42 This analysis covers advanced exploitation techniques targeting Active Directory Certificate Services (AD CS) through misconfigurations in certificate templates and misuse of shadow credentials. The threat involves attackers leveraging these weaknesses to escalate privileges within an Active Directory environment. The research by Palo Alto Unit 42 provides detailed behavioral detection methods to help defenders identify such misuse. No specific affected product versions or patches are indicated, and no known exploits in the wild have been reported at this time. | Palo Alto Unit 42 | |||
| High | 7.5 | EPSS 0.4% | High7.5EPSS 0.4%GCVE DatabaseCVE-2026-4046 This update includes the following RPMs: glibc: * compat-libpthread-nonshared-2.42-12.hum1 (aarch64, x86_64) * glibc-2.42-12.hum1 (aarch64, x86_64) * glibc-all-langpacks-2.42-12.hum1 (aarch64, x86_64) * glibc-benchtests-2.42-12.hum1 (aarch64, x86_64) * glibc-common-2.42-12.hum1 (aarch64, x86_64) * glibc-devel-2.42-12.hum1 (aarch64, x86_64) * glibc-doc-2.42-12.hum1 (noarch) * glibc-gconv-extra-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-aa-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-af-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-agr-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ak-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-am-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-an-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-anp-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ar-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-as-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ast-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ayc-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-az-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-be-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-bem-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ber-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-bg-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-bhb-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-bho-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-bi-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-bn-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-bo-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-br-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-brx-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-bs-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-byn-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ca-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ce-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-chr-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ckb-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-cmn-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-crh-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-cs-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-csb-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-cv-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-cy-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-da-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-de-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-doi-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-dsb-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-dv-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-dz-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-el-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-en-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-eo-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-es-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-et-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-eu-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-fa-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ff-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-fi-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-fil-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-fo-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-fr-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-fur-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-fy-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ga-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-gbm-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-gd-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-gez-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-gl-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-gu-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-gv-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ha-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-hak-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-he-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-hi-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-hif-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-hne-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-hr-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-hsb-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ht-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-hu-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-hy-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ia-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-id-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ig-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ik-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-is-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-it-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-iu-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ja-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-ka-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-kab-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-kk-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-kl-2.42-12.hum1 (aarch64, x86_64) * glibc-langpack-km-2.4 | GCVE Database | ||
| High | 4.7 | EPSS <0.1% | High4.7EPSS <0.1%GCVE DatabaseCVE-2026-31456 In the Linux kernel, the following vulnerability has been resolved: mm/pagewalk: fix race between concurrent split and refault The splitting of a PUD entry in walk_pud_range() can race with a concurrent thread refaulting the PUD leaf entry causing it to try walking a PMD range that has disappeared. An example and reproduction of this is to try reading numa_maps of a process while VFIO-PCI is setting up DMA (specifically the vfio_pin_pages_remote call) on a large BAR for that process. This will trigger a kernel BUG: vfio-pci 0000:03:00.0: enabling device (0000 -> 0002) BUG: unable to handle page fault for address: ffffa23980000000 PGD 0 P4D 0 Oops: Oops: 0000 [#1] SMP NOPTI ... RIP: 0010:walk_pgd_range+0x3b5/0x7a0 Code: 8d 43 ff 48 89 44 24 28 4d 89 ce 4d 8d a7 00 00 20 00 48 8b 4c 24 28 49 81 e4 00 00 e0 ff 49 8d 44 24 ff 48 39 c8 4c 0f 43 e3 <49> f7 06 9f ff ff ff 75 3b 48 8b 44 24 20 48 8b 40 28 48 85 c0 74 RSP: 0018:ffffac23e1ecf808 EFLAGS: 00010287 RAX: 00007f44c01fffff RBX: 00007f4500000000 RCX: 00007f44ffffffff RDX: 0000000000000000 RSI: 000ffffffffff000 RDI: ffffffff93378fe0 RBP: ffffac23e1ecf918 R08: 0000000000000004 R09: ffffa23980000000 R10: 0000000000000020 R11: 0000000000000004 R12: 00007f44c0200000 R13: 00007f44c0000000 R14: ffffa23980000000 R15: 00007f44c0000000 FS: 00007fe884739580(0000) GS:ffff9b7d7a9c0000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: ffffa23980000000 CR3: 000000c0650e2005 CR4: 0000000000770ef0 PKRU: 55555554 Call Trace: <TASK> __walk_page_range+0x195/0x1b0 walk_page_vma+0x62/0xc0 show_numa_map+0x12b/0x3b0 seq_read_iter+0x297/0x440 seq_read+0x11d/0x140 vfs_read+0xc2/0x340 ksys_read+0x5f/0xe0 do_syscall_64+0x68/0x130 ? get_page_from_freelist+0x5c2/0x17e0 ? mas_store_prealloc+0x17e/0x360 ? vma_set_page_prot+0x4c/0xa0 ? __alloc_pages_noprof+0x14e/0x2d0 ? __mod_memcg_lruvec_state+0x8d/0x140 ? __lruvec_stat_mod_folio+0x76/0xb0 ? __folio_mod_stat+0x26/0x80 ? do_anonymous_page+0x705/0x900 ? __handle_mm_fault+0xa8d/0x1000 ? __count_memcg_events+0x53/0xf0 ? handle_mm_fault+0xa5/0x360 ? do_user_addr_fault+0x342/0x640 ? arch_exit_to_user_mode_prepare.constprop.0+0x16/0xa0 ? irqentry_exit_to_user_mode+0x24/0x100 entry_SYSCALL_64_after_hwframe+0x76/0x7e RIP: 0033:0x7fe88464f47e Code: c0 e9 b6 fe ff ff 50 48 8d 3d be 07 0b 00 e8 69 01 02 00 66 0f 1f 84 00 00 00 00 00 64 8b 04 25 18 00 00 00 85 c0 75 14 0f 05 <48> 3d 00 f0 ff ff 77 5a c3 66 0f 1f 84 00 00 00 00 00 48 83 ec 28 RSP: 002b:00007ffe6cd9a9b8 EFLAGS: 00000246 ORIG_RAX: 0000000000000000 RAX: ffffffffffffffda RBX: 0000000000020000 RCX: 00007fe88464f47e RDX: 0000000000020000 RSI: 00007fe884543000 RDI: 0000000000000003 RBP: 00007fe884543000 R08: 00007fe884542010 R09: 0000000000000000 R10: fffffffffffffbc5 R11: 0000000000000246 R12: 0000000000000000 R13: 0000000000000003 R14: 0000000000020000 R15: 0000000000020000 </TASK> Fix this by validating the PUD entry in walk_pmd_range() using a stable snapshot (pudp_get()). If the PUD is not present or is a leaf, retry the walk via ACTION_AGAIN instead of descending further. This mirrors the retry logic in walk_pte_range(), which lets walk_pmd_range() retry if the PTE is not being got by pte_offset_map_lock(). | GCVE Database | ||
| Medium | 5.7 | EPSS 0.2% | Medium5.7EPSS 0.2%CVE Database V5CVE-2026-35241 CVE-2026-35241 is a medium severity vulnerability in Oracle PeopleSoft Enterprise CS Student Records version 9.2, specifically in the Research Tracking component. It allows a low privileged attacker with network access via HTTP to compromise the system, but requires user interaction from a person other than the attacker. Successful exploitation can lead to unauthorized access to critical or all accessible data within PeopleSoft Enterprise CS Student Records. The vulnerability has a CVSS 3.1 base score of 5.7, reflecting a significant confidentiality impact without integrity or availability effects. Oracle has included this vulnerability in its April 2026 Critical Patch Update advisory, but no specific patch or remediation details for this product version are explicitly provided in the advisory content. Customers are strongly advised to apply Oracle Critical Patch Updates promptly to mitigate risks from known vulnerabilities. | CVE Database V5 |
Page 6 of 12 · 3 duplicate CVE records merged