Export limit exceeded: 55890 CVEs match your query. Please refine your search to export 10,000 CVEs or fewer.
Export limit exceeded: 429400 CVEs match your query. Please refine your search to export 10,000 CVEs or fewer.
Export limit exceeded: 52322 CVEs match your query. Please refine your search to export 10,000 CVEs or fewer.
Export limit exceeded: 429400 CVEs match your query. Please refine your search to export 10,000 CVEs or fewer.
Search
Search Results (429400 CVEs found)
| CVE | Vendors | Products | Updated | CVSS v3.1 |
|---|---|---|---|---|
| CVE-2026-133072 | 2026-11-19 | 5.4 Medium | ||
| A flaw was found in Moodle. Insufficient authorization checks in the quiz editing functionality allow an authenticated user with teacher privileges to view slot details and modify sections of quizzes they do not have permission to manage. An attacker could exploit this flaw to alter quiz configurations or disclose quiz structure information without proper authorization. | ||||
| CVE-2026-133071 | 2026-11-19 | 5.4 Medium | ||
| A flaw was found in Moodle. Due to a missing authorization check when editing Lesson activity pages, authenticated users with teacher privileges can view and move lesson pages from courses they are not permitted to access into their own lessons. This issue can lead to unauthorized access and modification of restricted course content. | ||||
| CVE-2026-133070 | 2026-11-19 | 4.3 Medium | ||
| A flaw was found in Moodle. Due to a missing authorization check when viewing and restoring wiki page versions, an authenticated user can access content from courses they are not permitted to view. This issue allows an attacker to inspect restricted course material and copy it into their own wiki pages, leading to unauthorized information disclosure. | ||||
| CVE-2026-133069 | 2026-11-19 | 5.4 Medium | ||
| A flaw was found in Moodle. Missing authorization checks in the forum discussion web services allow authenticated users to view discussion information in courses they do not have permission to access. In addition, users with teacher privileges may lock forum discussions in courses where they lack proper authorization. This issue can lead to unauthorized information disclosure and unauthorized discussion state modification. | ||||
| CVE-2026-133068 | 2026-11-19 | 4.3 Medium | ||
| A flaw was found in Moodle. An improper authorization check when displaying individual glossary entries allows an authenticated user to view approved glossary items from courses they do not have permission to access. This vulnerability leads to unauthorized information disclosure of restricted educational materials. | ||||
| CVE-2026-133067 | 2026-11-19 | 5.4 Medium | ||
| A flaw was found in Moodle. Due to missing ownership checks in badge alignments, an authenticated user with badge management privileges can view and modify alignments associated with badges they do not own. This vulnerability can lead to unauthorized data disclosure and tampering with badge configurations. | ||||
| CVE-2026-133066 | 2026-11-19 | 5.4 Medium | ||
| A flaw was found in Moodle. Missing ownership verification in Feedback activity templates allows an authenticated teacher to view, use, or delete templates associated with courses other than their own. This can result in unauthorized access, modification, or deletion of course materials. | ||||
| CVE-2026-133065 | 2026-11-19 | 4.3 Medium | ||
| A flaw was found in Moodle. Due to insufficient permission checks and input validation in the quiz question bank callback, an authenticated user can access and view questions from question banks they do not have permission to access. Furthermore, this issue allows users to trigger arbitrary class instantiation (creating unintended application objects), potentially leading to further unauthorized actions. | ||||
| CVE-2026-133064 | 2026-11-19 | 4.6 Medium | ||
| A flaw was found in Moodle. Insufficient sanitization of objective identifiers in the SCORM (Sharable Content Object Reference Model) objectives report allows an authenticated user with content upload permissions to inject malicious scripts. When another user views the report, the injected script executes in their browser session, potentially allowing the attacker to access sensitive information or perform unauthorized actions on their behalf. | ||||
| CVE-2026-133063 | 2026-11-19 | 4.3 Medium | ||
| A flaw was found in Moodle. Due to insufficient validation when saving activity settings, an authenticated user with teacher privileges can modify activities in courses they are not authorized to access. This flaw allows unauthorized changes to course materials, compromising the integrity of course content. | ||||
| CVE-2026-133062 | 2026-11-19 | 7.5 High | ||
| A flaw was found in Moodle's external database enrolment plugin. Insufficient sanitization of data passed to queries against the external database allows an authenticated user with course editing permissions to perform a Structured Query Language (SQL) injection attack. When this non-default plugin is enabled, an attacker can exploit this issue to view, modify, or delete sensitive records within the connected external database. | ||||
| CVE-2026-133061 | 2026-11-19 | 4.3 Medium | ||
| A flaw was found in Moodle. Due to a missing capability check in the grade items web service, an authenticated user with a student role can view the names of all grade items in a course, including those intended to be hidden. This flaw leads to unauthorized information disclosure of hidden course assessment details. | ||||
| CVE-2026-133060 | 2026-11-19 | 6.5 Medium | ||
| A flaw was found in Moodle's Blackboard question import format. Insufficient validation of file paths during the question import process allows an authenticated user with permissions to import questions into a question bank to read arbitrary files accessible to the web server process. An attacker could leverage this vulnerability to view sensitive files, resulting in unauthorized information disclosure. | ||||
| CVE-2026-133059 | 2026-11-19 | 4.3 Medium | ||
| A flaw was found in Moodle. The grade feedback web service does not properly verify group and course enrolment permissions. An authenticated user with non-editing teacher privileges can exploit this vulnerability to access grade feedback and user profile details across groups or courses they are not authorized to view, leading to unauthorized information disclosure. | ||||
| CVE-2026-128128 | 2 Aio-libs, Aiohttp | 2 Aiohttp, Aiohttp | 2026-11-19 | 7.5 High |
| AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.4, the C WebSocket reader adds a declared frame length to the size of an already buffered partial message using signed 64-bit arithmetic. A length near two to the power of 63 can overflow, allowing the max_msg_size check to pass. A remote peer can send a small non-final fragment followed by an oversized message and cause unbounded memory consumption. The Python WebSocket reader is unaffected. This issue is fixed in version 3.14.4. | ||||
| CVE-2026-127925 | 2026-11-19 | N/A | ||
| Inline mitigations exists. | ||||
| CVE-2026-99565 | 1 Linux | 1 Linux Kernel | 2026-11-19 | 8.2 High |
| In the Linux kernel, the following vulnerability has been resolved: ksmbd: wait for negotiation before receiving another PDU The receive thread queues a request and can read the next PDU before the negotiation worker finishes. While need_neg is set, the next PDU can cause ksmbd_init_smb_server() to replace conn->ops. A pipelined SMB2 request can therefore make the worker handle an earlier, shorter SMB1 request with SMB2 operations and read beyond its buffer. An SMB1 multi-protocol negotiate may be followed by an SMB2 NEGOTIATE that changes conn->ops again. Wait for work queued while the connection is new or needs negotiation to complete before reading another PDU. This keeps the operations stable for both stages of negotiation without changing when need_neg is cleared. | ||||
| CVE-2026-99564 | 1 Linux | 1 Linux Kernel | 2026-11-19 | 5.9 Medium |
| In the Linux kernel, the following vulnerability has been resolved: smb: smbdirect: don't wait for RDMA_CM_EVENT_DISCONNECTED in smbdirect_socket_destroy_sync() smbdirect_socket_destroy_sync() waited for RDMA_CM_EVENT_DISCONNECTED after smbdirect_socket_cleanup_work() called rdma_disconnect(). That can take very long, e.g. if the peer just disappeared, until the rdma cm gives up, or forever if the event already happened, but the status was overwritten afterwards. This is not needed: smbdirect_socket_destroy() drains the qp under rdma_lock_handler(), destroys it and calls rdma_destroy_id(), which only waits for a currently running event handler and makes sure no further events are delivered. The rest of the disconnect protocol (DREQ/DREP and timewait for IB, abrupt close for iWarp) is handled by the rdma core asynchronously. drivers/nvme/host/rdma.c also just calls rdma_disconnect() and ib_drain_qp() before rdma_destroy_id(). So smbdirect_socket_destroy() now also accepts SMBDIRECT_SOCKET_DISCONNECTING and changes the status to SMBDIRECT_SOCKET_DISCONNECTED itself under rdma_lock_handler(). We could still get RDMA_CM_EVENT_DISCONNECTED in the small windows between rdma_unlock_handler() and rdma_destroy_id(), but in that case smbdirect_connection_rdma_event_handler() is basically a no-op. | ||||
| CVE-2026-99563 | 1 Linux | 1 Linux Kernel | 2026-11-19 | 7.5 High |
| In the Linux kernel, the following vulnerability has been resolved: smb: smbdirect: release failed pending sockets of a listener A child of a listener only left the listen.pending or listen.ready list via smbdirect_socket_accept() or when the listener was destroyed. So every connection that failed before it was accepted (negotiate timeout, peer disconnect, invalid negotiate request, ...) stayed on the list and counted against the backlog until the listener was destroyed. After about backlog (10 for ksmbd) such connections smbdirect_listen_connect_request() rejected every new connection with -EBUSY, so an unauthenticated peer was able to permanently stop ksmbd from accepting SMB-Direct connections. Now a failed child moves itself to a new listen.orphaned list at the end of smbdirect_socket_cleanup_work(), after the disconnect was started, and queues listen.purge_orphaned_work, which releases it with smbdirect_socket_release(), without holding the listener's rdma_lock_handler() lock, in the same way smbdirect_socket_destroy() does for the remaining children. Orphaned sockets still count against the backlog until they are released. sc->accept.listener is now only changed under listener->listen.lock and whoever clears it is responsible for releasing the socket: smbdirect_socket_accept(), purge_orphaned_work or the destroy of the listener. In order to make that work: - a struct smbdirect_socket that is a listener is now freed via kfree_rcu(), so that a child can dereference sc->accept.listener under rcu_read_lock(), even if the listener is released concurrently. - smbdirect_listen_connect_request() adds nsc to the listen.pending list and sets nsc->accept.listener before it calls smbdirect_accept_connect_request(), and always returns 0 so the rdma_cm core keeps the connection id and nsc owns it. On a non-zero return it schedules nsc's teardown with smbdirect_socket_schedule_cleanup(), which orphans it off the listener so that purge_orphaned_work releases it; nsc destroys its own connection id with rdma_destroy_id() in that teardown. The teardown has to be deferred because the rdma_cm core holds nsc's id_priv->handler_mutex across the handler, so nsc->rdma.cm_id must not be destroyed synchronously from here. That same handler_mutex (and the listener's) also guarantees nsc can't go away under us, so setting the listener before the call is safe and lets a failure orphan nsc. - smbdirect_accept_negotiate_recv_work() no longer moves a socket to the ready list if it already failed or no longer belongs to the listener. Every accepting socket has a listener, so if sc->accept.listener is already cleared, it no longer sends a negotiate response, as the socket is about to be released. - smbdirect_socket_destroy() of the listener disables purge_orphaned_work and also releases the orphaned sockets. | ||||
| CVE-2026-99561 | 1 Linux | 1 Linux Kernel | 2026-11-19 | 5.5 Medium |
| In the Linux kernel, the following vulnerability has been resolved: fork: don't create io threads once PF_POSTCOREDUMP is set zap_process() skips every thread that already has PF_POSTCOREDUMP set. Such a thread is past synchronize_group_exit(), so a coredump can't catch it anymore. It isn't counted in core_state->threads_remaining and it isn't sent SIGKILL. do_exit() sets PF_POSTCOREDUMP in synchronize_group_exit() and calls io_uring_files_cancel() right after that. The cancellation runs task work and a create_worker_cb() that io-wq queued before the exit creates a new io-wq worker from there. If another thread started a coredump in the meantime that worker joins a thread-group which is already being dumped. zap_process() never saw it so it was never counted. But when it exits it sees signal->core_state in synchronize_group_exit() and decrements threads_remaining like any other thread. So the count reaches zero one thread early and the dumper leaves coredump_wait_inactive() while a thread it counted is still running. The task has no fatal signal pending because zap_process() deliberately didn't send it one, and it never went through get_signal() so it doesn't have PF_SIGNALED either. Refuse to create an io thread when the creator has PF_POSTCOREDUMP. That costs nothing. io_uring_files_cancel() raises IO_WQ_BIT_EXIT before it runs any task work, so a worker created from there only ever gets to exit again, and io_should_retry_thread() doesn't retry -EINTR. Clearing PF_POSTCOREDUMP for the new thread in copy_process() was the other option. It makes the worker a thread like any other, but it only helps while the dump hasn't started. A worker born after zap_process() has run is invisible to it whatever its flags say and still decrements threads_remaining on the way out. Refusing to create it covers both, and then no task is ever born with the flag, so there is nothing to clear. Moving io_uring_files_cancel() ahead of synchronize_group_exit() closes the same window. It runs the cancellation, and whatever that can block on, before the thread announces itself to the dumper. A thread that blocks there never reaches coredump_task_exit() at all, so the dumper ends up waiting for a thread that never parks. Refusing the creation leaves the cancellation where it is. But it's very ugly to run io_uring work even before we did all the generic exit work. | ||||