CIRCL/cwe-parent-vulnerability-classification-roberta-base
Text Classification
•
0.1B
•
Updated
•
4
•
1
Dataset Viewer
id
stringlengths 13
16
| title
stringlengths 0
237
| description
stringlengths 35
3.88k
| patches
listlengths 1
14
| cwe
stringlengths 2
440
|
|---|---|---|---|---|
CVE-2014-9421
|
The auth_gssapi_unwrap_data function in lib/rpc/auth_gssapi_misc.c in MIT Kerberos 5 (aka krb5) through 1.11.5, 1.12.x through 1.12.2, and 1.13.x before 1.13.1 does not properly handle partial XDR deserialization, which allows remote authenticated users to cause a denial of service (use-after-free and double free, and daemon crash) or possibly execute arbitrary code via malformed XDR data, as demonstrated by data sent to kadmind.
|
[
{
"commit_message": "[PATCH] Fix kadm5/gssrpc XDR double free [CVE-2014-9421] [MITKRB5-SA-2015-001] In auth_gssapi_unwrap_data(), do not free partial deserialization results upon failure to deserialize. This responsibility belongs to the callers, svctcp_getargs() and svcudp_getargs(); doing it in the unwrap function results in freeing the results twice. In xdr_krb5_tl_data() and xdr_krb5_principal(), null out the pointers we are freeing, as other XDR functions such as xdr_bytes() and xdr_string(). ticket: 8056 (new) target_version: 1.13.1 tags: pullup src/lib/kadm5/kadm_rpc_xdr.c | 2 ++ src/lib/rpc/auth_gssapi_misc.c | 1 - 2 files changed, 2 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/krb5/krb5/commit/a197e92349a4aa2141b5dff12e9dd44c2a2166e3"
}
] |
n/a
|
|
CVE-2018-18206
|
In the client in Bytom before 1.0.6, checkTopicRegister in p2p/discover/net.go does not prevent negative idx values, leading to a crash.
|
[
{
"commit_message": "[PATCH] p2p/discv5: fix idx can be negative after uint convert to int(can cause crash) (#1307) p2p/discover/net.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSAxYWMzYzhhYzRmMmIxZTFkZjk2NzUyMjgyOTBiZGE2Yjk1ODZiYTQyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiB5YWh0b28gPHlhaHRvby5tYUBnbWFpbC5jb20+CkRhdGU6IEZyaSwgMzEgQXVnIDIwMTggMTM6NDg6NDAgKzA4MDAKU3ViamVjdDogW1BBVENIXSBwMnAvZGlzY3Y1OiBmaXggaWR4IGNhbiBiZSBuZWdhdGl2ZSBhZnRlciB1aW50IGNvbnZlcnQgdG8KIGludChjYW4gY2F1c2UgY3Jhc2gpICgjMTMwNykKCi0tLQogcDJwL2Rpc2NvdmVyL25ldC5nbyB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL3AycC9kaXNjb3Zlci9uZXQuZ28gYi9wMnAvZGlzY292ZXIvbmV0LmdvCmluZGV4IGE2MzE5ZDg5MC4uMzY0NTg2MGZhIDEwMDY0NAotLS0gYS9wMnAvZGlzY292ZXIvbmV0LmdvCisrKyBiL3AycC9kaXNjb3Zlci9uZXQuZ28KQEAgLTEyMjEsNyArMTIyMSw3IEBAIGZ1bmMgKG5ldCAqTmV0d29yaykgY2hlY2tUb3BpY1JlZ2lzdGVyKGRhdGEgKnRvcGljUmVnaXN0ZXIpICgqcG9uZywgZXJyb3IpIHsKIAlpZiBoYXNoICE9IHBvbmdwa3QuZGF0YS4oKnBvbmcpLlRvcGljSGFzaCB7CiAJCXJldHVybiBuaWwsIGVycm9ycy5OZXcoInRvcGljIGhhc2ggbWlzbWF0Y2giKQogCX0KLQlpZiBkYXRhLklkeCA8IDAgfHwgaW50KGRhdGEuSWR4KSA+PSBsZW4oZGF0YS5Ub3BpY3MpIHsKKwlpZiBpbnQoZGF0YS5JZHgpIDwgMCB8fCBpbnQoZGF0YS5JZHgpID49IGxlbihkYXRhLlRvcGljcykgewogCQlyZXR1cm4gbmlsLCBlcnJvcnMuTmV3KCJ0b3BpYyBpbmRleCBvdXQgb2YgcmFuZ2UiKQogCX0KIAlyZXR1cm4gcG9uZ3BrdC5kYXRhLigqcG9uZyksIG5pbA==",
"url": "https://github.com/Bytom/bytom/commit/1ac3c8ac4f2b1e1df9675228290bda6b9586ba42"
}
] |
n/a
|
|
CVE-2020-35236
|
The GitLab Webhook Handler in amazee.io Lagoon before 1.12.3 has incorrect access control associated with project deletion.
|
[
{
"commit_message": "[PATCH 1/2] AIOSEC-85 Verify project group membership before processing gitlab deletion node-packages/commons/src/api.ts | 19 ++++++++++- .../src/handlers/gitlabProjectDelete.ts | 33 ++++++++++++++++--- 2 files changed, 46 insertions(+), 6 deletions(-)",
"patch_text_b64": "From ca6368a23c7d5ec384ffc2fc0f99c9c155b2c40b Mon Sep 17 00:00:00 2001
From: Brandon Williams <brandon@amazee.io>
Date: Fri, 11 Dec 2020 06:16:39 -0600
Subject: [PATCH 1/2] AIOSEC-85 Verify project group membership before
 processing gitlab deletion

---
 node-packages/commons/src/api.ts              | 19 ++++++++++-
 .../src/handlers/gitlabProjectDelete.ts       | 33 ++++++++++++++++---
 2 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/node-packages/commons/src/api.ts b/node-packages/commons/src/api.ts
index b79c55ec81..bebb4270c9 100644
--- a/node-packages/commons/src/api.ts
+++ b/node-packages/commons/src/api.ts
@@ -653,6 +653,23 @@ export async function getProjectByName(project: string): Promise<any> {
   return result.project;
 }
 
+export const allProjectsInGroup = (groupInput: {
+  id?: string;
+  name?: string;
+}): Promise<any[]> =>
+  graphqlapi.query(
+    `
+    query($groupInput: GroupInput!) {
+      allProjectsInGroup(input: $groupInput) {
+        ...${projectFragment}
+      }
+    }
+  `,
+    {
+      groupInput
+    }
+  );
+
 export async function getMicrosoftTeamsInfoForProject(
   project: string, contentType = 'DEPLOYMENT'
 ): Promise<any[]> {
@@ -1456,4 +1473,4 @@ export const getProblemHarborScanMatches = () => graphqlapi.query(
         regex
       }
     }`
-);
\ No newline at end of file
+);
diff --git a/services/webhooks2tasks/src/handlers/gitlabProjectDelete.ts b/services/webhooks2tasks/src/handlers/gitlabProjectDelete.ts
index 38d0120226..9d1ce137cf 100644
--- a/services/webhooks2tasks/src/handlers/gitlabProjectDelete.ts
+++ b/services/webhooks2tasks/src/handlers/gitlabProjectDelete.ts
@@ -1,5 +1,6 @@
+import R from 'ramda';
 import { sendToLagoonLogs } from '@lagoon/commons/dist/logs';
-import { deleteProject } from '@lagoon/commons/dist/api';
+import { allProjectsInGroup, deleteProject, sanitizeGroupName } from '@lagoon/commons/dist/api';
 
 import { WebhookRequestData } from '../types';
 
@@ -9,15 +10,37 @@ export async function gitlabProjectDelete(webhook: WebhookRequestData) {
     event,
     uuid,
     body,
-    body: { path: name }
+    body: { path: projectName, path_with_namespace }
   } = webhook;
 
   try {
     const meta = {
-      project: name
+      project: projectName
     };
 
-    await deleteProject(name);
+    const groupName = sanitizeGroupName(path_with_namespace.replace(`/${projectName}`, ''));
+    const projectsInGroup = await allProjectsInGroup({ name: groupName });
+    const projectExists = R.pipe(
+      R.prop('allProjectsInGroup'),
+      R.pluck('name'),
+      R.contains(projectName),
+    // @ts-ignore
+    )(projectsInGroup);
+
+    if (projectExists) {
+      await deleteProject(projectName);
+
+      sendToLagoonLogs(
+        'info',
+        '',
+        uuid,
+        `${webhooktype}:${event}:handled`,
+        meta,
+        `deleted project ${projectName}`
+      );
+
+      return;
+    }
 
     sendToLagoonLogs(
       'info',
@@ -25,7 +48,7 @@ export async function gitlabProjectDelete(webhook: WebhookRequestData) {
       uuid,
       `${webhooktype}:${event}:handled`,
       meta,
-      `deleted project ${name}`
+      `project "${projectName}" not a member of group "${groupName}"`
     );
 
     return;

From 61e28e2bb1e68df7918dca5fd77781f2c24d8589 Mon Sep 17 00:00:00 2001
From: Brandon Williams <brandon@amazee.io>
Date: Fri, 11 Dec 2020 06:59:57 -0600
Subject: [PATCH 2/2] AIOSEC-85 Verify gitlab system hook event names instead
 of payload structure

---
 node-packages/commons/src/gitlabApi.ts        | 20 +++++++++++++++++++
 .../webhook-handler/src/extractWebhookData.ts |  3 ++-
 services/webhooks2tasks/src/processQueue.ts   |  5 ++++-
 3 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/node-packages/commons/src/gitlabApi.ts b/node-packages/commons/src/gitlabApi.ts
index 9633db1d7c..b9cde73a38 100644
--- a/node-packages/commons/src/gitlabApi.ts
+++ b/node-packages/commons/src/gitlabApi.ts
@@ -18,6 +18,26 @@ const options = {
 
 const gitlabapi = axios.create(options);
 
+export const secureGitlabSystemHooks = [
+  'group_create',
+  'group_rename',
+  'group_destroy',
+  'project_create',
+  'project_transfer',
+  'project_rename',
+  'project_update',
+  'project_destroy',
+  'user_create',
+  'user_rename',
+  'user_destroy',
+  'user_add_to_group',
+  'user_remove_from_group',
+  'user_add_to_team',
+  'user_remove_from_team',
+  'key_create',
+  'key_destroy',
+];
+
 class NetworkError extends Error {
   constructor(message: string) {
     super(message);
diff --git a/services/webhook-handler/src/extractWebhookData.ts b/services/webhook-handler/src/extractWebhookData.ts
index c96d3dc6b9..5187b80a75 100644
--- a/services/webhook-handler/src/extractWebhookData.ts
+++ b/services/webhook-handler/src/extractWebhookData.ts
@@ -2,6 +2,7 @@ import uuid4 from 'uuid4';
 import url from 'url';
 import R from 'ramda';
 import { IncomingMessage } from 'http';
+import { secureGitlabSystemHooks } from '@lagoon/commons/dist/gitlabApi';
 
 import type { RawData, WebhookRequestData } from './types';
 
@@ -45,7 +46,7 @@ export function extractWebhookData(req: IncomingMessage, body: string): WebhookR
       giturl = R.path(['project', 'git_ssh_url'], bodyObj);
 
       // This is a system webhook
-      if (!giturl) {
+      if (R.contains(event, secureGitlabSystemHooks)) {
         // Ensure the system hook came from gitlab
         if (!('x-gitlab-token' in req.headers) || req.headers['x-gitlab-token'] !== process.env.GITLAB_SYSTEM_HOOK_TOKEN) {
           throw new Error('Gitlab system hook secret verification failed');
diff --git a/services/webhooks2tasks/src/processQueue.ts b/services/webhooks2tasks/src/processQueue.ts
index 34ce759a2e..4c7754577a 100644
--- a/services/webhooks2tasks/src/processQueue.ts
+++ b/services/webhooks2tasks/src/processQueue.ts
@@ -1,5 +1,7 @@
+import R from 'ramda';
 import { ChannelWrapper } from 'amqp-connection-manager';
 import { ConsumeMessage } from 'amqplib';
+import { secureGitlabSystemHooks } from '@lagoon/commons/dist/gitlabApi';
 import { processProjects } from './webhooks/projects';
 import { processDataSync } from './webhooks/dataSync';
 import { processBackup } from './webhooks/backup';
@@ -11,13 +13,14 @@ export async function processQueue (rabbitMsg: ConsumeMessage, channelWrapperWeb
 
   const {
     webhooktype,
+    event,
     giturl,
   } = webhook;
 
   // GitLab supports System Hooks which trigger on changes like creating new
   // organizations or users. Since these don't have associated projects, they
   // must be handled separately.
-  if (webhooktype == 'gitlab' && !giturl) {
+  if (webhooktype == 'gitlab' && R.contains(event, secureGitlabSystemHooks)) {
     processDataSync(rabbitMsg, channelWrapperWebhooks);
   } else if (webhooktype == 'resticbackup') {
     processBackup(rabbitMsg, channelWrapperWebhooks);",
"url": "https://github.com/amazeeio/lagoon/commit/1140289bf9fa98b8602ab4662ae867b210d8476b"
}
] |
n/a
|
|
CVE-2023-43796
|
Synapse vulnerable to leak of remote user device information
|
Synapse is an open-source Matrix homeserver Prior to versions 1.95.1 and 1.96.0rc1, cached device information of remote users can be queried from Synapse. This can be used to enumerate the remote users known to a homeserver. System administrators are encouraged to upgrade to Synapse 1.95.1 or 1.96.0rc1 to receive a patch. As a workaround, the `federation_domain_whitelist` can be used to limit federation traffic with a homeserver.
|
[
{
"commit_message": "[PATCH] Merge pull request from GHSA-mp92-3jfm-3575 synapse/federation/federation_server.py | 8 +++++++- synapse/handlers/device.py | 3 +++ synapse/handlers/e2e_keys.py | 6 ++++++ 3 files changed, 16 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/matrix-org/synapse/commit/daec55e1fe120c564240c5386e77941372bf458f"
}
] |
CWE-200: Exposure of Sensitive Information to an Unauthorized Actor
|
CVE-2021-4176
|
Cross-site Scripting (XSS) - Reflected in livehelperchat/livehelperchat
|
livehelperchat is vulnerable to Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
[
{
"commit_message": "[PATCH] Old widget postMessage escape string lhc_web/design/defaulttheme/tpl/pagelayouts/widget.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSAxZjY3Y2Y5ZjI1MTI4OWE1MDk0Nzc0MzA3YzJjM2Q2MzhmOWYwYmE2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBSZW1pZ2lqdXMgS2ltaW5hcyA8cmVtZGV4QGdtYWlsLmNvbT4KRGF0ZTogTW9uLCAyNyBEZWMgMjAyMSAwMDo0NzozOSAtMDUwMApTdWJqZWN0OiBbUEFUQ0hdIE9sZCB3aWRnZXQgcG9zdE1lc3NhZ2UgZXNjYXBlIHN0cmluZwoKLS0tCiBsaGNfd2ViL2Rlc2lnbi9kZWZhdWx0dGhlbWUvdHBsL3BhZ2VsYXlvdXRzL3dpZGdldC5waHAgfCA0ICsrLS0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvbGhjX3dlYi9kZXNpZ24vZGVmYXVsdHRoZW1lL3RwbC9wYWdlbGF5b3V0cy93aWRnZXQucGhwIGIvbGhjX3dlYi9kZXNpZ24vZGVmYXVsdHRoZW1lL3RwbC9wYWdlbGF5b3V0cy93aWRnZXQucGhwCmluZGV4IDRmNGFjNzBjZTcuLjYyYWMxZmZiMjEgMTAwNjQ0Ci0tLSBhL2xoY193ZWIvZGVzaWduL2RlZmF1bHR0aGVtZS90cGwvcGFnZWxheW91dHMvd2lkZ2V0LnBocAorKysgYi9saGNfd2ViL2Rlc2lnbi9kZWZhdWx0dGhlbWUvdHBsL3BhZ2VsYXlvdXRzL3dpZGdldC5waHAKQEAgLTY0LDExICs2NCwxMSBAQAogCXBhcmVudC5wb3N0TWVzc2FnZSgibGhjX2NoOmhhc2hfcmVzdW1lOjw/cGhwIGVjaG8gJFJlc3VsdFsnY2hhdCddLT5pZCwnXycsJFJlc3VsdFsnY2hhdCddLT5oYXNoPz4iLCAnKicpOwogCTw/cGhwIGVuZGlmOyA/PgogCTw/cGhwIGlmIChpc3NldCgkUmVzdWx0WydhZGRpdGlvbmFsX3Bvc3RfbWVzc2FnZSddKSkgOiA/PgotCXBhcmVudC5wb3N0TWVzc2FnZSgiPD9waHAgZWNobyAkUmVzdWx0WydhZGRpdGlvbmFsX3Bvc3RfbWVzc2FnZSddPz4iLCAnKicpOworCXBhcmVudC5wb3N0TWVzc2FnZSg8P3BocCBlY2hvIGpzb25fZW5jb2RlKCRSZXN1bHRbJ2FkZGl0aW9uYWxfcG9zdF9tZXNzYWdlJ10pPz4sICcqJyk7CiAJPD9waHAgZW5kaWY7Pz4KIAk8P3BocCBpZiAoaXNzZXQoJFJlc3VsdFsncGFyZW50X21lc3NhZ2VzJ10pKSA6IAogCWZvcmVhY2ggKCRSZXN1bHRbJ3BhcmVudF9tZXNzYWdlcyddIGFzICRtc2dQQXJlbnQpIDogPz4KLQlwYXJlbnQucG9zdE1lc3NhZ2UoIjw/cGhwIGVjaG8gJG1zZ1BBcmVudD8+IiwgJyonKTsKKwlwYXJlbnQucG9zdE1lc3NhZ2UoPD9waHAgZWNobyBqc29uX2VuY29kZSgkbXNnUEFyZW50KT8+LCAnKicpOwogCTw/cGhwIGVuZGZvcmVhY2g7ZW5kaWY7Pz4KIAogICAgIGZ1bmN0aW9uIGhhbmRsZUNyb3NzTWVzc2FnZShlKSB7",
"url": "https://github.com/livehelperchat/livehelperchat/commit/1f67cf9f251289a5094774307c2c3d638f9f0ba6"
}
] |
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
CVE-2022-1351
|
Stored XSS in Tooltip in pimcore/pimcore
|
Stored XSS in Tooltip in GitHub repository pimcore/pimcore prior to 10.4.
|
[
{
"commit_message": "[PATCH] [Security] ContentSecurityPolicyHandler - Add exclude paths property to disable csp for specific paths Signed-off-by: dpahuja <[email protected]> .../AdminBundle/DependencyInjection/Configuration.php | 4 ++++ .../EventListener/AdminSecurityListener.php | 10 ++++++++++ .../Security/ContentSecurityPolicyHandler.php | 4 ---- 3 files changed, 14 insertions(+), 4 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/pimcore/pimcore/commit/8c39a8b8f14dce078b31f61c4da599ca6f8fc7ac"
}
] |
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
CVE-2011-2183
|
Race condition in the scan_get_next_rmap_item function in mm/ksm.c in the Linux kernel before 2.6.39.3, when Kernel SamePage Merging (KSM) is enabled, allows local users to cause a denial of service (NULL pointer dereference) or possibly have unspecified other impact via a crafted application.
|
[
{
"commit_message": "[PATCH] ksm: fix NULL pointer dereference in scan_get_next_rmap_item() Andrea Righi reported a case where an exiting task can race against ksmd::scan_get_next_rmap_item (http://lkml.org/lkml/2011/6/1/742) easily triggering a NULL pointer dereference in ksmd. ksm_scan.mm_slot == &ksm_mm_head with only one registered mm CPU 1 (__ksm_exit)\t\tCPU 2 (scan_get_next_rmap_item) list_empty() is false lock\t\t\t\tslot == &ksm_mm_head list_del(slot->mm_list) (list now empty) unlock lock slot = list_entry(slot->mm_list.next) (list is empty, so slot is still ksm_mm_head) unlock slot->mm == NULL ... Oops Close this race by revalidating that the new slot is not simply the list head again. Andrea's test case: #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/mman.h> #define BUFSIZE getpagesize() int main(int argc, char **argv) { void *ptr; if (posix_memalign(&ptr, getpagesize(), BUFSIZE) < 0) { perror(\"posix_memalign\"); exit(1); } if (madvise(ptr, BUFSIZE, MADV_MERGEABLE) < 0) { perror(\"madvise\"); exit(1); } *(char *)NULL = 0; return 0; } Reported-by: Andrea Righi <[email protected]> Tested-by: Andrea Righi <[email protected]> Cc: Andrea Arcangeli <[email protected]> Signed-off-by: Hugh Dickins <[email protected]> Signed-off-by: Chris Wright <[email protected]> Cc: <[email protected]> Signed-off-by: Andrew Morton <[email protected]> Signed-off-by: Linus Torvalds <[email protected]> mm/ksm.c | 6 ++++++ 1 file changed, 6 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/torvalds/linux/commit/2b472611a32a72f4a118c069c2d62a1a3f087afd"
}
] |
n/a
|
|
CVE-2022-0367
|
A heap-based buffer overflow flaw was found in libmodbus in function modbus_reply() in src/modbus.c.
|
[
{
"commit_message": "[PATCH] modbus_reply: fix copy & paste error in sanity check (fixes #614) While handling MODBUS_FC_WRITE_AND_READ_REGISTERS, both address offsets must be checked, i.e. the read and the write address must be within the mapping range. At the moment, only the read address was considered, it looks like a simple copy and paste error, so let's fix it. Signed-off-by: Michael Heimpold <[email protected]> src/modbus.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSBiNGVmNGMxN2Q2MThlYmEwYWRjY2M0YzdkOWU5YTFlZjgwOWZjOWI2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWNoYWVsIEhlaW1wb2xkIDxtaGVpQGhlaW1wb2xkLmRlPgpEYXRlOiBTYXQsIDggSmFuIDIwMjIgMjA6MDA6NTAgKzAxMDAKU3ViamVjdDogW1BBVENIXSBtb2RidXNfcmVwbHk6IGZpeCBjb3B5ICYgcGFzdGUgZXJyb3IgaW4gc2FuaXR5IGNoZWNrIChmaXhlcwogIzYxNCkKCldoaWxlIGhhbmRsaW5nIE1PREJVU19GQ19XUklURV9BTkRfUkVBRF9SRUdJU1RFUlMsIGJvdGggYWRkcmVzcyBvZmZzZXRzCm11c3QgYmUgY2hlY2tlZCwgaS5lLiB0aGUgcmVhZCBhbmQgdGhlIHdyaXRlIGFkZHJlc3MgbXVzdCBiZSB3aXRoaW4gdGhlCm1hcHBpbmcgcmFuZ2UuCgpBdCB0aGUgbW9tZW50LCBvbmx5IHRoZSByZWFkIGFkZHJlc3Mgd2FzIGNvbnNpZGVyZWQsIGl0IGxvb2tzIGxpa2UgYQpzaW1wbGUgY29weSBhbmQgcGFzdGUgZXJyb3IsIHNvIGxldCdzIGZpeCBpdC4KClNpZ25lZC1vZmYtYnk6IE1pY2hhZWwgSGVpbXBvbGQgPG1oZWlAaGVpbXBvbGQuZGU+Ci0tLQogc3JjL21vZGJ1cy5jIHwgMiArLQogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL21vZGJ1cy5jIGIvc3JjL21vZGJ1cy5jCmluZGV4IDk5ZjMzM2I4NS4uZTEzYmQwZGY3IDEwMDY0NAotLS0gYS9zcmMvbW9kYnVzLmMKKysrIGIvc3JjL21vZGJ1cy5jCkBAIC05NjEsNyArOTYxLDcgQEAgaW50IG1vZGJ1c19yZXBseShtb2RidXNfdCAqY3R4LCBjb25zdCB1aW50OF90ICpyZXEsCiAgICAgICAgICAgICAgICAgbmJfd3JpdGUsIG5iLCBNT0RCVVNfTUFYX1dSX1dSSVRFX1JFR0lTVEVSUywgTU9EQlVTX01BWF9XUl9SRUFEX1JFR0lTVEVSUyk7CiAgICAgICAgIH0gZWxzZSBpZiAobWFwcGluZ19hZGRyZXNzIDwgMCB8fAogICAgICAgICAgICAgICAgICAgIChtYXBwaW5nX2FkZHJlc3MgKyBuYikgPiBtYl9tYXBwaW5nLT5uYl9yZWdpc3RlcnMgfHwKLSAgICAgICAgICAgICAgICAgICBtYXBwaW5nX2FkZHJlc3MgPCAwIHx8CisgICAgICAgICAgICAgICAgICAgbWFwcGluZ19hZGRyZXNzX3dyaXRlIDwgMCB8fAogICAgICAgICAgICAgICAgICAgIChtYXBwaW5nX2FkZHJlc3Nfd3JpdGUgKyBuYl93cml0ZSkgPiBtYl9tYXBwaW5nLT5uYl9yZWdpc3RlcnMpIHsKICAgICAgICAgICAgIHJzcF9sZW5ndGggPSByZXNwb25zZV9leGNlcHRpb24oCiAgICAgICAgICAgICAgICAgY3R4LCAmc2Z0LCBNT0RCVVNfRVhDRVBUSU9OX0lMTEVHQUxfREFUQV9BRERSRVNTLCByc3AsIEZBTFNFLA==",
"url": "https://github.com/stephane/libmodbus/commit/b4ef4c17d618eba0adccc4c7d9e9a1ef809fc9b6"
}
] |
CWE-119 - Improper Restriction of Operations within the Bounds of a Memory Buffer.
|
|
CVE-2018-12249
|
An issue was discovered in mruby 1.4.1. There is a NULL pointer dereference in mrb_class_real because "class BasicObject" is not properly supported in class.c.
|
[
{
"commit_message": "[PATCH] `mrb_class_real()` did not work for `BasicObject`; fix #4037 src/class.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSBmYWE0ZWFmNjgwM2JkMTE2NjliYzMyNGI0YzM0ZTcxNjIyODZiZmEzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiAiWXVraWhpcm8gXCJNYXR6XCIgTWF0c3Vtb3RvIiA8bWF0ekBydWJ5Lm9yLmpwPgpEYXRlOiBGcmksIDggSnVuIDIwMTggMTQ6MTM6MDYgKzA5MDAKU3ViamVjdDogW1BBVENIXSBgbXJiX2NsYXNzX3JlYWwoKWAgZGlkIG5vdCB3b3JrIGZvciBgQmFzaWNPYmplY3RgOyBmaXggIzQwMzcKCi0tLQogc3JjL2NsYXNzLmMgfCA0ICsrLS0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2NsYXNzLmMgYi9zcmMvY2xhc3MuYwppbmRleCBjNzYxZjQ2YWYxLi5hOTQzOWQ3ZDdkIDEwMDY0NAotLS0gYS9zcmMvY2xhc3MuYworKysgYi9zcmMvY2xhc3MuYwpAQCAtMTc2MywxMCArMTc2MywxMCBAQCBtcmJfY2xhc3NfcGF0aChtcmJfc3RhdGUgKm1yYiwgc3RydWN0IFJDbGFzcyAqYykKIE1SQl9BUEkgc3RydWN0IFJDbGFzcyoKIG1yYl9jbGFzc19yZWFsKHN0cnVjdCBSQ2xhc3MqIGNsKQogewotICBpZiAoY2wgPT0gMCkKLSAgICByZXR1cm4gTlVMTDsKKyAgaWYgKGNsID09IDApIHJldHVybiBOVUxMOwogICB3aGlsZSAoKGNsLT50dCA9PSBNUkJfVFRfU0NMQVNTKSB8fCAoY2wtPnR0ID09IE1SQl9UVF9JQ0xBU1MpKSB7CiAgICAgY2wgPSBjbC0+c3VwZXI7CisgICAgaWYgKGNsID09IDApIHJldHVybiBOVUxMOwogICB9CiAgIHJldHVybiBjbDsKIH0=",
"url": "https://github.com/mruby/mruby/commit/faa4eaf6803bd11669bc324b4c34e7162286bfa3"
}
] |
n/a
|
|
CVE-2025-62366
|
Mailgen vulnerable to HTML injection and cross-site scripting via plaintext email generation
|
mailgen is a Node.js package that generates responsive HTML e-mails for sending transactional mail. Mailgen versions through 2.0.30 contain an HTML injection vulnerability in plaintext emails produced by the generatePlaintext method when user‑generated content is supplied. The function attempts to remove HTML tags, but if tags are provided as encoded HTML entities they are not removed and are later decoded, resulting in active HTML (for example an img tag with an event handler) in the supposed plaintext output. In contexts where the generated plaintext string is subsequently rendered as HTML, this can allow execution of attacker‑controlled JavaScript. Versions 2.0.31 and later contain a fix. No known workarounds exist.
|
[
{
"commit_message": "[PATCH] index.js: Fix additional HTML injection security issue in plaintext e-mails (thanks @edoardottt) index.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)",
"patch_text_b64": "RnJvbSA3Mjc5YTk4MzQ4MWQwNWM1MWFhNDUxZTg2MTQ2Zjk4YWFhNDJmZWU5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFbGFkIE5hdmEgPGVsYWRuYXZhQGdtYWlsLmNvbT4KRGF0ZTogVHVlLCAxNCBPY3QgMjAyNSAwOToxMjowNSArMDMwMApTdWJqZWN0OiBbUEFUQ0hdIGluZGV4LmpzOiBGaXggYWRkaXRpb25hbCBIVE1MIGluamVjdGlvbiBzZWN1cml0eSBpc3N1ZSBpbgogcGxhaW50ZXh0IGUtbWFpbHMgKHRoYW5rcyBAZWRvYXJkb3R0dCkKCi0tLQogaW5kZXguanMgfCA2ICsrKy0tLQogMSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9pbmRleC5qcyBiL2luZGV4LmpzCmluZGV4IDliOWQ5NmUuLjBhMWE5ZjMgMTAwNjQ0Ci0tLSBhL2luZGV4LmpzCisrKyBiL2luZGV4LmpzCkBAIC0xMjIsMTIgKzEyMiwxMiBAQCBNYWlsZ2VuLnByb3RvdHlwZS5nZW5lcmF0ZVBsYWludGV4dCA9IGZ1bmN0aW9uIChwYXJhbXMpIHsKICAgICAgICAgb3V0cHV0ID0gb3V0cHV0LnJlcGxhY2UoL14oPzogfFx0KSovZ20sICIiKTsKICAgICB9CiAKLSAgICAvLyBTdHJpcCBhbGwgSFRNTCB0YWdzIGZyb20gcGxhaW50ZXh0IG91dHB1dAotICAgIG91dHB1dCA9IG91dHB1dC5yZXBsYWNlKC88KC58XG4pKz8+L2csICcnKTsKLQogICAgIC8vIERlY29kZSBIVE1MIGVudGl0aWVzIHN1Y2ggYXMgJmNvcHk7CiAgICAgb3V0cHV0ID0gaGUuZGVjb2RlKG91dHB1dCk7CiAKKyAgICAvLyBTdHJpcCBhbGwgSFRNTCB0YWdzIGZyb20gcGxhaW50ZXh0IG91dHB1dAorICAgIG91dHB1dCA9IG91dHB1dC5yZXBsYWNlKC88KC58XG4pKz8+L2csICcnKTsKKwogICAgIC8vIEFsbCBkb25lIQogICAgIHJldHVybiBvdXRwdXQ7CiB9Ow==",
"url": "https://github.com/eladnava/mailgen/commit/7279a983481d05c51aa451e86146f98aaa42fee9"
}
] |
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
CVE-2020-5203
|
In Fat-Free Framework 3.7.1, attackers can achieve arbitrary code execution if developers choose to pass user controlled input (e.g., $_REQUEST, $_GET, or $_POST) to the framework's Clear method.
|
[
{
"commit_message": "[PATCH] ensure misuse of clear() wont open a vulnerability base.php | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)",
"patch_text_b64": "RnJvbSBkYWU5NWEwYmFmMzk2M2E5ZWY4N2MxN2NlZTUyZjc4Zjc3ZTIxODI5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBpa2tleiA8aWtrZXowbjNAZ21haWwuY29tPgpEYXRlOiBTYXQsIDQgSmFuIDIwMjAgMTU6NDM6NDEgKzAxMDAKU3ViamVjdDogW1BBVENIXSBlbnN1cmUgbWlzdXNlIG9mIGNsZWFyKCkgd29udCBvcGVuIGEgdnVsbmVyYWJpbGl0eQoKLS0tCiBiYXNlLnBocCB8IDggKysrKy0tLS0KIDEgZmlsZSBjaGFuZ2VkLCA0IGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYmFzZS5waHAgYi9iYXNlLnBocAppbmRleCBlODIzNGQ2Yi4uNDQxYWRlNTYgMTAwNjQ0Ci0tLSBhL2Jhc2UucGhwCisrKyBiL2Jhc2UucGhwCkBAIC01MDMsNiArNTAzLDggQEAgZnVuY3Rpb24gY2xlYXIoJGtleSkgewogCQkJLy8gUmVzZXQgZ2xvYmFsIHRvIGRlZmF1bHQgdmFsdWUKIAkJCSR0aGlzLT5oaXZlWyRwYXJ0c1swXV09JHRoaXMtPmluaXRbJHBhcnRzWzBdXTsKIAkJZWxzZSB7CisJCQkvLyBFbnN1cmUgd2UgaGF2ZSBubyBjb2RlIGluamVjdGlvbgorCQkJJGtleT1wcmVnX3JlcGxhY2UoJy8oXClcVypcdysuKiQpLycsJycsJGtleSk7CiAJCQlldmFsKCd1bnNldCgnLiR0aGlzLT5jb21waWxlKCdAdGhpcy0+aGl2ZS4nLiRrZXkpLicpOycpOwogCQkJaWYgKCRwYXJ0c1swXT09J1NFU1NJT04nKSB7CiAJCQkJc2Vzc2lvbl9jb21taXQoKTsKQEAgLTI5NjMsMTMgKzI5NjUsMTEgQEAgZnVuY3Rpb24gYygkdmFsKSB7CiAJKglAcGFyYW0gJHN0ciBzdHJpbmcKIAkqKi8KIAlmdW5jdGlvbiB0b2tlbigkc3RyKSB7Ci0JCSRmdz0kdGhpcy0+Znc7Ci0JCSRzdHI9dHJpbShwcmVnX3JlcGxhY2UoJy9ce1x7KC4rPylcfVx9L3MnLHRyaW0oJ1wxJyksCi0JCQkkZnctPmNvbXBpbGUoJHN0cikpKTsKKwkJJHN0cj10cmltKHByZWdfcmVwbGFjZSgnL1x7XHsoLis/KVx9XH0vcycsJ1wxJywkdGhpcy0+ZnctPmNvbXBpbGUoJHN0cikpKTsKIAkJaWYgKHByZWdfbWF0Y2goJy9eKC4rKSg/PCFcfClcfCgoPzpcaCpcdysoPzpcaCpbLDtdPykpKykkL3MnLAogCQkJJHN0ciwkcGFydHMpKSB7CiAJCQkkc3RyPXRyaW0oJHBhcnRzWzFdKTsKLQkJCWZvcmVhY2ggKCRmdy0+c3BsaXQodHJpbSgkcGFydHNbMl0sIlx4QzJceEEwIikpIGFzICRmdW5jKQorCQkJZm9yZWFjaCAoJHRoaXMtPmZ3LT5zcGxpdCh0cmltKCRwYXJ0c1syXSwiXHhDMlx4QTAiKSkgYXMgJGZ1bmMpCiAJCQkJJHN0cj0oKGVtcHR5KCR0aGlzLT5maWx0ZXJbJGNtZD0kZnVuY10pICYmCiAJCQkJCWZ1bmN0aW9uX2V4aXN0cygkY21kKSkgfHwKIAkJCQkJaXNfc3RyaW5nKCRjbWQ9JHRoaXMtPmZpbHRlcigkZnVuYykpKT8=",
"url": "https://github.com/bcosca/fatfree-core/commit/dae95a0baf3963a9ef87c17cee52f78f77e21829"
}
] |
n/a
|
|
CVE-2023-38700
|
matrix-appservice-irc events can be crafted to leak parts of targeted messages from other bridged rooms
|
matrix-appservice-irc is a Node.js IRC bridge for Matrix. Prior to version 1.0.1, it was possible to craft an event such that it would leak part of a targeted message event from another bridged room. This required knowing an event ID to target. Version 1.0.1n fixes this issue. As a workaround, set the `matrixHandler.eventCacheSize` config value to `0`. This workaround may impact performance.
|
[
{
"commit_message": "[PATCH] Merge pull request from GHSA-c7hh-3v6c-fj4q src/bridge/MatrixHandler.ts | 45 +++++++++++++++++++++---------------- 1 file changed, 26 insertions(+), 19 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/matrix-org/matrix-appservice-irc/commit/8bbd2b69a16cbcbeffdd9b5c973fd89d61498d75"
}
] |
CWE-200: Exposure of Sensitive Information to an Unauthorized Actor
|
CVE-2015-5219
|
The ULOGTOD function in ntp.d in SNTP before 4.2.7p366 does not properly perform type conversions from a precision value to a double, which allows remote attackers to cause a denial of service (infinite loop) via a crafted NTP packet.
|
[
{
"commit_message": "[PATCH] [Bug 2382] Implement LOGTOD using ldexp() instead of shifting ChangeLog | 1 + include/ntp.h | 5 ++--- 2 files changed, 3 insertions(+), 3 deletions(-)",
"patch_text_b64": "RnJvbSA1ZjI5NWNkMDVjM2MxMzZkMzlmNWIzZTUwMGEyZDc4MWJkYmI1OWM4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiAgPHN0ZW5uQGRlYWNvbi51ZGVsLmVkdT4KRGF0ZTogV2VkLCAyNCBBcHIgMjAxMyAxOToxMzo1MyAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFtCdWcgMjM4Ml0gSW1wbGVtZW50IExPR1RPRCB1c2luZyBsZGV4cCgpIGluc3RlYWQgb2Ygc2hpZnRpbmcKCi0tLQogQ2hhbmdlTG9nICAgICB8IDEgKwogaW5jbHVkZS9udHAuaCB8IDUgKystLS0KIDIgZmlsZXMgY2hhbmdlZCwgMyBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCBmOGEzZGQ2ZjQ4Li41NmM3YjE4ZTdhIDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdlTG9nCkBAIC0xLDQgKzEsNSBAQAogKiBbQnVnIDE0ODVdIFNvbWV0aW1lcyBudHBkIGNyYXNoZXMKKyogW0J1ZyAyMzgyXSBJbXBsZW1lbnQgTE9HVE9EIHVzaW5nIGxkZXhwKCkgaW5zdGVhZCBvZiBzaGlmdGluZy4KICg0LjIuN3AzNjYpIDIwMTMvMDQvMTcgUmVsZWFzZWQgYnkgSGFybGFuIFN0ZW5uIDxzdGVubkBudHAub3JnPgogKiBbQnVnIDE4NjZdIERpc2FibGUgc29tZSBkZWJ1Z2dpbmcgb3V0cHV0IGluIHJlZmNsb2NrX29uY29yZS4KICg0LjIuN3AzNjUpIDIwMTMvMDQvMTYgUmVsZWFzZWQgYnkgSGFybGFuIFN0ZW5uIDxzdGVubkBudHAub3JnPgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9udHAuaCBiL2luY2x1ZGUvbnRwLmgKaW5kZXggYWE0NWUxNjA0My4uOTViMjU0MmFiYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9udHAuaAorKysgYi9pbmNsdWRlL250cC5oCkBAIC0xNTYsMTAgKzE1Niw5IEBAIHR5cGVkZWYgY2hhciBzX2NoYXI7CiAjZGVmaW5lIFNRVUFSRSh4KSAoKHgpICogKHgpKQogI2RlZmluZSBTUVJUKHgpIChzcXJ0KHgpKQogI2RlZmluZSBESUZGKHgsIHkpIChTUVVBUkUoKHgpIC0gKHkpKSkKLSNkZWZpbmUgTE9HVE9EKGEpCSgoYSkgPCAwID8gMS4gLyAoMUwgPDwgLShhKSkgOiBcCi0JCQkgICAgMUwgPDwgKGludCkoYSkpIC8qIGxvZzIgdG8gZG91YmxlICovCisjZGVmaW5lIExPR1RPRChhKQlsZGV4cCgxLiwgKGludCkoYSkpIC8qIGxvZzIgdG8gZG91YmxlICovCiAjZGVmaW5lIFVOSVZBUih4KQkoU1FVQVJFKC4yODg2NzUxMyAqIExPR1RPRCh4KSkpIC8qIHN0ZCB1bmlmb3JtIGRpc3RyICovCi0jZGVmaW5lIFVMT0dUT0QoYSkJKDFMIDw8IChpbnQpKGEpKSAvKiB1bG9nMiB0byBkb3VibGUgKi8KKyNkZWZpbmUgVUxPR1RPRChhKQlsZGV4cCgxLiwgKGludCkoYSkpIC8qIHVsb2cyIHRvIGRvdWJsZSAqLwogCiAjZGVmaW5lCUVWRU5UX1RJTUVPVVQJMAkvKiBvbmUgc2Vjb25kLCB0aGF0IGlzICov",
"url": "https://github.com/ntp-project/ntp/commit/5f295cd05c3c136d39f5b3e500a2d781bdbb59c8"
}
] |
n/a
|
|
CVE-2022-4850
|
Cross-Site Request Forgery (CSRF) in usememos/memos
|
Cross-Site Request Forgery (CSRF) in GitHub repository usememos/memos prior to 0.9.1.
|
[
{
"commit_message": "[PATCH] chore: fix CSRF (#876) server/acl.go | 1 + server/server.go | 4 ++++ 2 files changed, 5 insertions(+)",
"patch_text_b64": "RnJvbSBjOWJiMmI3ODVkYzU4NTI2NTU0MDVkNWM5YWIxMjdhMmQ1YWEzOTQ4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBib29qYWNrIDxzdGV2ZW5sZ3RtQGdtYWlsLmNvbT4KRGF0ZTogRnJpLCAzMCBEZWMgMjAyMiAwMDoxNzoxOSArMDgwMApTdWJqZWN0OiBbUEFUQ0hdIGNob3JlOiBmaXggQ1NSRiAoIzg3NikKCi0tLQogc2VydmVyL2FjbC5nbyAgICB8IDEgKwogc2VydmVyL3NlcnZlci5nbyB8IDQgKysrKwogMiBmaWxlcyBjaGFuZ2VkLCA1IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9zZXJ2ZXIvYWNsLmdvIGIvc2VydmVyL2FjbC5nbwppbmRleCBjY2I2N2U4MTMxM2M4Li44N2U1YmFkN2ZkMzM4IDEwMDY0NAotLS0gYS9zZXJ2ZXIvYWNsLmdvCisrKyBiL3NlcnZlci9hY2wuZ28KQEAgLTI3LDYgKzI3LDcgQEAgZnVuYyBzZXRVc2VyU2Vzc2lvbihjdHggZWNoby5Db250ZXh0LCB1c2VyICphcGkuVXNlcikgZXJyb3IgewogCQlQYXRoOiAgICAgIi8iLAogCQlNYXhBZ2U6ICAgMzYwMCAqIDI0ICogMzAsCiAJCUh0dHBPbmx5OiB0cnVlLAorCQlTYW1lU2l0ZTogaHR0cC5TYW1lU2l0ZVN0cmljdE1vZGUsCiAJfQogCXNlc3MuVmFsdWVzW3VzZXJJRENvbnRleHRLZXldID0gdXNlci5JRAogCWVyciA6PSBzZXNzLlNhdmUoY3R4LlJlcXVlc3QoKSwgY3R4LlJlc3BvbnNlKCkpCmRpZmYgLS1naXQgYS9zZXJ2ZXIvc2VydmVyLmdvIGIvc2VydmVyL3NlcnZlci5nbwppbmRleCAyNDNmMjZhZGYwNWVkLi41ZTU3ZWE4YTI1Yzk2IDEwMDY0NAotLS0gYS9zZXJ2ZXIvc2VydmVyLmdvCisrKyBiL3NlcnZlci9zZXJ2ZXIuZ28KQEAgLTM2LDYgKzM2LDEwIEBAIGZ1bmMgTmV3U2VydmVyKHByb2ZpbGUgKnByb2ZpbGUuUHJvZmlsZSkgKlNlcnZlciB7CiAJCQlgInN0YXR1cyI6JHtzdGF0dXN9LCJlcnJvciI6IiR7ZXJyb3J9In1gICsgIlxuIiwKIAl9KSkKIAorCWUuVXNlKG1pZGRsZXdhcmUuQ1NSRldpdGhDb25maWcobWlkZGxld2FyZS5DU1JGQ29uZmlneworCQlUb2tlbkxvb2t1cDogImNvb2tpZTpfY3NyZiIsCisJfSkpCisKIAllLlVzZShtaWRkbGV3YXJlLkNPUlMoKSkKIAogCWUuVXNlKG1pZGRsZXdhcmUuVGltZW91dFdpdGhDb25maWcobWlkZGxld2FyZS5UaW1lb3V0Q29uZmlnew==",
"url": "https://github.com/usememos/memos/commit/c9bb2b785dc5852655405d5c9ab127a2d5aa3948"
}
] |
CWE-352 Cross-Site Request Forgery (CSRF)
|
CVE-2024-43199
|
Nagios NDOUtils before 2.1.4 allows privilege escalation from nagios to root because certain executable files are owned by the nagios user.
|
[
{
"commit_message": "[PATCH] configure.ac: don't install binaries as ndo2db_user:ndo2db_group In configure.ac we were adding two flags to INSTALL_OPTS that change the owner:group of all installed files to ndo2db_user:ndo2db_group. This is often a security vulnerability, since executables (we have a few) are typically installed into everyone's PATH. If root ever executes them, the ndo2db_user can take advantage of the situation to run malicious code as root. Fortunately the change in ownership is not really needed. We simply drop the INSTALL_OPTS, which are used for nothing else, allowing our files to be installed as the user who is doing the installing. When installing to one of the system PATHs, that will almost always be root. Makefile.in | 9 ++++----- configure.ac | 2 -- docs/docbook/en-en/Makefile.in | 1 - src/Makefile.in | 31 +++++++++++++++---------------- 4 files changed, 19 insertions(+), 24 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/NagiosEnterprises/ndoutils/commit/18ef12037f4a68772d6840cbaa08aa2da07d2891"
}
] |
n/a
|
|
CVE-2017-15204
|
In Kanboard before 1.0.47, by altering form data, an authenticated user can add automatic actions to a private project of another user.
|
[
{
"commit_message": "[PATCH] Avoid people to alter other projects by changing form data ChangeLog | 4 + app/Controller/ActionController.php | 5 +- app/Controller/ActionCreationController.php | 7 +- app/Controller/BaseController.php | 90 +++++++++++++++++++++ app/Controller/CategoryController.php | 31 +++---- app/Controller/ColumnController.php | 16 ++-- app/Controller/CustomFilterController.php | 7 +- app/Controller/ProjectEditController.php | 2 + app/Controller/ProjectTagController.php | 33 +++----- app/Controller/SwimlaneController.php | 43 ++++------ app/Controller/TaskCreationController.php | 1 + app/Template/action_creation/create.php | 1 - app/Template/action_creation/event.php | 1 - app/Template/action_creation/params.php | 1 - app/Template/category/create.php | 1 - app/Template/category/edit.php | 3 - app/Template/column/create.php | 2 - app/Template/column/edit.php | 3 - app/Template/custom_filter/create.php | 1 - app/Template/custom_filter/edit.php | 2 - app/Template/project_edit/show.php | 1 - app/Template/project_tag/create.php | 1 - app/Template/project_tag/edit.php | 2 - app/Template/swimlane/create.php | 2 - app/Template/swimlane/edit.php | 4 - app/Template/task_creation/show.php | 1 - 26 files changed, 154 insertions(+), 111 deletions(-)",
"patch_text_b64": "From 074f6c104f3e49401ef0065540338fc2d4be79f0 Mon Sep 17 00:00:00 2001
From: Frederic Guillot <fred@kanboard.net>
Date: Sat, 23 Sep 2017 18:48:45 -0700
Subject: [PATCH] Avoid people to alter other projects by changing form data

---
 ChangeLog                                   |  4 +
 app/Controller/ActionController.php         |  5 +-
 app/Controller/ActionCreationController.php |  7 +-
 app/Controller/BaseController.php           | 90 +++++++++++++++++++++
 app/Controller/CategoryController.php       | 31 +++----
 app/Controller/ColumnController.php         | 16 ++--
 app/Controller/CustomFilterController.php   |  7 +-
 app/Controller/ProjectEditController.php    |  2 +
 app/Controller/ProjectTagController.php     | 33 +++-----
 app/Controller/SwimlaneController.php       | 43 ++++------
 app/Controller/TaskCreationController.php   |  1 +
 app/Template/action_creation/create.php     |  1 -
 app/Template/action_creation/event.php      |  1 -
 app/Template/action_creation/params.php     |  1 -
 app/Template/category/create.php            |  1 -
 app/Template/category/edit.php              |  3 -
 app/Template/column/create.php              |  2 -
 app/Template/column/edit.php                |  3 -
 app/Template/custom_filter/create.php       |  1 -
 app/Template/custom_filter/edit.php         |  2 -
 app/Template/project_edit/show.php          |  1 -
 app/Template/project_tag/create.php         |  1 -
 app/Template/project_tag/edit.php           |  2 -
 app/Template/swimlane/create.php            |  2 -
 app/Template/swimlane/edit.php              |  4 -
 app/Template/task_creation/show.php         |  1 -
 26 files changed, 154 insertions(+), 111 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index 8ff191af3c..b209dc2b89 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -5,6 +5,10 @@ New features:
 
 * Vietnamese translation
 
+Security Issues:
+
+* Avoid people to alter other project resources by changing form data
+
 Version 1.0.46 (August 13, 2017)
 --------------------------------
 
diff --git a/app/Controller/ActionController.php b/app/Controller/ActionController.php
index c935125ae5..43acf59023 100644
--- a/app/Controller/ActionController.php
+++ b/app/Controller/ActionController.php
@@ -46,9 +46,10 @@ public function index()
     public function confirm()
     {
         $project = $this->getProject();
+        $action = $this->getAction($project);
 
         $this->response->html($this->helper->layout->project('action/remove', array(
-            'action' => $this->actionModel->getById($this->request->getIntegerParam('action_id')),
+            'action' => $action,
             'available_events' => $this->eventManager->getAll(),
             'available_actions' => $this->actionManager->getAvailableActions(),
             'project' => $project,
@@ -65,7 +66,7 @@ public function remove()
     {
         $this->checkCSRFParam();
         $project = $this->getProject();
-        $action = $this->actionModel->getById($this->request->getIntegerParam('action_id'));
+        $action = $this->getAction($project);
 
         if (! empty($action) && $this->actionModel->remove($action['id'])) {
             $this->flash->success(t('Action removed successfully.'));
diff --git a/app/Controller/ActionCreationController.php b/app/Controller/ActionCreationController.php
index 7fee58d1ff..abb214e642 100644
--- a/app/Controller/ActionCreationController.php
+++ b/app/Controller/ActionCreationController.php
@@ -35,8 +35,9 @@ public function event()
     {
         $project = $this->getProject();
         $values = $this->request->getValues();
+        $values['project_id'] = $project['id'];
 
-        if (empty($values['action_name']) || empty($values['project_id'])) {
+        if (empty($values['action_name'])) {
             return $this->create();
         }
 
@@ -57,8 +58,9 @@ public function params()
     {
         $project = $this->getProject();
         $values = $this->request->getValues();
+        $values['project_id'] = $project['id'];
 
-        if (empty($values['action_name']) || empty($values['project_id']) || empty($values['event_name'])) {
+        if (empty($values['action_name']) || empty($values['event_name'])) {
             $this->create();
             return;
         }
@@ -109,6 +111,7 @@ public function save()
      */
     private function doCreation(array $project, array $values)
     {
+        $values['project_id'] = $project['id'];
         list($valid, ) = $this->actionValidator->validateCreation($values);
 
         if ($valid) {
diff --git a/app/Controller/BaseController.php b/app/Controller/BaseController.php
index 5233e27fd4..1ac7ed2038 100644
--- a/app/Controller/BaseController.php
+++ b/app/Controller/BaseController.php
@@ -155,4 +155,94 @@ protected function getSubtask()
 
         return $subtask;
     }
+
+    protected function getColumn(array $project)
+    {
+        $column = $this->columnModel->getById($this->request->getIntegerParam('column_id'));
+
+        if (empty($column)) {
+            throw new PageNotFoundException();
+        }
+
+        if ($column['project_id'] != $project['id']) {
+            throw new AccessForbiddenException();
+        }
+
+        return $column;
+    }
+
+    protected function getSwimlane(array $project)
+    {
+        $swimlane = $this->swimlaneModel->getById($this->request->getIntegerParam('swimlane_id'));
+
+        if (empty($swimlane)) {
+            throw new PageNotFoundException();
+        }
+
+        if ($swimlane['project_id'] != $project['id']) {
+            throw new AccessForbiddenException();
+        }
+
+        return $swimlane;
+    }
+
+    protected function getCategory(array $project)
+    {
+        $category = $this->categoryModel->getById($this->request->getIntegerParam('category_id'));
+
+        if (empty($category)) {
+            throw new PageNotFoundException();
+        }
+
+        if ($category['project_id'] != $project['id']) {
+            throw new AccessForbiddenException();
+        }
+
+        return $category;
+    }
+
+    protected function getProjectTag(array $project)
+    {
+        $tag = $this->tagModel->getById($this->request->getIntegerParam('tag_id'));
+
+        if (empty($tag)) {
+            throw new PageNotFoundException();
+        }
+
+        if ($tag['project_id'] != $project['id']) {
+            throw new AccessForbiddenException();
+        }
+
+        return $tag;
+    }
+
+    protected function getAction(array $project)
+    {
+        $action = $this->actionModel->getById($this->request->getIntegerParam('action_id'));
+
+        if (empty($action)) {
+            throw new PageNotFoundException();
+        }
+
+        if ($action['project_id'] != $project['id']) {
+            throw new AccessForbiddenException();
+        }
+
+        return $action;
+    }
+
+    protected function getCustomFilter(array $project)
+    {
+        $filter = $this->customFilterModel->getById($this->request->getIntegerParam('filter_id'));
+
+        if (empty($filter)) {
+            throw new PageNotFoundException();
+        }
+
+        if ($filter['project_id'] != $project['id']) {
+            throw new AccessForbiddenException();
+        }
+
+        return $filter;
+    }
 }
diff --git a/app/Controller/CategoryController.php b/app/Controller/CategoryController.php
index 69bbad5aa1..e3f2406b64 100644
--- a/app/Controller/CategoryController.php
+++ b/app/Controller/CategoryController.php
@@ -12,24 +12,6 @@
  */
 class CategoryController extends BaseController
 {
-    /**
-     * Get the category (common method between actions)
-     *
-     * @access private
-     * @return array
-     * @throws PageNotFoundException
-     */
-    private function getCategory()
-    {
-        $category = $this->categoryModel->getById($this->request->getIntegerParam('category_id'));
-
-        if (empty($category)) {
-            throw new PageNotFoundException();
-        }
-
-        return $category;
-    }
-
     /**
      * List of categories for a given project
      *
@@ -72,8 +54,9 @@ public function create(array $values = array(), array $errors = array())
     public function save()
     {
         $project = $this->getProject();
-
         $values = $this->request->getValues();
+        $values['project_id'] = $project['id'];
+
         list($valid, $errors) = $this->categoryValidator->validateCreation($values);
 
         if ($valid) {
@@ -100,7 +83,7 @@ public function save()
     public function edit(array $values = array(), array $errors = array())
     {
         $project = $this->getProject();
-        $category = $this->getCategory();
+        $category = $this->getCategory($project);
 
         $this->response->html($this->template->render('category/edit', array(
             'values'  => empty($values) ? $category : $values,
@@ -117,8 +100,12 @@ public function edit(array $values = array(), array $errors = array())
     public function update()
     {
         $project = $this->getProject();
+        $category = $this->getCategory($project);
 
         $values = $this->request->getValues();
+        $values['project_id'] = $project['id'];
+        $values['id'] = $category['id'];
+
         list($valid, $errors) = $this->categoryValidator->validateModification($values);
 
         if ($valid) {
@@ -141,7 +128,7 @@ public function update()
     public function confirm()
     {
         $project = $this->getProject();
-        $category = $this->getCategory();
+        $category = $this->getCategory($project);
 
         $this->response->html($this->helper->layout->project('category/remove', array(
             'project'  => $project,
@@ -158,7 +145,7 @@ public function remove()
     {
         $this->checkCSRFParam();
         $project = $this->getProject();
-        $category = $this->getCategory();
+        $category = $this->getCategory($project);
 
         if ($this->categoryModel->remove($category['id'])) {
             $this->flash->success(t('Category removed successfully.'));
diff --git a/app/Controller/ColumnController.php b/app/Controller/ColumnController.php
index 7047d30e14..8e4712d979 100644
--- a/app/Controller/ColumnController.php
+++ b/app/Controller/ColumnController.php
@@ -61,6 +61,7 @@ public function save()
     {
         $project = $this->getProject();
         $values = $this->request->getValues() + array('hide_in_dashboard' => 0);
+        $values['project_id'] = $project['id'];
 
         list($valid, $errors) = $this->columnValidator->validateCreation($values);
 
@@ -95,7 +96,7 @@ public function save()
     public function edit(array $values = array(), array $errors = array())
     {
         $project = $this->getProject();
-        $column = $this->columnModel->getById($this->request->getIntegerParam('column_id'));
+        $column = $this->getColumn($project);
 
         $this->response->html($this->helper->layout->project('column/edit', array(
             'errors' => $errors,
@@ -113,7 +114,11 @@ public function edit(array $values = array(), array $errors = array())
     public function update()
     {
         $project = $this->getProject();
+        $column = $this->getColumn($project);
+
         $values = $this->request->getValues() + array('hide_in_dashboard' => 0);
+        $values['project_id'] = $project['id'];
+        $values['id'] = $column['id'];
 
         list($valid, $errors) = $this->columnValidator->validateModification($values);
 
@@ -164,9 +169,10 @@ public function move()
     public function confirm()
     {
         $project = $this->getProject();
+        $column = $this->getColumn($project);
 
         $this->response->html($this->helper->layout->project('column/remove', array(
-            'column' => $this->columnModel->getById($this->request->getIntegerParam('column_id')),
+            'column' => $column,
             'project' => $project,
         )));
     }
@@ -178,11 +184,11 @@ public function confirm()
      */
     public function remove()
     {
-        $project = $this->getProject();
         $this->checkCSRFParam();
-        $column_id = $this->request->getIntegerParam('column_id');
+        $project = $this->getProject();
+        $column = $this->getColumn($project);
 
-        if ($this->columnModel->remove($column_id)) {
+        if ($this->columnModel->remove($column['id'])) {
             $this->flash->success(t('Column removed successfully.'));
         } else {
             $this->flash->failure(t('Unable to remove this column.'));
diff --git a/app/Controller/CustomFilterController.php b/app/Controller/CustomFilterController.php
index dfe1ffc4cc..1bf1617e82 100644
--- a/app/Controller/CustomFilterController.php
+++ b/app/Controller/CustomFilterController.php
@@ -59,6 +59,7 @@ public function save()
         $project = $this->getProject();
 
         $values = $this->request->getValues();
+        $values['project_id'] = $project['id'];
         $values['user_id'] = $this->userSession->getId();
 
         list($valid, $errors) = $this->customFilterValidator->validateCreation($values);
@@ -84,7 +85,7 @@ public function save()
     public function confirm()
     {
         $project = $this->getProject();
-        $filter = $this->customFilterModel->getById($this->request->getIntegerParam('filter_id'));
+        $filter = $this->getCustomFilter($project);
 
         $this->response->html($this->helper->layout->project('custom_filter/remove', array(
             'project' => $project,
@@ -102,7 +103,7 @@ public function remove()
     {
         $this->checkCSRFParam();
         $project = $this->getProject();
-        $filter = $this->customFilterModel->getById($this->request->getIntegerParam('filter_id'));
+        $filter = $this->getCustomFilter($project);
 
         $this->checkPermission($project, $filter);
 
@@ -153,6 +154,8 @@ public function update()
         $this->checkPermission($project, $filter);
 
         $values = $this->request->getValues();
+        $values['id'] = $filter['id'];
+        $values['project_id'] = $project['id'];
 
         if (! isset($values['is_shared'])) {
             $values += array('is_shared' => 0);
diff --git a/app/Controller/ProjectEditController.php b/app/Controller/ProjectEditController.php
index ae39fdf356..dd5345084c 100644
--- a/app/Controller/ProjectEditController.php
+++ b/app/Controller/ProjectEditController.php
@@ -65,6 +65,8 @@ public function update()
      */
     private function prepareValues(array $project, array $values)
     {
+        $values['id'] = $project['id'];
+
         if (isset($values['is_private'])) {
             if (! $this->helper->user->hasProjectAccess('ProjectCreationController', 'create', $project['id'])) {
                 unset($values['is_private']);
diff --git a/app/Controller/ProjectTagController.php b/app/Controller/ProjectTagController.php
index d225f0cab8..c45e71e153 100644
--- a/app/Controller/ProjectTagController.php
+++ b/app/Controller/ProjectTagController.php
@@ -2,8 +2,6 @@
 
 namespace Kanboard\Controller;
 
-use Kanboard\Core\Controller\AccessForbiddenException;
-
 /**
  * Class ProjectTagController
  *
@@ -27,10 +25,6 @@ public function create(array $values = array(), array $errors = array())
     {
         $project = $this->getProject();
 
-        if (empty($values)) {
-            $values['project_id'] = $project['id'];
-        }
-
         $this->response->html($this->template->render('project_tag/create', array(
             'project' => $project,
             'values'  => $values,
@@ -42,6 +36,8 @@ public function save()
     {
         $project = $this->getProject();
         $values = $this->request->getValues();
+        $values['project_id'] = $project['id'];
+
         list($valid, $errors) = $this->tagValidator->validateCreation($values);
 
         if ($valid) {
@@ -60,8 +56,7 @@ public function save()
     public function edit(array $values = array(), array $errors = array())
     {
         $project = $this->getProject();
-        $tag_id = $this->request->getIntegerParam('tag_id');
-        $tag = $this->tagModel->getById($tag_id);
+        $tag = $this->getProjectTag($project);
 
         if (empty($values)) {
             $values = $tag;
@@ -78,14 +73,12 @@ public function edit(array $values = array(), array $errors = array())
     public function update()
     {
         $project = $this->getProject();
-        $tag_id = $this->request->getIntegerParam('tag_id');
-        $tag = $this->tagModel->getById($tag_id);
+        $tag = $this->getProjectTag($project);
         $values = $this->request->getValues();
-        list($valid, $errors) = $this->tagValidator->validateModification($values);
+        $values['project_id'] = $project['id'];
+        $values['id'] = $tag['id'];
 
-        if ($tag['project_id'] != $project['id']) {
-            throw new AccessForbiddenException();
-        }
+        list($valid, $errors) = $this->tagValidator->validateModification($values);
 
         if ($valid) {
             if ($this->tagModel->update($values['id'], $values['name'])) {
@@ -103,8 +96,7 @@ public function update()
     public function confirm()
     {
         $project = $this->getProject();
-        $tag_id = $this->request->getIntegerParam('tag_id');
-        $tag = $this->tagModel->getById($tag_id);
+        $tag = $this->getProjectTag($project);
 
         $this->response->html($this->template->render('project_tag/remove', array(
             'tag'     => $tag,
@@ -116,14 +108,9 @@ public function remove()
     {
         $this->checkCSRFParam();
         $project = $this->getProject();
-        $tag_id = $this->request->getIntegerParam('tag_id');
-        $tag = $this->tagModel->getById($tag_id);
-
-        if ($tag['project_id'] != $project['id']) {
-            throw new AccessForbiddenException();
-        }
+        $tag = $this->getProjectTag($project);
 
-        if ($this->tagModel->remove($tag_id)) {
+        if ($this->tagModel->remove($tag['id'])) {
             $this->flash->success(t('Tag removed successfully.'));
         } else {
             $this->flash->failure(t('Unable to remove this tag.'));
diff --git a/app/Controller/SwimlaneController.php b/app/Controller/SwimlaneController.php
index 0d81d83cc9..e6368b248d 100644
--- a/app/Controller/SwimlaneController.php
+++ b/app/Controller/SwimlaneController.php
@@ -3,8 +3,6 @@
 namespace Kanboard\Controller;
 
 use Kanboard\Core\Controller\AccessForbiddenException;
-use Kanboard\Core\Controller\PageNotFoundException;
-use Kanboard\Model\SwimlaneModel;
 
 /**
  * Swimlanes Controller
@@ -14,24 +12,6 @@
  */
 class SwimlaneController extends BaseController
 {
-    /**
-     * Get the swimlane (common method between actions)
-     *
-     * @access private
-     * @return array
-     * @throws PageNotFoundException
-     */
-    private function getSwimlane()
-    {
-        $swimlane = $this->swimlaneModel->getById($this->request->getIntegerParam('swimlane_id'));
-
-        if (empty($swimlane)) {
-            throw new PageNotFoundException();
-        }
-
-        return $swimlane;
-    }
-
     /**
      * List of swimlanes for a given project
      *
@@ -78,6 +58,8 @@ public function save()
     {
         $project = $this->getProject();
         $values = $this->request->getValues();
+        $values['project_id'] = $project['id'];
+
         list($valid, $errors) = $this->swimlaneValidator->validateCreation($values);
 
         if ($valid) {
@@ -104,7 +86,7 @@ public function save()
     public function edit(array $values = array(), array $errors = array())
     {
         $project = $this->getProject();
-        $swimlane = $this->getSwimlane();
+        $swimlane = $this->getSwimlane($project);
 
         $this->response->html($this->helper->layout->project('swimlane/edit', array(
             'values' => empty($values) ? $swimlane : $values,
@@ -121,8 +103,11 @@ public function edit(array $values = array(), array $errors = array())
     public function update()
     {
         $project = $this->getProject();
-
+        $swimlane = $this->getSwimlane($project);
         $values = $this->request->getValues();
+        $values['project_id'] = $project['id'];
+        $values['id'] = $swimlane['id'];
+
         list($valid, $errors) = $this->swimlaneValidator->validateModification($values);
 
         if ($valid) {
@@ -145,7 +130,7 @@ public function update()
     public function confirm()
     {
         $project = $this->getProject();
-        $swimlane = $this->getSwimlane();
+        $swimlane = $this->getSwimlane($project);
 
         $this->response->html($this->helper->layout->project('swimlane/remove', array(
             'project' => $project,
@@ -162,9 +147,9 @@ public function remove()
     {
         $this->checkCSRFParam();
         $project = $this->getProject();
-        $swimlane_id = $this->request->getIntegerParam('swimlane_id');
+        $swimlane = $this->getSwimlane($project);
 
-        if ($this->swimlaneModel->remove($project['id'], $swimlane_id)) {
+        if ($this->swimlaneModel->remove($project['id'], $swimlane['id'])) {
             $this->flash->success(t('Swimlane removed successfully.'));
         } else {
             $this->flash->failure(t('Unable to remove this swimlane.'));
@@ -182,9 +167,9 @@ public function disable()
     {
         $this->checkCSRFParam();
         $project = $this->getProject();
-        $swimlane_id = $this->request->getIntegerParam('swimlane_id');
+        $swimlane = $this->getSwimlane($project);
 
-        if ($this->swimlaneModel->disable($project['id'], $swimlane_id)) {
+        if ($this->swimlaneModel->disable($project['id'], $swimlane['id'])) {
             $this->flash->success(t('Swimlane updated successfully.'));
         } else {
             $this->flash->failure(t('Unable to update this swimlane.'));
@@ -202,9 +187,9 @@ public function enable()
     {
         $this->checkCSRFParam();
         $project = $this->getProject();
-        $swimlane_id = $this->request->getIntegerParam('swimlane_id');
+        $swimlane = $this->getSwimlane($project);
 
-        if ($this->swimlaneModel->enable($project['id'], $swimlane_id)) {
+        if ($this->swimlaneModel->enable($project['id'], $swimlane['id'])) {
             $this->flash->success(t('Swimlane updated successfully.'));
         } else {
             $this->flash->failure(t('Unable to update this swimlane.'));
diff --git a/app/Controller/TaskCreationController.php b/app/Controller/TaskCreationController.php
index 0d808c54c1..d050a60df8 100644
--- a/app/Controller/TaskCreationController.php
+++ b/app/Controller/TaskCreationController.php
@@ -49,6 +49,7 @@ public function save()
     {
         $project = $this->getProject();
         $values = $this->request->getValues();
+        $values['project_id'] = $project['id'];
 
         list($valid, $errors) = $this->taskValidator->validateCreation($values);
 
diff --git a/app/Template/action_creation/create.php b/app/Template/action_creation/create.php
index 862ee47460..a1169dca19 100644
--- a/app/Template/action_creation/create.php
+++ b/app/Template/action_creation/create.php
@@ -3,7 +3,6 @@
 </div>
 <form method="post" action="<?= $this->url->href('ActionCreationController', 'event', array('project_id' => $project['id'])) ?>">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('project_id', $values) ?>
 
     <?= $this->form->label(t('Action'), 'action_name') ?>
     <?= $this->form->select('action_name', $available_actions, $values) ?>
diff --git a/app/Template/action_creation/event.php b/app/Template/action_creation/event.php
index e41665483f..2ea72612a8 100644
--- a/app/Template/action_creation/event.php
+++ b/app/Template/action_creation/event.php
@@ -5,7 +5,6 @@
 <form method="post" action="<?= $this->url->href('ActionCreationController', 'params', array('project_id' => $project['id'])) ?>">
     <?= $this->form->csrf() ?>
 
-    <?= $this->form->hidden('project_id', $values) ?>
     <?= $this->form->hidden('action_name', $values) ?>
 
     <?= $this->form->label(t('Action'), 'action_name') ?>
diff --git a/app/Template/action_creation/params.php b/app/Template/action_creation/params.php
index 0cc98f501a..6c30d6c60a 100644
--- a/app/Template/action_creation/params.php
+++ b/app/Template/action_creation/params.php
@@ -5,7 +5,6 @@
 <form method="post" action="<?= $this->url->href('ActionCreationController', 'save', array('project_id' => $project['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
 
-    <?= $this->form->hidden('project_id', $values) ?>
     <?= $this->form->hidden('event_name', $values) ?>
     <?= $this->form->hidden('action_name', $values) ?>
 
diff --git a/app/Template/category/create.php b/app/Template/category/create.php
index b12ff7fa79..b32a770c8c 100644
--- a/app/Template/category/create.php
+++ b/app/Template/category/create.php
@@ -3,7 +3,6 @@
 </div>
 <form method="post" action="<?= $this->url->href('CategoryController', 'save', array('project_id' => $project['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('project_id', $values) ?>
 
     <?= $this->form->label(t('Category Name'), 'name') ?>
     <?= $this->form->text('name', $values, $errors, array('autofocus', 'required', 'maxlength="50"')) ?>
diff --git a/app/Template/category/edit.php b/app/Template/category/edit.php
index 108826f3bc..9ad5a9e998 100644
--- a/app/Template/category/edit.php
+++ b/app/Template/category/edit.php
@@ -5,9 +5,6 @@
 <form method="post" action="<?= $this->url->href('CategoryController', 'update', array('project_id' => $project['id'], 'category_id' => $values['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
 
-    <?= $this->form->hidden('id', $values) ?>
-    <?= $this->form->hidden('project_id', $values) ?>
-
     <?= $this->form->label(t('Category Name'), 'name') ?>
     <?= $this->form->text('name', $values, $errors, array('autofocus', 'required', 'maxlength="50"', 'tabindex="1"')) ?>
 
diff --git a/app/Template/column/create.php b/app/Template/column/create.php
index aad9606bd1..2b0c4641e1 100644
--- a/app/Template/column/create.php
+++ b/app/Template/column/create.php
@@ -4,8 +4,6 @@
 <form method="post" action="<?= $this->url->href('ColumnController', 'save', array('project_id' => $project['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
 
-    <?= $this->form->hidden('project_id', $values) ?>
-
     <?= $this->form->label(t('Title'), 'title') ?>
     <?= $this->form->text('title', $values, $errors, array('autofocus', 'required', 'maxlength="50"', 'tabindex="1"')) ?>
 
diff --git a/app/Template/column/edit.php b/app/Template/column/edit.php
index e590b5cc70..25cf60c9ce 100644
--- a/app/Template/column/edit.php
+++ b/app/Template/column/edit.php
@@ -5,9 +5,6 @@
 <form method="post" action="<?= $this->url->href('ColumnController', 'update', array('project_id' => $project['id'], 'column_id' => $column['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
 
-    <?= $this->form->hidden('id', $values) ?>
-    <?= $this->form->hidden('project_id', $values) ?>
-
     <?= $this->form->label(t('Title'), 'title') ?>
     <?= $this->form->text('title', $values, $errors, array('autofocus', 'required', 'maxlength="50"')) ?>
 
diff --git a/app/Template/custom_filter/create.php b/app/Template/custom_filter/create.php
index 24e896eef9..724cbc85aa 100644
--- a/app/Template/custom_filter/create.php
+++ b/app/Template/custom_filter/create.php
@@ -3,7 +3,6 @@
 </div>
 <form method="post" action="<?= $this->url->href('CustomFilterController', 'save', array('project_id' => $project['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('project_id', $values) ?>
 
     <?= $this->form->label(t('Name'), 'name') ?>
     <?= $this->form->text('name', $values, $errors, array('autofocus', 'required', 'maxlength="100"')) ?>
diff --git a/app/Template/custom_filter/edit.php b/app/Template/custom_filter/edit.php
index b64dee53b8..786e0c91d7 100644
--- a/app/Template/custom_filter/edit.php
+++ b/app/Template/custom_filter/edit.php
@@ -5,9 +5,7 @@
 <form method="post" action="<?= $this->url->href('CustomFilterController', 'update', array('project_id' => $filter['project_id'], 'filter_id' => $filter['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
 
-    <?= $this->form->hidden('id', $values) ?>
     <?= $this->form->hidden('user_id', $values) ?>
-    <?= $this->form->hidden('project_id', $values) ?>
 
     <?= $this->form->label(t('Name'), 'name') ?>
     <?= $this->form->text('name', $values, $errors, array('autofocus', 'required', 'maxlength="100"')) ?>
diff --git a/app/Template/project_edit/show.php b/app/Template/project_edit/show.php
index d4d0f8a64a..8b85f0105d 100644
--- a/app/Template/project_edit/show.php
+++ b/app/Template/project_edit/show.php
@@ -9,7 +9,6 @@
 <?php endif ?>
 <form method="post" action="<?= $this->url->href('ProjectEditController', 'update', array('project_id' => $project['id'], 'redirect' => 'edit')) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('id', $values) ?>
 
     <fieldset>
         <legend><?= t('General') ?></legend>
diff --git a/app/Template/project_tag/create.php b/app/Template/project_tag/create.php
index a0e6243b75..6765e8fc8b 100644
--- a/app/Template/project_tag/create.php
+++ b/app/Template/project_tag/create.php
@@ -3,7 +3,6 @@
 </div>
 <form method="post" action="<?= $this->url->href('ProjectTagController', 'save', array('project_id' => $project['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('project_id', $values) ?>
 
     <?= $this->form->label(t('Name'), 'name') ?>
     <?= $this->form->text('name', $values, $errors, array('autofocus', 'required', 'maxlength="255"')) ?>
diff --git a/app/Template/project_tag/edit.php b/app/Template/project_tag/edit.php
index 8cb1e20919..29290c0c9a 100644
--- a/app/Template/project_tag/edit.php
+++ b/app/Template/project_tag/edit.php
@@ -3,8 +3,6 @@
 </div>
 <form method="post" action="<?= $this->url->href('ProjectTagController', 'update', array('tag_id' => $tag['id'], 'project_id' => $project['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('id', $values) ?>
-    <?= $this->form->hidden('project_id', $values) ?>
 
     <?= $this->form->label(t('Name'), 'name') ?>
     <?= $this->form->text('name', $values, $errors, array('autofocus', 'required', 'maxlength="255"')) ?>
diff --git a/app/Template/swimlane/create.php b/app/Template/swimlane/create.php
index 7d05e731b1..5ff8cbeec9 100644
--- a/app/Template/swimlane/create.php
+++ b/app/Template/swimlane/create.php
@@ -2,9 +2,7 @@
     <h2><?= t('Add a new swimlane') ?></h2>
 </div>
 <form method="post" action="<?= $this->url->href('SwimlaneController', 'save', array('project_id' => $project['id'])) ?>" autocomplete="off">
-
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('project_id', $values) ?>
 
     <?= $this->form->label(t('Name'), 'name') ?>
     <?= $this->form->text('name', $values, $errors, array('autofocus', 'required', 'maxlength="50"', 'tabindex="1"')) ?>
diff --git a/app/Template/swimlane/edit.php b/app/Template/swimlane/edit.php
index c1c41196d7..b1d713ee55 100644
--- a/app/Template/swimlane/edit.php
+++ b/app/Template/swimlane/edit.php
@@ -3,12 +3,8 @@
 </div>
 
 <form method="post" action="<?= $this->url->href('SwimlaneController', 'update', array('project_id' => $project['id'], 'swimlane_id' => $values['id'])) ?>" autocomplete="off">
-
     <?= $this->form->csrf() ?>
 
-    <?= $this->form->hidden('id', $values) ?>
-    <?= $this->form->hidden('project_id', $values) ?>
-
     <?= $this->form->label(t('Name'), 'name') ?>
     <?= $this->form->text('name', $values, $errors, array('autofocus', 'required', 'maxlength="50"', 'tabindex="1"')) ?>
 
diff --git a/app/Template/task_creation/show.php b/app/Template/task_creation/show.php
index e957087f50..cc92779335 100644
--- a/app/Template/task_creation/show.php
+++ b/app/Template/task_creation/show.php
@@ -3,7 +3,6 @@
 </div>
 <form method="post" action="<?= $this->url->href('TaskCreationController', 'save', array('project_id' => $project['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('project_id', $values) ?>
 
     <div class="task-form-container">
         <div class="task-form-main-column">",
"url": "https://github.com/kanboard/kanboard/commit/074f6c104f3e49401ef0065540338fc2d4be79f0"
},
{
"commit_message": "[PATCH] Do not expose IDs in forms app/Controller/BaseController.php | 62 ++++++++++++++++--- app/Controller/CommentController.php | 43 +++---------- app/Controller/SubtaskController.php | 12 ++-- app/Controller/SubtaskConverterController.php | 5 +- .../SubtaskRestrictionController.php | 4 +- app/Controller/SubtaskStatusController.php | 10 +-- app/Controller/TaskExternalLinkController.php | 37 +++++------ app/Controller/TaskInternalLinkController.php | 34 +++------- app/Controller/TaskModificationController.php | 2 + app/Controller/TaskRecurrenceController.php | 1 + app/Template/comment/create.php | 2 - app/Template/comment/edit.php | 3 - app/Template/subtask/create.php | 3 +- app/Template/subtask/edit.php | 2 - app/Template/task_external_link/edit.php | 2 +- app/Template/task_external_link/find.php | 1 - app/Template/task_external_link/form.php | 2 - app/Template/task_internal_link/create.php | 1 - app/Template/task_internal_link/edit.php | 4 +- app/Template/task_modification/show.php | 2 - 20 files changed, 112 insertions(+), 120 deletions(-)",
"patch_text_b64": "From 3e0f14ae2b0b5a44bd038a472f17eac75f538524 Mon Sep 17 00:00:00 2001
From: Frederic Guillot <fred@kanboard.net>
Date: Sat, 23 Sep 2017 20:56:54 -0700
Subject: [PATCH] Do not expose IDs in forms

---
 app/Controller/BaseController.php             | 62 ++++++++++++++++---
 app/Controller/CommentController.php          | 43 +++----------
 app/Controller/SubtaskController.php          | 12 ++--
 app/Controller/SubtaskConverterController.php |  5 +-
 .../SubtaskRestrictionController.php          |  4 +-
 app/Controller/SubtaskStatusController.php    | 10 +--
 app/Controller/TaskExternalLinkController.php | 37 +++++------
 app/Controller/TaskInternalLinkController.php | 34 +++-------
 app/Controller/TaskModificationController.php |  2 +
 app/Controller/TaskRecurrenceController.php   |  1 +
 app/Template/comment/create.php               |  2 -
 app/Template/comment/edit.php                 |  3 -
 app/Template/subtask/create.php               |  3 +-
 app/Template/subtask/edit.php                 |  2 -
 app/Template/task_external_link/edit.php      |  2 +-
 app/Template/task_external_link/find.php      |  1 -
 app/Template/task_external_link/form.php      |  2 -
 app/Template/task_internal_link/create.php    |  1 -
 app/Template/task_internal_link/edit.php      |  4 +-
 app/Template/task_modification/show.php       |  2 -
 20 files changed, 112 insertions(+), 120 deletions(-)

diff --git a/app/Controller/BaseController.php b/app/Controller/BaseController.php
index 1ac7ed2038..41fcef1c37 100644
--- a/app/Controller/BaseController.php
+++ b/app/Controller/BaseController.php
@@ -138,14 +138,7 @@ protected function getUser()
         return $user;
     }
 
-    /**
-     * Get the current subtask
-     *
-     * @access protected
-     * @return array
-     * @throws PageNotFoundException
-     */
-    protected function getSubtask()
+    protected function getSubtask(array $task)
     {
         $subtask = $this->subtaskModel->getById($this->request->getIntegerParam('subtask_id'));
 
@@ -153,9 +146,62 @@ protected function getSubtask()
             throw new PageNotFoundException();
         }
 
+        if ($subtask['task_id'] != $task['id']) {
+            throw new AccessForbiddenException();
+        }
+
         return $subtask;
     }
 
+    protected function getComment(array $task)
+    {
+        $comment = $this->commentModel->getById($this->request->getIntegerParam('comment_id'));
+
+        if (empty($comment)) {
+            throw new PageNotFoundException();
+        }
+
+        if (! $this->userSession->isAdmin() && $comment['user_id'] != $this->userSession->getId()) {
+            throw new AccessForbiddenException();
+        }
+
+        if ($comment['task_id'] != $task['id']) {
+            throw new AccessForbiddenException();
+        }
+
+        return $comment;
+    }
+
+    protected function getExternalTaskLink(array $task)
+    {
+        $link = $this->taskExternalLinkModel->getById($this->request->getIntegerParam('link_id'));
+
+        if (empty($link)) {
+            throw new PageNotFoundException();
+        }
+
+        if ($link['task_id'] != $task['id']) {
+            throw new AccessForbiddenException();
+        }
+
+        return $link;
+    }
+
+    protected function getInternalTaskLink(array $task)
+    {
+        $link = $this->taskLinkModel->getById($this->request->getIntegerParam('link_id'));
+
+        if (empty($link)) {
+            throw new PageNotFoundException();
+        }
+
+        if ($link['task_id'] != $task['id']) {
+            throw new AccessForbiddenException();
+        }
+
+        return $link;
+    }
+
     protected function getColumn(array $project)
     {
         $column = $this->columnModel->getById($this->request->getIntegerParam('column_id'));
diff --git a/app/Controller/CommentController.php b/app/Controller/CommentController.php
index 9a89103eeb..a29491a31d 100644
--- a/app/Controller/CommentController.php
+++ b/app/Controller/CommentController.php
@@ -13,29 +13,6 @@
  */
 class CommentController extends BaseController
 {
-    /**
-     * Get the current comment
-     *
-     * @access protected
-     * @return array
-     * @throws PageNotFoundException
-     * @throws AccessForbiddenException
-     */
-    protected function getComment()
-    {
-        $comment = $this->commentModel->getById($this->request->getIntegerParam('comment_id'));
-
-        if (empty($comment)) {
-            throw new PageNotFoundException();
-        }
-
-        if (! $this->userSession->isAdmin() && $comment['user_id'] != $this->userSession->getId()) {
-            throw new AccessForbiddenException();
-        }
-
-        return $comment;
-    }
-
     /**
      * Add comment form
      *
@@ -49,14 +26,6 @@ public function create(array $values = array(), array $errors = array())
     {
         $project = $this->getProject();
         $task = $this->getTask();
-
-        if (empty($values)) {
-            $values = array(
-                'user_id' => $this->userSession->getId(),
-                'task_id' => $task['id'],
-            );
-        }
-
         $values['project_id'] = $task['project_id'];
 
         $this->response->html($this->helper->layout->task('comment/create', array(
@@ -106,7 +75,7 @@ public function save()
     public function edit(array $values = array(), array $errors = array())
     {
         $task = $this->getTask();
-        $comment = $this->getComment();
+        $comment = $this->getComment($task);
 
         if (empty($values)) {
             $values = $comment;
@@ -130,9 +99,13 @@ public function edit(array $values = array(), array $errors = array())
     public function update()
     {
         $task = $this->getTask();
-        $this->getComment();
+        $comment = $this->getComment($task);
 
         $values = $this->request->getValues();
+        $values['id'] = $comment['id'];
+        $values['task_id'] = $task['id'];
+        $values['user_id'] = $comment['user_id'];
+
         list($valid, $errors) = $this->commentValidator->validateModification($values);
 
         if ($valid) {
@@ -157,7 +130,7 @@ public function update()
     public function confirm()
     {
         $task = $this->getTask();
-        $comment = $this->getComment();
+        $comment = $this->getComment($task);
 
         $this->response->html($this->template->render('comment/remove', array(
             'comment' => $comment,
@@ -175,7 +148,7 @@ public function remove()
     {
         $this->checkCSRFParam();
         $task = $this->getTask();
-        $comment = $this->getComment();
+        $comment = $this->getComment($task);
 
         if ($this->commentModel->remove($comment['id'])) {
             $this->flash->success(t('Comment removed successfully.'));
diff --git a/app/Controller/SubtaskController.php b/app/Controller/SubtaskController.php
index 5fa55f6bcf..b9bb09342d 100644
--- a/app/Controller/SubtaskController.php
+++ b/app/Controller/SubtaskController.php
@@ -66,6 +66,7 @@ public function save()
     {
         $task = $this->getTask();
         $values = $this->request->getValues();
+        $values['task_id'] = $task['id'];
 
         list($valid, $errors) = $this->subtaskValidator->validateCreation($values);
 
@@ -103,7 +104,7 @@ public function save()
     public function edit(array $values = array(), array $errors = array())
     {
         $task = $this->getTask();
-        $subtask = $this->getSubtask();
+        $subtask = $this->getSubtask($task);
 
         $this->response->html($this->template->render('subtask/edit', array(
             'values' => empty($values) ? $subtask : $values,
@@ -123,9 +124,12 @@ public function edit(array $values = array(), array $errors = array())
     public function update()
     {
         $task = $this->getTask();
-        $this->getSubtask();
+        $subtask = $this->getSubtask($task);
 
         $values = $this->request->getValues();
+        $values['id'] = $subtask['id'];
+        $values['task_id'] = $task['id'];
+
         list($valid, $errors) = $this->subtaskValidator->validateModification($values);
 
         if ($valid) {
@@ -149,7 +153,7 @@ public function update()
     public function confirm()
     {
         $task = $this->getTask();
-        $subtask = $this->getSubtask();
+        $subtask = $this->getSubtask($task);
 
         $this->response->html($this->template->render('subtask/remove', array(
             'subtask' => $subtask,
@@ -166,7 +170,7 @@ public function remove()
     {
         $this->checkCSRFParam();
         $task = $this->getTask();
-        $subtask = $this->getSubtask();
+        $subtask = $this->getSubtask($task);
 
         if ($this->subtaskModel->remove($subtask['id'])) {
             $this->flash->success(t('Sub-task removed successfully.'));
diff --git a/app/Controller/SubtaskConverterController.php b/app/Controller/SubtaskConverterController.php
index 404c50d0e8..dafbb7e002 100644
--- a/app/Controller/SubtaskConverterController.php
+++ b/app/Controller/SubtaskConverterController.php
@@ -13,7 +13,7 @@ class SubtaskConverterController extends BaseController
     public function show()
     {
         $task = $this->getTask();
-        $subtask = $this->getSubtask();
+        $subtask = $this->getSubtask($task);
 
         $this->response->html($this->template->render('subtask_converter/show', array(
             'subtask' => $subtask,
@@ -24,7 +24,8 @@ public function show()
     public function save()
     {
         $project = $this->getProject();
-        $subtask = $this->getSubtask();
+        $task = $this->getTask();
+        $subtask = $this->getSubtask($task);
 
         $task_id = $this->subtaskTaskConversionModel->convertToTask($project['id'], $subtask['id']);
 
diff --git a/app/Controller/SubtaskRestrictionController.php b/app/Controller/SubtaskRestrictionController.php
index 99315931f2..315b023d1d 100644
--- a/app/Controller/SubtaskRestrictionController.php
+++ b/app/Controller/SubtaskRestrictionController.php
@@ -20,7 +20,7 @@ class SubtaskRestrictionController extends BaseController
     public function show()
     {
         $task = $this->getTask();
-        $subtask = $this->getSubtask();
+        $subtask = $this->getSubtask($task);
 
         $this->response->html($this->template->render('subtask_restriction/show', array(
             'status_list' => array(
@@ -41,7 +41,7 @@ public function show()
     public function save()
     {
         $task = $this->getTask();
-        $subtask = $this->getSubtask();
+        $subtask = $this->getSubtask($task);
         $values = $this->request->getValues();
 
         // Change status of the previous "in progress" subtask
diff --git a/app/Controller/SubtaskStatusController.php b/app/Controller/SubtaskStatusController.php
index ef16fce0ff..c912848e71 100644
--- a/app/Controller/SubtaskStatusController.php
+++ b/app/Controller/SubtaskStatusController.php
@@ -18,7 +18,7 @@ class SubtaskStatusController extends BaseController
     public function change()
     {
         $task = $this->getTask();
-        $subtask = $this->getSubtask();
+        $subtask = $this->getSubtask($task);
         $fragment = $this->request->getStringParam('fragment');
 
         $status = $this->subtaskStatusModel->toggleStatus($subtask['id']);
@@ -43,19 +43,19 @@ public function change()
     public function timer()
     {
         $task = $this->getTask();
-        $subtaskId = $this->request->getIntegerParam('subtask_id');
+        $subtask = $this->getSubtask($task);
         $timer = $this->request->getStringParam('timer');
 
         if ($timer === 'start') {
-            $this->subtaskTimeTrackingModel->logStartTime($subtaskId, $this->userSession->getId());
+            $this->subtaskTimeTrackingModel->logStartTime($subtask['id'], $this->userSession->getId());
         } elseif ($timer === 'stop') {
-            $this->subtaskTimeTrackingModel->logEndTime($subtaskId, $this->userSession->getId());
+            $this->subtaskTimeTrackingModel->logEndTime($subtask['id'], $this->userSession->getId());
             $this->subtaskTimeTrackingModel->updateTaskTimeTracking($task['id']);
         }
 
         $this->response->html($this->template->render('subtask/timer', array(
             'task'    => $task,
-            'subtask' => $this->subtaskModel->getByIdWithDetails($subtaskId),
+            'subtask' => $this->subtaskModel->getByIdWithDetails($subtask['id']),
         )));
     }
 
diff --git a/app/Controller/TaskExternalLinkController.php b/app/Controller/TaskExternalLinkController.php
index df23f87bb7..946451fcb7 100644
--- a/app/Controller/TaskExternalLinkController.php
+++ b/app/Controller/TaskExternalLinkController.php
@@ -74,6 +74,8 @@ public function save()
     {
         $task = $this->getTask();
         $values = $this->request->getValues();
+        $values['task_id'] = $task['id'];
+
         list($valid, $errors) = $this->externalLinkValidator->validateCreation($values);
 
         if ($valid) {
@@ -108,22 +110,14 @@ public function save()
     public function edit(array $values = array(), array $errors = array())
     {
         $task = $this->getTask();
-        $link_id = $this->request->getIntegerParam('link_id');
-
-        if ($link_id > 0) {
-            $values = $this->taskExternalLinkModel->getById($link_id);
-        }
-
-        if (empty($values)) {
-            throw new PageNotFoundException();
-        }
-
-        $provider = $this->externalLinkManager->getProvider($values['link_type']);
+        $link = $this->getExternalTaskLink($task);
+        $provider = $this->externalLinkManager->getProvider($link['link_type']);
 
         $this->response->html($this->template->render('task_external_link/edit', array(
-            'values' => $values,
-            'errors' => $errors,
-            'task' => $task,
+            'values'       => empty($values) ? $link : $values,
+            'errors'       => $errors,
+            'task'         => $task,
+            'link'         => $link,
             'dependencies' => $provider->getDependencies(),
         )));
     }
@@ -136,7 +130,12 @@ public function edit(array $values = array(), array $errors = array())
     public function update()
     {
         $task = $this->getTask();
+        $link = $this->getExternalTaskLink($task);
+
         $values = $this->request->getValues();
+        $values['id'] = $link['id'];
+        $values['task_id'] = $link['task_id'];
+
         list($valid, $errors) = $this->externalLinkValidator->validateModification($values);
 
         if ($valid && $this->taskExternalLinkModel->update($values)) {
@@ -155,12 +154,7 @@ public function update()
     public function confirm()
     {
         $task = $this->getTask();
-        $link_id = $this->request->getIntegerParam('link_id');
-        $link = $this->taskExternalLinkModel->getById($link_id);
-
-        if (empty($link)) {
-            throw new PageNotFoundException();
-        }
+        $link = $this->getExternalTaskLink($task);
 
         $this->response->html($this->template->render('task_external_link/remove', array(
             'link' => $link,
@@ -177,8 +171,9 @@ public function remove()
     {
         $this->checkCSRFParam();
         $task = $this->getTask();
+        $link = $this->getExternalTaskLink($task);
 
-        if ($this->taskExternalLinkModel->remove($this->request->getIntegerParam('link_id'))) {
+        if ($this->taskExternalLinkModel->remove($link['id'])) {
             $this->flash->success(t('Link removed successfully.'));
         } else {
             $this->flash->failure(t('Unable to remove this link.'));
diff --git a/app/Controller/TaskInternalLinkController.php b/app/Controller/TaskInternalLinkController.php
index 7c80016541..02cc15c4dd 100644
--- a/app/Controller/TaskInternalLinkController.php
+++ b/app/Controller/TaskInternalLinkController.php
@@ -13,24 +13,6 @@
  */
 class TaskInternalLinkController extends BaseController
 {
-    /**
-     * Get the current link
-     *
-     * @access private
-     * @return array
-     * @throws PageNotFoundException
-     */
-    private function getTaskLink()
-    {
-        $link = $this->taskLinkModel->getById($this->request->getIntegerParam('link_id'));
-
-        if (empty($link)) {
-            throw new PageNotFoundException();
-        }
-
-        return $link;
-    }
-
     /**
      * Creation form
      *
@@ -45,9 +27,7 @@ public function create(array $values = array(), array $errors = array())
         $task = $this->getTask();
 
         if (empty($values)) {
-          $values = array(
-              'another_tasklink' => $this->request->getIntegerParam('another_tasklink', 0)
-          );
+          $values['another_tasklink'] = $this->request->getIntegerParam('another_tasklink', 0);
           $values = $this->hook->merge('controller:tasklink:form:default', $values, array('default_values' => $values));
         }
 
@@ -68,6 +48,7 @@ public function save()
     {
         $task = $this->getTask();
         $values = $this->request->getValues();
+        $values['task_id'] = $task['id'];
 
         list($valid, $errors) = $this->taskLinkValidator->validateCreation($values);
 
@@ -106,7 +87,7 @@ public function save()
     public function edit(array $values = array(), array $errors = array())
     {
         $task = $this->getTask();
-        $task_link = $this->getTaskLink();
+        $task_link = $this->getInternalTaskLink($task);
 
         if (empty($values)) {
             $opposite_task = $this->taskFinderModel->getById($task_link['opposite_task_id']);
@@ -131,7 +112,11 @@ public function edit(array $values = array(), array $errors = array())
     public function update()
     {
         $task = $this->getTask();
+        $task_link = $this->getInternalTaskLink($task);
+
         $values = $this->request->getValues();
+        $values['task_id'] = $task['id'];
+        $values['id'] = $task_link['id'];
 
         list($valid, $errors) = $this->taskLinkValidator->validateModification($values);
 
@@ -155,7 +140,7 @@ public function update()
     public function confirm()
     {
         $task = $this->getTask();
-        $link = $this->getTaskLink();
+        $link = $this->getInternalTaskLink($task);
 
         $this->response->html($this->template->render('task_internal_link/remove', array(
             'link' => $link,
@@ -172,8 +157,9 @@ public function remove()
     {
         $this->checkCSRFParam();
         $task = $this->getTask();
+        $link = $this->getInternalTaskLink($task);
 
-        if ($this->taskLinkModel->remove($this->request->getIntegerParam('link_id'))) {
+        if ($this->taskLinkModel->remove($link['id'])) {
             $this->flash->success(t('Link removed successfully.'));
         } else {
             $this->flash->failure(t('Unable to remove this link.'));
diff --git a/app/Controller/TaskModificationController.php b/app/Controller/TaskModificationController.php
index 1892a20982..338ed54014 100644
--- a/app/Controller/TaskModificationController.php
+++ b/app/Controller/TaskModificationController.php
@@ -98,6 +98,8 @@ public function update()
     {
         $task = $this->getTask();
         $values = $this->request->getValues();
+        $values['id'] = $task['id'];
+        $values['project_id'] = $task['project_id'];
 
         list($valid, $errors) = $this->taskValidator->validateModification($values);
 
diff --git a/app/Controller/TaskRecurrenceController.php b/app/Controller/TaskRecurrenceController.php
index c6fdfa3781..7f14cb5344 100644
--- a/app/Controller/TaskRecurrenceController.php
+++ b/app/Controller/TaskRecurrenceController.php
@@ -47,6 +47,7 @@ public function update()
     {
         $task = $this->getTask();
         $values = $this->request->getValues();
+        $values['id'] = $task['id'];
 
         list($valid, $errors) = $this->taskValidator->validateEditRecurrence($values);
 
diff --git a/app/Template/comment/create.php b/app/Template/comment/create.php
index 0e19ac1964..55e972dc07 100644
--- a/app/Template/comment/create.php
+++ b/app/Template/comment/create.php
@@ -8,8 +8,6 @@
 </div>
 <form method="post" action="<?= $this->url->href('CommentController', 'save', array('task_id' => $task['id'], 'project_id' => $task['project_id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('task_id', $values) ?>
-    <?= $this->form->hidden('user_id', $values) ?>
 
     <?= $this->form->textEditor('comment', $values, $errors, array('autofocus' => true, 'required' => true)) ?>
 
diff --git a/app/Template/comment/edit.php b/app/Template/comment/edit.php
index 04f6ffd477..db8d2921fc 100644
--- a/app/Template/comment/edit.php
+++ b/app/Template/comment/edit.php
@@ -4,9 +4,6 @@
 
 <form method="post" action="<?= $this->url->href('CommentController', 'update', array('task_id' => $task['id'], 'project_id' => $task['project_id'], 'comment_id' => $comment['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('id', $values) ?>
-    <?= $this->form->hidden('task_id', $values) ?>
-    <?= $this->form->hidden('user_id', $values) ?>
 
     <?= $this->form->textEditor('comment', $values, $errors, array('autofocus' => true, 'required' => true)) ?>
 
diff --git a/app/Template/subtask/create.php b/app/Template/subtask/create.php
index 96ad7a468d..bbb6400538 100644
--- a/app/Template/subtask/create.php
+++ b/app/Template/subtask/create.php
@@ -3,9 +3,8 @@
 </div>
 
 <form method="post" action="<?= $this->url->href('SubtaskController', 'save', array('task_id' => $task['id'], 'project_id' => $task['project_id'])) ?>" autocomplete="off">
-
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('task_id', $values) ?>
+
     <?= $this->subtask->renderTitleField($values, $errors, array('autofocus')) ?>
     <?= $this->subtask->renderAssigneeField($users_list, $values, $errors) ?>
     <?= $this->subtask->renderTimeEstimatedField($values, $errors) ?>
diff --git a/app/Template/subtask/edit.php b/app/Template/subtask/edit.php
index 7c0266a8e7..aed57e957f 100644
--- a/app/Template/subtask/edit.php
+++ b/app/Template/subtask/edit.php
@@ -4,8 +4,6 @@
 
 <form method="post" action="<?= $this->url->href('SubtaskController', 'update', array('task_id' => $task['id'], 'project_id' => $task['project_id'], 'subtask_id' => $subtask['id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('id', $values) ?>
-    <?= $this->form->hidden('task_id', $values) ?>
 
     <?= $this->subtask->renderTitleField($values, $errors, array('autofocus')) ?>
     <?= $this->subtask->renderAssigneeField($users_list, $values, $errors) ?>
diff --git a/app/Template/task_external_link/edit.php b/app/Template/task_external_link/edit.php
index df10d444fa..e448b10f3f 100644
--- a/app/Template/task_external_link/edit.php
+++ b/app/Template/task_external_link/edit.php
@@ -2,7 +2,7 @@
     <h2><?= t('Edit external link') ?></h2>
 </div>
 
-<form action="<?= $this->url->href('TaskExternalLinkController', 'update', array('task_id' => $task['id'], 'project_id' => $task['project_id'])) ?>" method="post" autocomplete="off">
+<form action="<?= $this->url->href('TaskExternalLinkController', 'update', array('task_id' => $task['id'], 'project_id' => $task['project_id'], 'link_id' => $link['id'])) ?>" method="post" autocomplete="off">
     <?= $this->render('task_external_link/form', array('task' => $task, 'dependencies' => $dependencies, 'values' => $values, 'errors' => $errors)) ?>
     <?= $this->modal->submitButtons() ?>
 </form>
diff --git a/app/Template/task_external_link/find.php b/app/Template/task_external_link/find.php
index a3665c0d08..29d85101ef 100644
--- a/app/Template/task_external_link/find.php
+++ b/app/Template/task_external_link/find.php
@@ -4,7 +4,6 @@
 
 <form action="<?= $this->url->href('TaskExternalLinkController', 'create', array('task_id' => $task['id'], 'project_id' => $task['project_id'])) ?>" method="post" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('task_id', array('task_id' => $task['id'])) ?>
 
     <?= $this->form->label(t('External link'), 'text') ?>
     <?= $this->form->text(
diff --git a/app/Template/task_external_link/form.php b/app/Template/task_external_link/form.php
index 932ca52178..4ad2b2e0f3 100644
--- a/app/Template/task_external_link/form.php
+++ b/app/Template/task_external_link/form.php
@@ -1,6 +1,4 @@
 <?= $this->form->csrf() ?>
-<?= $this->form->hidden('task_id', array('task_id' => $task['id'])) ?>
-<?= $this->form->hidden('id', $values) ?>
 <?= $this->form->hidden('link_type', $values) ?>
 
 <?= $this->form->label(t('URL'), 'url') ?>
diff --git a/app/Template/task_internal_link/create.php b/app/Template/task_internal_link/create.php
index c5e80f414b..bab4125378 100644
--- a/app/Template/task_internal_link/create.php
+++ b/app/Template/task_internal_link/create.php
@@ -5,7 +5,6 @@
 <form action="<?= $this->url->href('TaskInternalLinkController', 'save', array('task_id' => $task['id'], 'project_id' => $task['project_id'])) ?>" method="post" autocomplete="off">
 
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('task_id', array('task_id' => $task['id'])) ?>
     <?= $this->form->hidden('opposite_task_id', $values) ?>
 
     <?= $this->form->label(t('Label'), 'link_id') ?>
diff --git a/app/Template/task_internal_link/edit.php b/app/Template/task_internal_link/edit.php
index 5abf7b65e3..fab84d0b67 100644
--- a/app/Template/task_internal_link/edit.php
+++ b/app/Template/task_internal_link/edit.php
@@ -3,10 +3,8 @@
 </div>
 
 <form action="<?= $this->url->href('TaskInternalLinkController', 'update', array('task_id' => $task['id'], 'project_id' => $task['project_id'], 'link_id' => $task_link['id'])) ?>" method="post" autocomplete="off">
-
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('id', $values) ?>
-    <?= $this->form->hidden('task_id', $values) ?>
+
     <?= $this->form->hidden('opposite_task_id', $values) ?>
 
     <?= $this->form->label(t('Label'), 'link_id') ?>
diff --git a/app/Template/task_modification/show.php b/app/Template/task_modification/show.php
index 710abedff2..ebe9f6fd6c 100644
--- a/app/Template/task_modification/show.php
+++ b/app/Template/task_modification/show.php
@@ -3,8 +3,6 @@
 </div>
 <form method="post" action="<?= $this->url->href('TaskModificationController', 'update', array('task_id' => $task['id'], 'project_id' => $task['project_id'])) ?>" autocomplete="off">
     <?= $this->form->csrf() ?>
-    <?= $this->form->hidden('id', $values) ?>
-    <?= $this->form->hidden('project_id', $values) ?>
 
     <div class="task-form-container">
         <div class="task-form-main-column">",
"url": "https://github.com/kanboard/kanboard/commit/3e0f14ae2b0b5a44bd038a472f17eac75f538524"
}
] |
n/a
|
|
CVE-2023-4226
|
Chamilo LMS File Upload Functionality Remote Code Execution
|
Unrestricted file upload in `/main/inc/ajax/work.ajax.php` in Chamilo LMS <= v1.11.24 allows authenticated attackers with learner role to obtain remote code execution via uploading of PHP files.
|
[
{
"commit_message": "[PATCH] System: Security: Add header rule to avoid MIME-sniffing .htaccess | 4 ++++ 1 file changed, 4 insertions(+)",
"patch_text_b64": "RnJvbSA2ZjMyNjI1YTAxMmQ1ZGUyZGZlOGVkYmNjYjRlZDE0YTg1ZTMxMGQ0IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmdlbCBGZXJuYW5kbyBRdWlyb3ogQ2FtcG9zIDxhbmdlbGZxYy4xOEBnbWFpbC5jb20+CkRhdGU6IFR1ZSwgNSBTZXAgMjAyMyAxMzo0MjoxNiAtMDUwMApTdWJqZWN0OiBbUEFUQ0hdIFN5c3RlbTogU2VjdXJpdHk6IEFkZCBoZWFkZXIgcnVsZSB0byBhdm9pZCBNSU1FLXNuaWZmaW5nCgotLS0KIC5odGFjY2VzcyB8IDQgKysrKwogMSBmaWxlIGNoYW5nZWQsIDQgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhLy5odGFjY2VzcyBiLy5odGFjY2VzcwppbmRleCBjMTA0NDBhOGE1MS4uZDUwNzhiYWI2MGQgMTAwNzU1Ci0tLSBhLy5odGFjY2VzcworKysgYi8uaHRhY2Nlc3MKQEAgLTExMywzICsxMTMsNyBAQCBBZGRUeXBlIGFwcGxpY2F0aW9uL2ZvbnQtd29mZiAud29mZiAud29mZjIKICM8SWZNb2R1bGUgbW9kX2hlYWRlcnMuYz4KICMgIEhlYWRlciBhbHdheXMgc2V0IENvbnRlbnQtU2VjdXJpdHktUG9saWN5ICJ1cGdyYWRlLWluc2VjdXJlLXJlcXVlc3RzOyIKICM8L0lmTW9kdWxlPgorCis8SWZNb2R1bGUgbW9kX2hlYWRlcnMuYz4KKyAgSGVhZGVyIGFsd2F5cyBzZXQgWC1Db250ZW50LVR5cGUtT3B0aW9ucyBub3NuaWZmCis8L0lmTW9kdWxlPg==",
"url": "https://github.com/chamilo/chamilo-lms/commit/6f32625a012d5de2dfe8edbccb4ed14a85e310d4"
},
{
"commit_message": "[PATCH] Security: Sanitize file name when uploading chunks with bigUpload (2) main/inc/ajax/dropbox.ajax.php | 7 +++++-- main/inc/ajax/exercise.ajax.php | 7 +++++-- main/inc/ajax/work.ajax.php | 7 +++++-- 3 files changed, 15 insertions(+), 6 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/chamilo/chamilo-lms/commit/f3d62b65ad60d68096c2674d5695339f04de0b8a"
},
{
"commit_message": "[PATCH] Security: Add redirect to .htaccess to avoid direct access to bigupload temporary upload directory .htaccess | 4 ++++ 1 file changed, 4 insertions(+)",
"patch_text_b64": "RnJvbSBlODY0MTI3YTQ0MGMyY2FiMGViNjJjMTEzYTA0ZTJlOTA0NTQzYTFmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBZYW5uaWNrIFdhcm5pZXIgPHl3YXJuaWVyQGJlZXpuZXN0Lm9yZz4KRGF0ZTogVGh1LCAyMSBTZXAgMjAyMyAxNDo0Nzo1NCArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIFNlY3VyaXR5OiBBZGQgcmVkaXJlY3QgdG8gLmh0YWNjZXNzIHRvIGF2b2lkIGRpcmVjdCBhY2Nlc3MgdG8KIGJpZ3VwbG9hZCB0ZW1wb3JhcnkgdXBsb2FkIGRpcmVjdG9yeQoKLS0tCiAuaHRhY2Nlc3MgfCA0ICsrKysKIDEgZmlsZSBjaGFuZ2VkLCA0IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS8uaHRhY2Nlc3MgYi8uaHRhY2Nlc3MKaW5kZXggY2E0NjFjNDg5ZTAuLmY3ZjEzM2VjNDkzIDEwMDc1NQotLS0gYS8uaHRhY2Nlc3MKKysrIGIvLmh0YWNjZXNzCkBAIC0xMTcsNiArMTE3LDEwIEBAIEFkZFR5cGUgYXBwbGljYXRpb24vZm9udC13b2ZmIC53b2ZmIC53b2ZmMgogIyAgSGVhZGVyIGFsd2F5cyBzZXQgQ29udGVudC1TZWN1cml0eS1Qb2xpY3kgInVwZ3JhZGUtaW5zZWN1cmUtcmVxdWVzdHM7IgogIzwvSWZNb2R1bGU+CiAKKyMgRGlzYWxsb3cgZGlyZWN0IGFjY2VzcyB0byAvbWFpbi9pbmMvbGliL2phdmFzY3JpcHQvYmlndXBsb2FkL2ZpbGVzCitSZWRpcmVjdE1hdGNoIDQwMyBeL21haW4vaW5jL2xpYi9qYXZhc2NyaXB0L2JpZ3VwbG9hZC9maWxlcworCisjIERpc2FsbG93IE1JTUUgc25pZmZpbmcgdG8gcHJldmVudCBYU1MgZnJvbSB1bmtub3duL2luY29ycmVjdCBmaWxlIGV4dGVuc2lvbnMKIDxJZk1vZHVsZSBtb2RfaGVhZGVycy5jPgogICBIZWFkZXIgYWx3YXlzIHNldCBYLUNvbnRlbnQtVHlwZS1PcHRpb25zIG5vc25pZmYKIDwvSWZNb2R1bGU+",
"url": "https://github.com/chamilo/chamilo-lms/commit/e864127a440c2cab0eb62c113a04e2e904543a1f"
}
] |
CWE-434 Unrestricted Upload of File with Dangerous Type
|
CVE-2017-13014
|
The White Board protocol parser in tcpdump before 4.9.2 has a buffer over-read in print-wb.c:wb_prep(), several functions.
|
[
{
"commit_message": "[PATCH] CVE-2017-13014/White Board: Do more bounds checks. This fixes a buffer over-read discovered by Yannick Formaggio. Add a test using the capture file supplied by the reporter(s). While we're at it, print a truncation error if the packets are truncated, rather than just, in effect, ignoring the result of the routines that print particular packet types. print-wb.c | 9 +++++++-- tests/TESTLIST | 1 + tests/wb-oobr.out | 18 ++++++++++++++++++ tests/wb-oobr.pcap | Bin 0 -> 396 bytes 4 files changed, 26 insertions(+), 2 deletions(-) create mode 100644 tests/wb-oobr.out create mode 100644 tests/wb-oobr.pcap",
"patch_text_b64": "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",
"url": "https://github.com/the-tcpdump-group/tcpdump/commit/cc356512f512e7fa423b3674db4bb31dbe40ffec"
}
] |
n/a
|
|
CVE-2025-48964
|
ping in iputils before 20250602 allows a denial of service (application error in adaptive ping mode or incorrect data collection) via a crafted ICMP Echo Reply packet, because a zero timestamp can lead to large intermediate values that have an integer overflow when squared during statistics calculations. NOTE: this issue exists because of an incomplete fix for CVE-2025-47268 (that fix was only about timestamp calculations, and it did not account for a specific scenario where the original timestamp in the ICMP payload is zero).
|
[
{
"commit_message": "[PATCH] ping: Fix moving average rtt calculation The rts->rtt counts an exponential weight moving average in a fixed point, that means that even if we limit the triptime to fit into a 32bit number the average will overflow because because fixed point needs eight more bits. We also have to limit the triptime to 32bit number because otherwise the moving average may stil overflow if we manage to produce a large enough triptime. Fixes: CVE-2025-48964 Fixes: https://bugzilla.suse.com/show_bug.cgi?id=1243772 Closes: https://github.com/iputils/iputils-ghsa-25fr-jw29-74f9/pull/1 Reported-by: Mohamed Maatallah <[email protected]> Reviewed-by: Petr Vorel <[email protected]> Tested-by: Petr Vorel <[email protected]> Reviewed-by: Michal Kubecek <[email protected]> Reviewed-by: Mohamed Maatallah <[email protected]> Signed-off-by: Cyril Hrubis <[email protected]> iputils_common.h | 2 +- ping/ping.h | 2 +- ping/ping_common.c | 8 ++++---- 3 files changed, 6 insertions(+), 6 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/iputils/iputils/commit/afa36390394a6e0cceba03b52b59b6d41710608c"
}
] |
CWE-190 Integer Overflow or Wraparound
|
|
CVE-2019-15161
|
rpcapd/daemon.c in libpcap before 1.9.1 mishandles certain length values because of reuse of a variable. This may open up an attack vector involving extra data at the end of a request.
|
[
{
"commit_message": "[PATCH] Calculate the reply payload length in a local variable. Using the same variable for the remaining request length and the reply length is confusing at best and can cause errors at worst (if the request had extra stuff at the end, so that the variable is non-zero). This addresses Include Security issue I8: [libpcap] Remote Packet Capture Daemon Parameter Reuse. rpcapd/daemon.c | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/the-tcpdump-group/libpcap/commit/617b12c0339db4891d117b661982126c495439ea"
}
] |
n/a
|
|
CVE-2017-16820
|
The csnmp_read_table function in snmp.c in the SNMP plugin in collectd before 5.6.3 is susceptible to a double free in a certain error case, which could lead to a crash (or potentially have other impact).
|
[
{
"commit_message": "[PATCH] snmp plugin: Fix double free of request PDU snmp_sess_synch_response() always frees request PDU, in both case of request error and success. If error condition occurs inside of `while (status == 0)` loop, double free of `req` happens. Issue: #2291 Signed-off-by: Florian Forster <[email protected]> src/snmp.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/collectd/collectd/commit/d16c24542b2f96a194d43a73c2e5778822b9cb47"
}
] |
n/a
|
|
CVE-2015-10103
|
InternalError503 Forget It settings.js infinite loop
|
A vulnerability, which was classified as problematic, was found in InternalError503 Forget It up to 1.3. This affects an unknown part of the file js/settings.js. The manipulation of the argument setForgetTime with the input 0 leads to infinite loop. It is possible to launch the attack on the local host. Upgrading to version 1.4 is able to address this issue. The patch is named adf0c7fd59b9c935b4fd675c556265620124999c. It is recommended to upgrade the affected component. The associated identifier of this vulnerability is VDB-226119.
|
[
{
"commit_message": "[PATCH] Fixed: denial of service loop if setForgetTime set to 0. A small issue with setForgetTime input field would allow users to manually enter 0 value in the input and save it causing the timed forget loop to rapidly refresh causing a denial of service. js/settings.js | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/InternalError503/forget-it/commit/adf0c7fd59b9c935b4fd675c556265620124999c"
}
] |
CWE-835 Infinite Loop
|
CVE-2024-23334
|
aiohttp.web.static(follow_symlinks=True) is vulnerable to directory traversal
|
aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. When using aiohttp as a web server and configuring static routes, it is necessary to specify the root path for static files. Additionally, the option 'follow_symlinks' can be used to determine whether to follow symbolic links outside the static root directory. When 'follow_symlinks' is set to True, there is no validation to check if reading a file is within the root directory. This can lead to directory traversal vulnerabilities, resulting in unauthorized access to arbitrary files on the system, even when symlinks are not present. Disabling follow_symlinks and using a reverse proxy are encouraged mitigations. Version 3.9.2 fixes this issue.
|
[
{
"commit_message": "[PATCH] Validate static paths (#8079) Co-authored-by: J. Nick Koston <[email protected]> CHANGES/8079.bugfix.rst | 1 + aiohttp/web_urldispatcher.py | 18 +++++-- docs/web_advanced.rst | 16 ++++-- docs/web_reference.rst | 12 +++-- tests/test_web_urldispatcher.py | 91 +++++++++++++++++++++++++++++++++ 5 files changed, 128 insertions(+), 10 deletions(-) create mode 100644 CHANGES/8079.bugfix.rst",
"patch_text_b64": "From 1c335944d6a8b1298baf179b7c0b3069f10c514b Mon Sep 17 00:00:00 2001
From: Sam Bull <git@sambull.org>
Date: Sun, 28 Jan 2024 18:13:06 +0000
Subject: [PATCH] Validate static paths (#8079)

Co-authored-by: J. Nick Koston <nick@koston.org>
---
 CHANGES/8079.bugfix.rst         |  1 +
 aiohttp/web_urldispatcher.py    | 18 +++++--
 docs/web_advanced.rst           | 16 ++++--
 docs/web_reference.rst          | 12 +++--
 tests/test_web_urldispatcher.py | 91 +++++++++++++++++++++++++++++++++
 5 files changed, 128 insertions(+), 10 deletions(-)
 create mode 100644 CHANGES/8079.bugfix.rst

diff --git a/CHANGES/8079.bugfix.rst b/CHANGES/8079.bugfix.rst
new file mode 100644
index 00000000000..57bc8bfebcc
--- /dev/null
+++ b/CHANGES/8079.bugfix.rst
@@ -0,0 +1 @@
+Improved validation of paths for static resources -- by :user:`bdraco`.
diff --git a/aiohttp/web_urldispatcher.py b/aiohttp/web_urldispatcher.py
index fee4f61a1aa..a05ac6cc3de 100644
--- a/aiohttp/web_urldispatcher.py
+++ b/aiohttp/web_urldispatcher.py
@@ -573,9 +573,14 @@ def url_for(  # type: ignore[override]
             url = url / filename
 
         if append_version:
+            unresolved_path = self._directory.joinpath(filename)
             try:
-                filepath = self._directory.joinpath(filename).resolve()
-                if not self._follow_symlinks:
+                if self._follow_symlinks:
+                    normalized_path = Path(os.path.normpath(unresolved_path))
+                    normalized_path.relative_to(self._directory)
+                    filepath = normalized_path.resolve()
+                else:
+                    filepath = unresolved_path.resolve()
                     filepath.relative_to(self._directory)
             except (ValueError, FileNotFoundError):
                 # ValueError for case when path point to symlink
@@ -640,8 +645,13 @@ async def _handle(self, request: Request) -> StreamResponse:
                 # /static/\\machine_name\c$ or /static/D:\path
                 # where the static dir is totally different
                 raise HTTPForbidden()
-            filepath = self._directory.joinpath(filename).resolve()
-            if not self._follow_symlinks:
+            unresolved_path = self._directory.joinpath(filename)
+            if self._follow_symlinks:
+                normalized_path = Path(os.path.normpath(unresolved_path))
+                normalized_path.relative_to(self._directory)
+                filepath = normalized_path.resolve()
+            else:
+                filepath = unresolved_path.resolve()
                 filepath.relative_to(self._directory)
         except (ValueError, FileNotFoundError) as error:
             # relatively safe
diff --git a/docs/web_advanced.rst b/docs/web_advanced.rst
index 6b1ad199758..5ba3cd33442 100644
--- a/docs/web_advanced.rst
+++ b/docs/web_advanced.rst
@@ -262,12 +262,22 @@ instead could be enabled with ``show_index`` parameter set to ``True``::
 
    web.static('/prefix', path_to_static_folder, show_index=True)
 
-When a symlink from the static directory is accessed, the server responses to
-client with ``HTTP/404 Not Found`` by default. To allow the server to follow
-symlinks, parameter ``follow_symlinks`` should be set to ``True``::
+When a symlink that leads outside the static directory is accessed, the server
+responds to the client with ``HTTP/404 Not Found`` by default. To allow the server to
+follow symlinks that lead outside the static root, the parameter ``follow_symlinks``
+should be set to ``True``::
 
    web.static('/prefix', path_to_static_folder, follow_symlinks=True)
 
+.. caution::
+
+   Enabling ``follow_symlinks`` can be a security risk, and may lead to
+   a directory transversal attack. You do NOT need this option to follow symlinks
+   which point to somewhere else within the static directory, this option is only
+   used to break out of the security sandbox. Enabling this option is highly
+   discouraged, and only expected to be used for edge cases in a local
+   development setting where remote users do not have access to the server.
+
 When you want to enable cache busting,
 parameter ``append_version`` can be set to ``True``
 
diff --git a/docs/web_reference.rst b/docs/web_reference.rst
index 60dc723c405..127d075cad7 100644
--- a/docs/web_reference.rst
+++ b/docs/web_reference.rst
@@ -1784,9 +1784,15 @@ Application and Router
                               by default it's not allowed and HTTP/403 will
                               be returned on directory access.
 
-      :param bool follow_symlinks: flag for allowing to follow symlinks from
-                              a directory, by default it's not allowed and
-                              HTTP/404 will be returned on access.
+      :param bool follow_symlinks: flag for allowing to follow symlinks that lead
+                              outside the static root directory, by default it's not allowed and
+                              HTTP/404 will be returned on access.  Enabling ``follow_symlinks``
+                              can be a security risk, and may lead to a directory transversal attack.
+                              You do NOT need this option to follow symlinks which point to somewhere
+                              else within the static directory, this option is only used to break out
+                              of the security sandbox. Enabling this option is highly discouraged,
+                              and only expected to be used for edge cases in a local development
+                              setting where remote users do not have access to the server.
 
       :param bool append_version: flag for adding file version (hash)
                               to the url query string, this value will
diff --git a/tests/test_web_urldispatcher.py b/tests/test_web_urldispatcher.py
index 716fa78fd4a..c3caa4ffcff 100644
--- a/tests/test_web_urldispatcher.py
+++ b/tests/test_web_urldispatcher.py
@@ -108,6 +108,97 @@ async def test_follow_symlink(
     assert (await r.text()) == data
 
 
+async def test_follow_symlink_directory_traversal(
+    tmp_path: pathlib.Path, aiohttp_client: AiohttpClient
+) -> None:
+    # Tests that follow_symlinks does not allow directory transversal
+    data = "private"
+
+    private_file = tmp_path / "private_file"
+    private_file.write_text(data)
+
+    safe_path = tmp_path / "safe_dir"
+    safe_path.mkdir()
+
+    app = web.Application()
+
+    # Register global static route:
+    app.router.add_static("/", str(safe_path), follow_symlinks=True)
+    client = await aiohttp_client(app)
+
+    await client.start_server()
+    # We need to use a raw socket to test this, as the client will normalize
+    # the path before sending it to the server.
+    reader, writer = await asyncio.open_connection(client.host, client.port)
+    writer.write(b"GET /../private_file HTTP/1.1\r\n\r\n")
+    response = await reader.readuntil(b"\r\n\r\n")
+    assert b"404 Not Found" in response
+    writer.close()
+    await writer.wait_closed()
+    await client.close()
+
+
+async def test_follow_symlink_directory_traversal_after_normalization(
+    tmp_path: pathlib.Path, aiohttp_client: AiohttpClient
+) -> None:
+    # Tests that follow_symlinks does not allow directory transversal
+    # after normalization
+    #
+    # Directory structure
+    # |-- secret_dir
+    # |   |-- private_file (should never be accessible)
+    # |   |-- symlink_target_dir
+    # |       |-- symlink_target_file (should be accessible via the my_symlink symlink)
+    # |       |-- sandbox_dir
+    # |           |-- my_symlink -> symlink_target_dir
+    #
+    secret_path = tmp_path / "secret_dir"
+    secret_path.mkdir()
+
+    # This file is below the symlink target and should not be reachable
+    private_file = secret_path / "private_file"
+    private_file.write_text("private")
+
+    symlink_target_path = secret_path / "symlink_target_dir"
+    symlink_target_path.mkdir()
+
+    sandbox_path = symlink_target_path / "sandbox_dir"
+    sandbox_path.mkdir()
+
+    # This file should be reachable via the symlink
+    symlink_target_file = symlink_target_path / "symlink_target_file"
+    symlink_target_file.write_text("readable")
+
+    my_symlink_path = sandbox_path / "my_symlink"
+    pathlib.Path(str(my_symlink_path)).symlink_to(str(symlink_target_path), True)
+
+    app = web.Application()
+
+    # Register global static route:
+    app.router.add_static("/", str(sandbox_path), follow_symlinks=True)
+    client = await aiohttp_client(app)
+
+    await client.start_server()
+    # We need to use a raw socket to test this, as the client will normalize
+    # the path before sending it to the server.
+    reader, writer = await asyncio.open_connection(client.host, client.port)
+    writer.write(b"GET /my_symlink/../private_file HTTP/1.1\r\n\r\n")
+    response = await reader.readuntil(b"\r\n\r\n")
+    assert b"404 Not Found" in response
+    writer.close()
+    await writer.wait_closed()
+
+    reader, writer = await asyncio.open_connection(client.host, client.port)
+    writer.write(b"GET /my_symlink/symlink_target_file HTTP/1.1\r\n\r\n")
+    response = await reader.readuntil(b"\r\n\r\n")
+    assert b"200 OK" in response
+    response = await reader.readuntil(b"readable")
+    assert response == b"readable"
+    writer.close()
+    await writer.wait_closed()
+    await client.close()
+
+
 @pytest.mark.parametrize(
     "dir_name,filename,data",
     [",
"url": "https://github.com/aio-libs/aiohttp/commit/1c335944d6a8b1298baf179b7c0b3069f10c514b"
}
] |
CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
|
End of preview. Expand
in Data Studio
Description
This dataset, CIRCL/vulnerability-cwe-patch, provides structured real-world vulnerabilities enriched with CWE identifiers and actual patches from platforms like GitHub and GitLab. It was built to support the development of tools for vulnerability classification, triage, and automated repair. Each entry includes metadata such as CVE/GHSA ID, a description, CWE categorization, and links to verified patch commits with associated diff content and commit messages.
The dataset is automatically extracted using a pipeline that fetches vulnerability records from several sources, filters out entries without patches, and verifies patch links for accessibility. Extracted patches are fetched, encoded in base64, and stored alongside commit messages for training and evaluation of ML models. Source Data
The dataset comprises 15,836 vulnerabilities and 18,435 associated patches. For training, we consider only those patches corresponding to vulnerabilities annotated with at least one CWE.
How to use with datasets
>>> import json
>>> from datasets import load_dataset
>>> dataset = load_dataset("CIRCL/vulnerability-cwe-patch")
>>> vulnerabilities = ["CVE-2025-60249", "CVE-2025-32413"]
>>> filtered_entries = dataset.filter(lambda elem: elem["id"] in vulnerabilities)
>>> for entry in filtered_entries["train"]:
... print(entry["cwe"])
... for patch in entry["patches"]:
... print(f" {patch['commit_message']}")
...
CWE-79 Improper Neutralization of Input During Web Page Generation (XSS or 'Cross-site Scripting')
[PATCH] fix: [security] Fixed a stored XSS vulnerability in user bios. Thanks to Dawid Czarnecki for reporting the issue.
CWE-79 Improper Neutralization of Input During Web Page Generation (XSS or 'Cross-site Scripting')
[PATCH] fix: [security] sanitize user input in comments, bundles, and sightings - Escaped untrusted data in templates and tables to prevent XSS - Replaced unsafe innerHTML assignments with createElement/textContent - Encoded dynamic URLs using encodeURIComponent - Improved validation in Comment, Bundle, and Sighting models Credit: @Wachizungu
Schema
Each example contains:
- id: Vulnerability identifier (e.g., CVE-2023-XXXX, GHSA-XXXX)
- title: Human-readable title of the vulnerability
- description: Detailed vulnerability description
- patches: List of patch records, each with:
url: Verified patch URL (GitHub/GitLab)
patch_text_b64: Base64-encoded unified diff
commit_message: Associated commit message
- cwe: List of CWE identifiers and names
The vulnerabilities can be sourced from:
- NVD CVE List — enriched with commit references
- GitHub Security Advisories (GHSA)
- GitLab advisories
- CSAF feeds from vendors including Red Hat, Cisco, and CISA
Use Cases
The dataset supports a range of security-focused machine learning tasks:
* Vulnerability classification
* CWE prediction from descriptions
* Patch generation from natural language
* Commit message understanding
Associated Code
The dataset is generated with the extraction pipeline from vulnerability-lookup/ML-Gateway, which includes logic for fetching, filtering, validating, and encoding patch data.
- Downloads last month
- 169
Size of downloaded dataset files:
725 MB
Size of the auto-converted Parquet files:
725 MB
Number of rows:
15,836
Models trained or fine-tuned on CIRCL/vulnerability-cwe-patch