id
stringlengths 12
19
| title
stringlengths 0
237
| description
stringlengths 35
3.87k
⌀ | patches
listlengths 1
22
| cwe
stringlengths 2
440
⌀ |
|---|---|---|---|---|
CVE-2024-11171
|
Improper Input Validation in danny-avila/librechat
|
In danny-avila/librechat version git 0c2a583, there is an improper input validation vulnerability. The application uses multer middleware for handling multipart file uploads. When using in-memory storage (the default setting for multer), there is no limit on the upload file size. This can lead to a server crash due to out-of-memory errors when handling large files. An attacker without any privileges can exploit this vulnerability to cause a complete denial of service. The issue is fixed in version 0.7.6.
|
[
{
"commit_message": "[PATCH] fix: refactor avatar upload handling to use fs for file reading and enhance file validation api/server/routes/files/avatar.js | 9 +++++---- api/server/services/Files/process.js | 18 ++++++++++++------ 2 files changed, 17 insertions(+), 10 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/danny-avila/librechat/commit/bb58a2d0662ef86dc75a9d2f6560125c018e3836.patch"
}
] |
CWE-770 Allocation of Resources Without Limits or Throttling
|
CVE-2024-24811
|
Products.SQLAlchemyDA vulnerable to unauthenticated arbitrary SQL query execution
|
SQLAlchemyDA is a generic database adapter for ZSQL methods. A vulnerability found in versions prior to 2.2 allows unauthenticated execution of arbitrary SQL statements on the database to which the SQLAlchemyDA instance is connected. All users are affected. The problem has been patched in version 2.2. There is no workaround for the problem.
|
[
{
"commit_message": "[PATCH] - Add missing security declarations on the database adapter class CHANGES.rst | 3 +++ src/Products/SQLAlchemyDA/da.py | 3 +++ 2 files changed, 6 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/zopefoundation/Products.SQLAlchemyDA/commit/e682b99f8406f20bc3f0f2c77153ed7345fd215a.patch"
}
] |
CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')
|
GHSA-v6qv-c78w-ff25
| null |
[
{
"commit_message": "[PATCH] ci: add llvm dependencies Signed-off-by: Ettore Di Giacinto <mudler@users.noreply.github.com> Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSBkMDJhMGY2ZjAxZDVjNGE5MjZhMmQ2NzE5MGNiNTVkN2FjYTIzYjY2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFdHRvcmUgRGkgR2lhY2ludG8gPG11ZGxlckB1c2Vycy5ub3JlcGx5LmdpdGh1Yi5jb20+CkRhdGU6IFR1ZSwgMjAgQXVnIDIwMjQgMTg6Mjc6MTAgKzAyMDAKU3ViamVjdDogW1BBVENIXSBjaTogYWRkIGxsdm0gZGVwZW5kZW5jaWVzCgpTaWduZWQtb2ZmLWJ5OiBFdHRvcmUgRGkgR2lhY2ludG8gPG11ZGxlckB1c2Vycy5ub3JlcGx5LmdpdGh1Yi5jb20+Ci0tLQogRG9ja2VyZmlsZSB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL0RvY2tlcmZpbGUgYi9Eb2NrZXJmaWxlCmluZGV4IGU1Y2JiYzgzNDk2Ny4uZjY5ZWMwNjdiNmYzIDEwMDY0NAotLS0gYS9Eb2NrZXJmaWxlCisrKyBiL0RvY2tlcmZpbGUKQEAgLTgxLDcgKzgxLDcgQEAgUlVOIGFwdC1nZXQgdXBkYXRlICYmIFwKICAgICAgICAgZXNwZWFrIFwKICAgICAgICAgcHl0aG9uMy1waXAgXAogICAgICAgICBweXRob24taXMtcHl0aG9uMyBcCi0gICAgICAgIHB5dGhvbjMtZGV2IFwKKyAgICAgICAgcHl0aG9uMy1kZXYgbHNiX3JlbGVhc2Ugd2dldCBhZGQtYXB0LXJlcG9zaXRvcnkgZ3BnIFwKICAgICAgICAgcHl0aG9uMy12ZW52ICYmIFwKICAgICBhcHQtZ2V0IGNsZWFuICYmIFwKICAgICBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyogJiYgXA==",
"url": "https://github.com/mudler/localai/commit/d02a0f6f01d5c4a926a2d67190cb55d7aca23b66.patch"
}
] | null |
|
GHSA-h2fp-7rxc-44gq
| null |
[
{
"commit_message": "[PATCH] nfs: always make sure page is up-to-date before extending a write to cover the entire page MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We should always make sure the cached page is up-to-date when we're determining whether we can extend a write to cover the full page -- even if we've received a write delegation from the server. Commit c7559663 added logic to skip this check if we have a write delegation, which can lead to data corruption such as the following scenario if client B receives a write delegation from the NFS server: Client A: # echo 123456789 > /mnt/file Client B: # echo abcdefghi >> /mnt/file # cat /mnt/file 0�D0�abcdefghi Just because we hold a write delegation doesn't mean that we've read in the entire page contents. Cc: <stable@vger.kernel.org> # v3.11+ Signed-off-by: Scott Mayhew <smayhew@redhat.com> Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com> fs/nfs/write.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/torvalds/linux/commit/263b4509ec4d47e0da3e753f85a39ea12d1eff24.patch"
}
] | null |
|
CVE-2022-4585
|
Opencaching Deutschland oc-server3 Cookie start.tpl cross site scripting
|
A vulnerability classified as problematic has been found in Opencaching Deutschland oc-server3. This affects an unknown part of the file htdocs/templates2/ocstyle/start.tpl of the component Cookie Handler. The manipulation of the argument usercountryCode leads to cross site scripting. It is possible to initiate the attack remotely. The name of the patch is c720f2777a452186c67ef30db3679dd409556544. It is recommended to apply a patch to fix this issue. The associated identifier of this vulnerability is VDB-216171.
|
[
{
"commit_message": "[PATCH] Fix XSS on home page (OBB-602216) Do not store totaly invalid countries in cookie in the first place htdocs/lib2/common.inc.php | 2 +- htdocs/templates2/ocstyle/start.tpl | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/OpencachingDeutschland/oc-server3/commit/c720f2777a452186c67ef30db3679dd409556544.patch"
}
] |
CWE-707 Improper Neutralization -> CWE-74 Injection -> CWE-79 Cross Site Scripting
|
GHSA-3f84-rpwh-47g6
|
Waitress vulnerable to DoS leading to high CPU usage/resource exhaustion
| null |
[
{
"commit_message": "[PATCH 1/6] HTTPChannel is always created from accept, explicitly set self.connected to True src/waitress/channel.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)",
"patch_text_b64": "From 03cc640fe7106902899f82115c26e37002bca7f1 Mon Sep 17 00:00:00 2001
From: Delta Regeer <bertjw@regeer.org>
Date: Sun, 3 Mar 2024 16:15:51 -0700
Subject: [PATCH 1/6] HTTPChannel is always created from accept, explicitly set
 self.connected to True

---
 src/waitress/channel.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/waitress/channel.py b/src/waitress/channel.py
index eb59dd3f..ea019d3f 100644
--- a/src/waitress/channel.py
+++ b/src/waitress/channel.py
@@ -67,8 +67,7 @@ def __init__(self, server, sock, addr, adj, map=None):
         self.outbuf_lock = threading.Condition()
 
         wasyncore.dispatcher.__init__(self, sock, map=map)
-
-        # Don't let wasyncore.dispatcher throttle self.addr on us.
+        self.connected = True
         self.addr = addr
         self.requests = []
 

From 840aebce1c4c1bfd9036f402c1f5d5a4d2f4a1c2 Mon Sep 17 00:00:00 2001
From: Delta Regeer <bertjw@regeer.org>
Date: Sun, 3 Mar 2024 16:16:48 -0700
Subject: [PATCH 2/6] Assume socket is not connected when passed to
 wasyncore.dispatcher

No longer call getpeername() on the remote socket either, as it is not
necessary for any of the places where waitress requires that self.addr
in a subclass of the dispatcher needs it.

This removes a race condition when setting up a HTTPChannel where we
accepted the socket, and know the remote address, yet call getpeername()
again which would have the unintended side effect of potentially setting
self.connected to False because the remote has already shut down part of
the socket.

This issue was uncovered in #418, where the server would go into a hard
loop because self.connected was used in various parts of the code base.
---
 src/waitress/wasyncore.py | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/src/waitress/wasyncore.py b/src/waitress/wasyncore.py
index 86155578..97943085 100644
--- a/src/waitress/wasyncore.py
+++ b/src/waitress/wasyncore.py
@@ -297,22 +297,6 @@ def __init__(self, sock=None, map=None):
             # get a socket from a blocking source.
             sock.setblocking(0)
             self.set_socket(sock, map)
-            self.connected = True
-            # The constructor no longer requires that the socket
-            # passed be connected.
-            try:
-                self.addr = sock.getpeername()
-            except OSError as err:
-                if err.args[0] in (ENOTCONN, EINVAL):
-                    # To handle the case where we got an unconnected
-                    # socket.
-                    self.connected = False
-                else:
-                    # The socket is broken in some unknown way, alert
-                    # the user and remove it from the map (to prevent
-                    # polling of broken sockets).
-                    self.del_channel(map)
-                    raise
         else:
             self.socket = None
 

From 86c680df4e4bdd40c78dec771cddcee059e802c4 Mon Sep 17 00:00:00 2001
From: Delta Regeer <bertjw@regeer.org>
Date: Sun, 3 Mar 2024 16:23:33 -0700
Subject: [PATCH 3/6] Remove test for getpeername()

---
 tests/test_wasyncore.py | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/tests/test_wasyncore.py b/tests/test_wasyncore.py
index 55c40191..a8a480a8 100644
--- a/tests/test_wasyncore.py
+++ b/tests/test_wasyncore.py
@@ -1454,17 +1454,6 @@ def _makeOne(self, sock=None, map=None):
 
         return dispatcher(sock=sock, map=map)
 
-    def test_unexpected_getpeername_exc(self):
-        sock = dummysocket()
-
-        def getpeername():
-            raise OSError(errno.EBADF)
-
-        map = {}
-        sock.getpeername = getpeername
-        self.assertRaises(socket.error, self._makeOne, sock=sock, map=map)
-        self.assertEqual(map, {})
-
     def test___repr__accepting(self):
         sock = dummysocket()
         map = {}

From 8cba302b1ac08c2874ae179b2af2445e89311bac Mon Sep 17 00:00:00 2001
From: Delta Regeer <bertjw@regeer.org>
Date: Sun, 3 Mar 2024 16:26:22 -0700
Subject: [PATCH 4/6] Don't exit handle_write early -- even if socket is not
 connected

Calling handle_close() multiple times does not hurt anything, and is
safe.
---
 src/waitress/channel.py | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/waitress/channel.py b/src/waitress/channel.py
index ea019d3f..3860ed51 100644
--- a/src/waitress/channel.py
+++ b/src/waitress/channel.py
@@ -91,13 +91,7 @@ def handle_write(self):
         # Precondition: there's data in the out buffer to be sent, or
         # there's a pending will_close request
 
-        if not self.connected:
-            # we dont want to close the channel twice
-
-            return
-
         # try to flush any pending output
-
         if not self.requests:
             # 1. There are no running tasks, so we don't need to try to lock
             #    the outbuf before sending

From 63678e652d912e67621580123c603e37c319d8c4 Mon Sep 17 00:00:00 2001
From: Delta Regeer <bertjw@regeer.org>
Date: Sun, 3 Mar 2024 16:35:39 -0700
Subject: [PATCH 5/6] Remove code not used by waitress from vendored asyncore

---
 src/waitress/wasyncore.py | 45 ------------------
 tests/test_wasyncore.py   | 96 ++++++++-------------------------------
 2 files changed, 18 insertions(+), 123 deletions(-)

diff --git a/src/waitress/wasyncore.py b/src/waitress/wasyncore.py
index 97943085..49829f98 100644
--- a/src/waitress/wasyncore.py
+++ b/src/waitress/wasyncore.py
@@ -378,23 +378,6 @@ def bind(self, addr):
         self.addr = addr
         return self.socket.bind(addr)
 
-    def connect(self, address):
-        self.connected = False
-        self.connecting = True
-        err = self.socket.connect_ex(address)
-        if (
-            err in (EINPROGRESS, EALREADY, EWOULDBLOCK)
-            or err == EINVAL
-            and os.name == "nt"
-        ):  # pragma: no cover
-            self.addr = address
-            return
-        if err in (0, EISCONN):
-            self.addr = address
-            self.handle_connect_event()
-        else:
-            raise OSError(err, errorcode[err])
-
     def accept(self):
         # XXX can return either an address pair or None
         try:
@@ -556,34 +539,6 @@ def handle_close(self):
         self.close()
 
 
-# ---------------------------------------------------------------------------
-# adds simple buffered output capability, useful for simple clients.
-# [for more sophisticated usage use asynchat.async_chat]
-# ---------------------------------------------------------------------------
-
-
-class dispatcher_with_send(dispatcher):
-    def __init__(self, sock=None, map=None):
-        dispatcher.__init__(self, sock, map)
-        self.out_buffer = b""
-
-    def initiate_send(self):
-        num_sent = 0
-        num_sent = dispatcher.send(self, self.out_buffer[:65536])
-        self.out_buffer = self.out_buffer[num_sent:]
-
-    handle_write = initiate_send
-
-    def writable(self):
-        return (not self.connected) or len(self.out_buffer)
-
-    def send(self, data):
-        if self.debug:  # pragma: no cover
-            self.log_info("sending %s" % repr(data))
-        self.out_buffer = self.out_buffer + data
-        self.initiate_send()
-
-
 def close_all(map=None, ignore_all=False):
     if map is None:  # pragma: no cover
         map = socket_map
diff --git a/tests/test_wasyncore.py b/tests/test_wasyncore.py
index a8a480a8..20f68f6e 100644
--- a/tests/test_wasyncore.py
+++ b/tests/test_wasyncore.py
@@ -1,6 +1,7 @@
 import _thread as thread
 import contextlib
 import errno
+from errno import EALREADY, EINPROGRESS, EINVAL, EISCONN, EWOULDBLOCK, errorcode
 import functools
 import gc
 from io import BytesIO
@@ -641,62 +642,6 @@ def test_strerror(self):
         self.assertTrue(err != "")
 
 
-class dispatcherwithsend_noread(asyncore.dispatcher_with_send):  # pragma: no cover
-    def readable(self):
-        return False
-
-    def handle_connect(self):
-        pass
-
-
-class DispatcherWithSendTests(unittest.TestCase):
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        asyncore.close_all()
-
-    @reap_threads
-    def test_send(self):
-        evt = threading.Event()
-        sock = socket.socket()
-        sock.settimeout(3)
-        port = bind_port(sock)
-
-        cap = BytesIO()
-        args = (evt, cap, sock)
-        t = threading.Thread(target=capture_server, args=args)
-        t.start()
-        try:
-            # wait a little longer for the server to initialize (it sometimes
-            # refuses connections on slow machines without this wait)
-            time.sleep(0.2)
-
-            data = b"Suppose there isn't a 16-ton weight?"
-            d = dispatcherwithsend_noread()
-            d.create_socket()
-            d.connect((HOST, port))
-
-            # give time for socket to connect
-            time.sleep(0.1)
-
-            d.send(data)
-            d.send(data)
-            d.send(b"\n")
-
-            n = 1000
-
-            while d.out_buffer and n > 0:  # pragma: no cover
-                asyncore.poll()
-                n -= 1
-
-            evt.wait()
-
-            self.assertEqual(cap.getvalue(), data * 2)
-        finally:
-            join_thread(t, timeout=TIMEOUT)
-
-
 @unittest.skipUnless(
     hasattr(asyncore, "file_wrapper"), "asyncore.file_wrapper required"
 )
@@ -839,6 +784,23 @@ def __init__(self, family, address):
         self.create_socket(family)
         self.connect(address)
 
+    def connect(self, address):
+        self.connected = False
+        self.connecting = True
+        err = self.socket.connect_ex(address)
+        if (
+            err in (EINPROGRESS, EALREADY, EWOULDBLOCK)
+            or err == EINVAL
+            and os.name == "nt"
+        ):  # pragma: no cover
+            self.addr = address
+            return
+        if err in (0, EISCONN):
+            self.addr = address
+            self.handle_connect_event()
+        else:
+            raise OSError(err, errorcode[err])
+
     def handle_connect(self):
         pass
 
@@ -1489,13 +1451,6 @@ def setsockopt(*arg, **kw):
         inst.set_reuse_addr()
         self.assertTrue(sock.errored)
 
-    def test_connect_raise_socket_error(self):
-        sock = dummysocket()
-        map = {}
-        sock.connect_ex = lambda *arg: 1
-        inst = self._makeOne(sock=sock, map=map)
-        self.assertRaises(socket.error, inst.connect, 0)
-
     def test_accept_raise_TypeError(self):
         sock = dummysocket()
         map = {}
@@ -1664,21 +1619,6 @@ def test_handle_accepted(self):
         self.assertTrue(sock.closed)
 
 
-class Test_dispatcher_with_send(unittest.TestCase):
-    def _makeOne(self, sock=None, map=None):
-        from waitress.wasyncore import dispatcher_with_send
-
-        return dispatcher_with_send(sock=sock, map=map)
-
-    def test_writable(self):
-        sock = dummysocket()
-        map = {}
-        inst = self._makeOne(sock=sock, map=map)
-        inst.out_buffer = b"123"
-        inst.connected = True
-        self.assertTrue(inst.writable())
-
-
 class Test_close_all(unittest.TestCase):
     def _callFUT(self, map=None, ignore_all=False):
         from waitress.wasyncore import close_all

From 9d99c89ae4aa8449313eea210a5ec9f3994a87b2 Mon Sep 17 00:00:00 2001
From: Delta Regeer <bertjw@regeer.org>
Date: Sun, 3 Mar 2024 16:37:12 -0700
Subject: [PATCH 6/6] When closing the socket, set it to None

This avoids calling close() twice on the same socket if self.close() or
self.handle_close() is called multiple times
---
 src/waitress/wasyncore.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/waitress/wasyncore.py b/src/waitress/wasyncore.py
index 49829f98..f42ee37c 100644
--- a/src/waitress/wasyncore.py
+++ b/src/waitress/wasyncore.py
@@ -436,6 +436,8 @@ def close(self):
                 if why.args[0] not in (ENOTCONN, EBADF):
                     raise
 
+            self.socket = None
+
     # log and log_info may be overridden to provide more sophisticated
     # logging and warning methods. In general, log is for 'hit' logging
     # and 'log_info' is for informational, warning and error logging.
@@ -486,7 +488,11 @@ def handle_expt_event(self):
         # handle_expt_event() is called if there might be an error on the
         # socket, or if there is OOB data
         # check for the error condition first
-        err = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
+        err = (
+            self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
+            if self.socket is not None
+            else 1
+        )
         if err != 0:
             # we can get here when select.select() says that there is an
             # exceptional condition on the socket",
"url": "https://github.com/Pylons/waitress/commit/1ae4e894c9f76543bee06584001583fc6fa8c95c.patch"
}
] | null |
GHSA-rr76-fj9v-7w82
| null |
[
{
"commit_message": "[PATCH] io_uring: COW io_identity on mismatch If the io_identity doesn't completely match the task, then create a copy of it and use that. The existing copy remains valid until the last user of it has gone away. This also changes the personality lookup to be indexed by io_identity, instead of creds directly. Signed-off-by: Jens Axboe <axboe@kernel.dk> fs/io_uring.c | 222 ++++++++++++++++++++++++++++++--------- include/linux/io_uring.h | 1 + 2 files changed, 171 insertions(+), 52 deletions(-)",
"patch_text_b64": "From 1e6fa5216a0e59ef02e8b6b40d553238a3b81d49 Mon Sep 17 00:00:00 2001
From: Jens Axboe <axboe@kernel.dk>
Date: Thu, 15 Oct 2020 08:46:24 -0600
Subject: [PATCH] io_uring: COW io_identity on mismatch

If the io_identity doesn't completely match the task, then create a
copy of it and use that. The existing copy remains valid until the last
user of it has gone away.

This also changes the personality lookup to be indexed by io_identity,
instead of creds directly.

Signed-off-by: Jens Axboe <axboe@kernel.dk>
---
 fs/io_uring.c            | 222 ++++++++++++++++++++++++++++++---------
 include/linux/io_uring.h |   1 +
 2 files changed, 171 insertions(+), 52 deletions(-)

diff --git a/fs/io_uring.c b/fs/io_uring.c
index bd6fd51302ed7..ab30834c275f9 100644
--- a/fs/io_uring.c
+++ b/fs/io_uring.c
@@ -1040,6 +1040,27 @@ static inline void req_set_fail_links(struct io_kiocb *req)
 		req->flags |= REQ_F_FAIL_LINK;
 }
 
+/*
+ * None of these are dereferenced, they are simply used to check if any of
+ * them have changed. If we're under current and check they are still the
+ * same, we're fine to grab references to them for actual out-of-line use.
+ */
+static void io_init_identity(struct io_identity *id)
+{
+	id->files = current->files;
+	id->mm = current->mm;
+#ifdef CONFIG_BLK_CGROUP
+	rcu_read_lock();
+	id->blkcg_css = blkcg_css();
+	rcu_read_unlock();
+#endif
+	id->creds = current_cred();
+	id->nsproxy = current->nsproxy;
+	id->fs = current->fs;
+	id->fsize = rlimit(RLIMIT_FSIZE);
+	refcount_set(&id->count, 1);
+}
+
 /*
  * Note: must call io_req_init_async() for the first time you
  * touch any members of io_wq_work.
@@ -1051,6 +1072,7 @@ static inline void io_req_init_async(struct io_kiocb *req)
 
 	memset(&req->work, 0, sizeof(req->work));
 	req->flags |= REQ_F_WORK_INITIALIZED;
+	io_init_identity(&req->identity);
 	req->work.identity = &req->identity;
 }
 
@@ -1157,6 +1179,14 @@ static void __io_commit_cqring(struct io_ring_ctx *ctx)
 	}
 }
 
+static void io_put_identity(struct io_kiocb *req)
+{
+	if (req->work.identity == &req->identity)
+		return;
+	if (refcount_dec_and_test(&req->work.identity->count))
+		kfree(req->work.identity);
+}
+
 static void io_req_clean_work(struct io_kiocb *req)
 {
 	if (!(req->flags & REQ_F_WORK_INITIALIZED))
@@ -1189,28 +1219,67 @@ static void io_req_clean_work(struct io_kiocb *req)
 			free_fs_struct(fs);
 		req->work.flags &= ~IO_WQ_WORK_FS;
 	}
+
+	io_put_identity(req);
 }
 
-static void io_prep_async_work(struct io_kiocb *req)
+/*
+ * Create a private copy of io_identity, since some fields don't match
+ * the current context.
+ */
+static bool io_identity_cow(struct io_kiocb *req)
+{
+	const struct cred *creds = NULL;
+	struct io_identity *id;
+
+	if (req->work.flags & IO_WQ_WORK_CREDS)
+		creds = req->work.identity->creds;
+
+	id = kmemdup(req->work.identity, sizeof(*id), GFP_KERNEL);
+	if (unlikely(!id)) {
+		req->work.flags |= IO_WQ_WORK_CANCEL;
+		return false;
+	}
+
+	/*
+	 * We can safely just re-init the creds we copied  Either the field
+	 * matches the current one, or we haven't grabbed it yet. The only
+	 * exception is ->creds, through registered personalities, so handle
+	 * that one separately.
+	 */
+	io_init_identity(id);
+	if (creds)
+		req->work.identity->creds = creds;
+
+	/* add one for this request */
+	refcount_inc(&id->count);
+
+	/* drop old identity, assign new one. one ref for req, one for tctx */
+	if (req->work.identity != &req->identity &&
+	    refcount_sub_and_test(2, &req->work.identity->count))
+		kfree(req->work.identity);
+
+	req->work.identity = id;
+	return true;
+}
+
+static bool io_grab_identity(struct io_kiocb *req)
 {
 	const struct io_op_def *def = &io_op_defs[req->opcode];
+	struct io_identity *id = &req->identity;
 	struct io_ring_ctx *ctx = req->ctx;
 
-	io_req_init_async(req);
+	if (def->needs_fsize && id->fsize != rlimit(RLIMIT_FSIZE))
+		return false;
 
-	if (req->flags & REQ_F_ISREG) {
-		if (def->hash_reg_file || (ctx->flags & IORING_SETUP_IOPOLL))
-			io_wq_hash_work(&req->work, file_inode(req->file));
-	} else {
-		if (def->unbound_nonreg_file)
-			req->work.flags |= IO_WQ_WORK_UNBOUND;
-	}
 	if (!(req->work.flags & IO_WQ_WORK_FILES) &&
-	    (io_op_defs[req->opcode].work_flags & IO_WQ_WORK_FILES) &&
+	    (def->work_flags & IO_WQ_WORK_FILES) &&
 	    !(req->flags & REQ_F_NO_FILE_TABLE)) {
-		req->work.identity->files = get_files_struct(current);
-		get_nsproxy(current->nsproxy);
-		req->work.identity->nsproxy = current->nsproxy;
+		if (id->files != current->files ||
+		    id->nsproxy != current->nsproxy)
+			return false;
+		atomic_inc(&id->files->count);
+		get_nsproxy(id->nsproxy);
 		req->flags |= REQ_F_INFLIGHT;
 
 		spin_lock_irq(&ctx->inflight_lock);
@@ -1218,46 +1287,79 @@ static void io_prep_async_work(struct io_kiocb *req)
 		spin_unlock_irq(&ctx->inflight_lock);
 		req->work.flags |= IO_WQ_WORK_FILES;
 	}
-	if (!(req->work.flags & IO_WQ_WORK_MM) &&
-	    (def->work_flags & IO_WQ_WORK_MM)) {
-		mmgrab(current->mm);
-		req->work.identity->mm = current->mm;
-		req->work.flags |= IO_WQ_WORK_MM;
-	}
 #ifdef CONFIG_BLK_CGROUP
 	if (!(req->work.flags & IO_WQ_WORK_BLKCG) &&
 	    (def->work_flags & IO_WQ_WORK_BLKCG)) {
 		rcu_read_lock();
-		req->work.identity->blkcg_css = blkcg_css();
+		if (id->blkcg_css != blkcg_css()) {
+			rcu_read_unlock();
+			return false;
+		}
 		/*
 		 * This should be rare, either the cgroup is dying or the task
 		 * is moving cgroups. Just punt to root for the handful of ios.
 		 */
-		if (css_tryget_online(req->work.identity->blkcg_css))
+		if (css_tryget_online(id->blkcg_css))
 			req->work.flags |= IO_WQ_WORK_BLKCG;
 		rcu_read_unlock();
 	}
 #endif
 	if (!(req->work.flags & IO_WQ_WORK_CREDS)) {
-		req->work.identity->creds = get_current_cred();
+		if (id->creds != current_cred())
+			return false;
+		get_cred(id->creds);
 		req->work.flags |= IO_WQ_WORK_CREDS;
 	}
 	if (!(req->work.flags & IO_WQ_WORK_FS) &&
 	    (def->work_flags & IO_WQ_WORK_FS)) {
-		spin_lock(&current->fs->lock);
-		if (!current->fs->in_exec) {
-			req->work.identity->fs = current->fs;
-			req->work.identity->fs->users++;
+		if (current->fs != id->fs)
+			return false;
+		spin_lock(&id->fs->lock);
+		if (!id->fs->in_exec) {
+			id->fs->users++;
 			req->work.flags |= IO_WQ_WORK_FS;
 		} else {
 			req->work.flags |= IO_WQ_WORK_CANCEL;
 		}
 		spin_unlock(&current->fs->lock);
 	}
-	if (def->needs_fsize)
-		req->work.identity->fsize = rlimit(RLIMIT_FSIZE);
-	else
-		req->work.identity->fsize = RLIM_INFINITY;
+
+	return true;
+}
+
+static void io_prep_async_work(struct io_kiocb *req)
+{
+	const struct io_op_def *def = &io_op_defs[req->opcode];
+	struct io_identity *id = &req->identity;
+	struct io_ring_ctx *ctx = req->ctx;
+
+	io_req_init_async(req);
+
+	if (req->flags & REQ_F_ISREG) {
+		if (def->hash_reg_file || (ctx->flags & IORING_SETUP_IOPOLL))
+			io_wq_hash_work(&req->work, file_inode(req->file));
+	} else {
+		if (def->unbound_nonreg_file)
+			req->work.flags |= IO_WQ_WORK_UNBOUND;
+	}
+
+	/* ->mm can never change on us */
+	if (!(req->work.flags & IO_WQ_WORK_MM) &&
+	    (def->work_flags & IO_WQ_WORK_MM)) {
+		mmgrab(id->mm);
+		req->work.flags |= IO_WQ_WORK_MM;
+	}
+
+	/* if we fail grabbing identity, we must COW, regrab, and retry */
+	if (io_grab_identity(req))
+		return;
+
+	if (!io_identity_cow(req))
+		return;
+
+	/* can't fail at this point */
+	if (!io_grab_identity(req))
+		WARN_ON(1);
 }
 
 static void io_prep_async_link(struct io_kiocb *req)
@@ -1696,12 +1798,10 @@ static void io_dismantle_req(struct io_kiocb *req)
 
 static void __io_free_req(struct io_kiocb *req)
 {
-	struct io_uring_task *tctx;
-	struct io_ring_ctx *ctx;
+	struct io_uring_task *tctx = req->task->io_uring;
+	struct io_ring_ctx *ctx = req->ctx;
 
 	io_dismantle_req(req);
-	tctx = req->task->io_uring;
-	ctx = req->ctx;
 
 	atomic_long_inc(&tctx->req_complete);
 	if (tctx->in_idle)
@@ -6374,11 +6474,16 @@ static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req,
 
 	id = READ_ONCE(sqe->personality);
 	if (id) {
+		struct io_identity *iod;
+
 		io_req_init_async(req);
-		req->work.identity->creds = idr_find(&ctx->personality_idr, id);
-		if (unlikely(!req->work.identity->creds))
+		iod = idr_find(&ctx->personality_idr, id);
+		if (unlikely(!iod))
 			return -EINVAL;
-		get_cred(req->work.identity->creds);
+		refcount_inc(&iod->count);
+		io_put_identity(req);
+		get_cred(iod->creds);
+		req->work.identity = iod;
 		req->work.flags |= IO_WQ_WORK_CREDS;
 	}
 
@@ -8171,11 +8276,14 @@ static int io_uring_fasync(int fd, struct file *file, int on)
 static int io_remove_personalities(int id, void *p, void *data)
 {
 	struct io_ring_ctx *ctx = data;
-	const struct cred *cred;
+	struct io_identity *iod;
 
-	cred = idr_remove(&ctx->personality_idr, id);
-	if (cred)
-		put_cred(cred);
+	iod = idr_remove(&ctx->personality_idr, id);
+	if (iod) {
+		put_cred(iod->creds);
+		if (refcount_dec_and_test(&iod->count))
+			kfree(iod);
+	}
 	return 0;
 }
 
@@ -9245,23 +9353,33 @@ static int io_probe(struct io_ring_ctx *ctx, void __user *arg, unsigned nr_args)
 
 static int io_register_personality(struct io_ring_ctx *ctx)
 {
-	const struct cred *creds = get_current_cred();
-	int id;
+	struct io_identity *id;
+	int ret;
 
-	id = idr_alloc_cyclic(&ctx->personality_idr, (void *) creds, 1,
-				USHRT_MAX, GFP_KERNEL);
-	if (id < 0)
-		put_cred(creds);
-	return id;
+	id = kmalloc(sizeof(*id), GFP_KERNEL);
+	if (unlikely(!id))
+		return -ENOMEM;
+
+	io_init_identity(id);
+	id->creds = get_current_cred();
+
+	ret = idr_alloc_cyclic(&ctx->personality_idr, id, 1, USHRT_MAX, GFP_KERNEL);
+	if (ret < 0) {
+		put_cred(id->creds);
+		kfree(id);
+	}
+	return ret;
 }
 
 static int io_unregister_personality(struct io_ring_ctx *ctx, unsigned id)
 {
-	const struct cred *old_creds;
+	struct io_identity *iod;
 
-	old_creds = idr_remove(&ctx->personality_idr, id);
-	if (old_creds) {
-		put_cred(old_creds);
+	iod = idr_remove(&ctx->personality_idr, id);
+	if (iod) {
+		put_cred(iod->creds);
+		if (refcount_dec_and_test(&iod->count))
+			kfree(iod);
 		return 0;
 	}
 
diff --git a/include/linux/io_uring.h b/include/linux/io_uring.h
index 352aa6bbd36b9..342cc574d5c07 100644
--- a/include/linux/io_uring.h
+++ b/include/linux/io_uring.h
@@ -15,6 +15,7 @@ struct io_identity {
 	struct nsproxy			*nsproxy;
 	struct fs_struct		*fs;
 	unsigned long			fsize;
+	refcount_t			count;
 };
 
 struct io_uring_task {",
"url": "https://github.com/gregkh/linux/commit/1e6fa5216a0e59ef02e8b6b40d553238a3b81d49.patch"
}
] | null |
|
GHSA-q73m-3q7r-fpf7
|
Cross-site Scripting in ShowDoc
| null |
[
{
"commit_message": "[PATCH] Update AttachmentModel.class.php server/Application/Api/Model/AttachmentModel.class.php | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSBhYTQxYzgzZTBjYzUwNzlmYjM5ZTA0ZDlmNjMwNTcxZmZiOGJiZjIyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBamF5c2VuIFIgPDQwMTMyNDIwK2FqYXlzZW5yQHVzZXJzLm5vcmVwbHkuZ2l0aHViLmNvbT4KRGF0ZTogTW9uLCAxNCBNYXIgMjAyMiAxMjoyNDozMyArMDAwMApTdWJqZWN0OiBbUEFUQ0hdIFVwZGF0ZSBBdHRhY2htZW50TW9kZWwuY2xhc3MucGhwCgotLS0KIHNlcnZlci9BcHBsaWNhdGlvbi9BcGkvTW9kZWwvQXR0YWNobWVudE1vZGVsLmNsYXNzLnBocCB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL3NlcnZlci9BcHBsaWNhdGlvbi9BcGkvTW9kZWwvQXR0YWNobWVudE1vZGVsLmNsYXNzLnBocCBiL3NlcnZlci9BcHBsaWNhdGlvbi9BcGkvTW9kZWwvQXR0YWNobWVudE1vZGVsLmNsYXNzLnBocAppbmRleCAzY2U5NGNlYWYuLmFjOTY2NmMxZiAxMDA2NDQKLS0tIGEvc2VydmVyL0FwcGxpY2F0aW9uL0FwaS9Nb2RlbC9BdHRhY2htZW50TW9kZWwuY2xhc3MucGhwCisrKyBiL3NlcnZlci9BcHBsaWNhdGlvbi9BcGkvTW9kZWwvQXR0YWNobWVudE1vZGVsLmNsYXNzLnBocApAQCAtMzI1LDcgKzMyNSw3IEBAIHB1YmxpYyBmdW5jdGlvbiBpc0FsbG93ZWRGaWxlbmFtZSgkZmlsZW5hbWUpewogCQkkYWxsb3dfYXJyYXkgPSBhcnJheSgKIAkJCScuanBnJywnLmpwZWcnLCcucG5nJywnLmJtcCcsJy5naWYnLCcuaWNvJywnLndlYnAnLAogCQkJJy5tcDMnLCcud2F2JywnLm00YScsJy5vZ2cnLCcud2VibWEnLCcubXA0JywnLmZsdicsCi0JCQknLm1vdicsJy53ZWJtdicsJy5tM3U4YScsJy5mbGFjJywnLm1rdicsCisJCQknLm1vdicsJy53ZWJtdicsJy5mbGFjJywnLm1rdicsCiAJCQknLnppcCcsJy50YXInLCcuZ3onLCcudGd6JywnLmlwYScsJy5hcGsnLCcucmFyJywnLmlzbycsJy5iejInLCcuZXB1YicsCiAJCQknLnBkZicsJy5vZmQnLCcuc3dmJywnLmVwdWInLCcueHBzJywKIAkJCScuZG9jJywnLmRvY3gnLCcub2R0JywnLnJ0ZicsJy5kb2NtJywnLmRvdG0nLCcuZG90JywnLmRvdHgnLCcud3BzJywnLndwdCcs",
"url": "https://github.com/star7th/showdoc/commit/d1c9ed0d77ea5d56f09be0c492361dca8af745bb.patch"
}
] | null |
GHSA-x9vc-5q77-m7x4
|
Improper Input Validation in pyload-ng
| null |
[
{
"commit_message": "[PATCH] validate time config values src/pyload/core/config/parser.py | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/pyload/pyload/commit/a2b1eb1028f45ac58dea5f58593c1d3db2b4a104.patch"
}
] | null |
GHSA-q8h9-pqcx-59hw
|
Apache Airflow exposes arbitrary file content
| null |
[
{
"commit_message": "[PATCH] Configurable umask to all deamonized processes. (#25664) We previously had this for just the `celery worker` subcommand, this PR extends it to anything that can run in daemon mode (cherry picked from commit bf14d14e272d24ee7a3f798c242593078359383e) airflow/cli/cli_parser.py | 1 - airflow/cli/commands/celery_command.py | 3 +++ airflow/cli/commands/dag_processor_command.py | 2 ++ airflow/cli/commands/kerberos_command.py | 1 + airflow/cli/commands/scheduler_command.py | 1 + airflow/cli/commands/triggerer_command.py | 1 + airflow/cli/commands/webserver_command.py | 1 + airflow/config_templates/config.yml | 22 +++++++++++-------- airflow/config_templates/default_airflow.cfg | 13 ++++++----- airflow/configuration.py | 10 +++++++++ airflow/settings.py | 2 ++ tests/cli/commands/test_celery_command.py | 1 + tests/cli/commands/test_kerberos_command.py | 1 + 13 files changed, 44 insertions(+), 15 deletions(-)",
"patch_text_b64": "From b6a2cd1aa34f69a36ea127e4f7f5ba87f4aca420 Mon Sep 17 00:00:00 2001
From: Ash Berlin-Taylor <ash_github@firemirror.com>
Date: Thu, 11 Aug 2022 17:03:55 +0100
Subject: [PATCH] Configurable umask to all deamonized processes. (#25664)

We previously had this for just the `celery worker` subcommand, this PR
extends it to anything that can run in daemon mode

(cherry picked from commit bf14d14e272d24ee7a3f798c242593078359383e)
---
 airflow/cli/cli_parser.py                     |  1 -
 airflow/cli/commands/celery_command.py        |  3 +++
 airflow/cli/commands/dag_processor_command.py |  2 ++
 airflow/cli/commands/kerberos_command.py      |  1 +
 airflow/cli/commands/scheduler_command.py     |  1 +
 airflow/cli/commands/triggerer_command.py     |  1 +
 airflow/cli/commands/webserver_command.py     |  1 +
 airflow/config_templates/config.yml           | 22 +++++++++++--------
 airflow/config_templates/default_airflow.cfg  | 13 ++++++-----
 airflow/configuration.py                      | 10 +++++++++
 airflow/settings.py                           |  2 ++
 tests/cli/commands/test_celery_command.py     |  1 +
 tests/cli/commands/test_kerberos_command.py   |  1 +
 13 files changed, 44 insertions(+), 15 deletions(-)

diff --git a/airflow/cli/cli_parser.py b/airflow/cli/cli_parser.py
index d494aa0f0656f..ae71d2007a219 100644
--- a/airflow/cli/cli_parser.py
+++ b/airflow/cli/cli_parser.py
@@ -667,7 +667,6 @@ def string_lower_type(val):
 ARG_UMASK = Arg(
     ("-u", "--umask"),
     help="Set the umask of celery worker in daemon mode",
-    default=conf.get('celery', 'worker_umask'),
 )
 ARG_WITHOUT_MINGLE = Arg(
     ("--without-mingle",),
diff --git a/airflow/cli/commands/celery_command.py b/airflow/cli/commands/celery_command.py
index affe032411c79..edb61c1b9deb9 100644
--- a/airflow/cli/commands/celery_command.py
+++ b/airflow/cli/commands/celery_command.py
@@ -72,6 +72,7 @@ def flower(args):
                 pidfile=TimeoutPIDLockFile(pidfile, -1),
                 stdout=stdout,
                 stderr=stderr,
+                umask=int(settings.DAEMON_UMASK, 8),
             )
             with ctx:
                 celery_app.start(options)
@@ -180,6 +181,8 @@ def worker(args):
         with open(stdout, 'w+') as stdout_handle, open(stderr, 'w+') as stderr_handle:
             if args.umask:
                 umask = args.umask
+            else:
+                umask = conf.get('celery', 'worker_umask', fallback=settings.DAEMON_UMASK)
 
             ctx = daemon.DaemonContext(
                 files_preserve=[handle],
diff --git a/airflow/cli/commands/dag_processor_command.py b/airflow/cli/commands/dag_processor_command.py
index d57e26510c974..e6a27072cd30c 100644
--- a/airflow/cli/commands/dag_processor_command.py
+++ b/airflow/cli/commands/dag_processor_command.py
@@ -22,6 +22,7 @@
 import daemon
 from daemon.pidfile import TimeoutPIDLockFile
 
+from airflow import settings
 from airflow.configuration import conf
 from airflow.dag_processing.manager import DagFileProcessorManager
 from airflow.utils import cli as cli_utils
@@ -66,6 +67,7 @@ def dag_processor(args):
                 files_preserve=[handle],
                 stdout=stdout_handle,
                 stderr=stderr_handle,
+                umask=int(settings.DAEMON_UMASK, 8),
             )
             with ctx:
                 try:
diff --git a/airflow/cli/commands/kerberos_command.py b/airflow/cli/commands/kerberos_command.py
index fea874349923b..51acdf62dfa37 100644
--- a/airflow/cli/commands/kerberos_command.py
+++ b/airflow/cli/commands/kerberos_command.py
@@ -39,6 +39,7 @@ def kerberos(args):
                 pidfile=TimeoutPIDLockFile(pid, -1),
                 stdout=stdout_handle,
                 stderr=stderr_handle,
+                umask=int(settings.DAEMON_UMASK, 8),
             )
 
             with ctx:
diff --git a/airflow/cli/commands/scheduler_command.py b/airflow/cli/commands/scheduler_command.py
index bc6e983ee5c8e..ab24dd21c7911 100644
--- a/airflow/cli/commands/scheduler_command.py
+++ b/airflow/cli/commands/scheduler_command.py
@@ -65,6 +65,7 @@ def scheduler(args):
                 files_preserve=[handle],
                 stdout=stdout_handle,
                 stderr=stderr_handle,
+                umask=int(settings.DAEMON_UMASK, 8),
             )
             with ctx:
                 _run_scheduler_job(args=args)
diff --git a/airflow/cli/commands/triggerer_command.py b/airflow/cli/commands/triggerer_command.py
index 82e7fde129698..70f860034d73b 100644
--- a/airflow/cli/commands/triggerer_command.py
+++ b/airflow/cli/commands/triggerer_command.py
@@ -45,6 +45,7 @@ def triggerer(args):
                 files_preserve=[handle],
                 stdout=stdout_handle,
                 stderr=stderr_handle,
+                umask=int(settings.DAEMON_UMASK, 8),
             )
             with ctx:
                 job.run()
diff --git a/airflow/cli/commands/webserver_command.py b/airflow/cli/commands/webserver_command.py
index c74513d23e2b9..f1eeb8000f978 100644
--- a/airflow/cli/commands/webserver_command.py
+++ b/airflow/cli/commands/webserver_command.py
@@ -455,6 +455,7 @@ def monitor_gunicorn(gunicorn_master_pid: int):
                     files_preserve=[handle],
                     stdout=stdout,
                     stderr=stderr,
+                    umask=int(settings.DAEMON_UMASK, 8),
                 )
                 with ctx:
                     subprocess.Popen(run_args, close_fds=True)
diff --git a/airflow/config_templates/config.yml b/airflow/config_templates/config.yml
index 4ea090bcd9315..9a97790ab776a 100644
--- a/airflow/config_templates/config.yml
+++ b/airflow/config_templates/config.yml
@@ -366,6 +366,19 @@
       example: ~
       default: "1024"
 
+    - name: daemon_umask
+      description: |
+        The default umask to use for process when run in daemon mode (scheduler, worker,  etc.)
+
+        This controls the file-creation mode mask which determines the initial value of file permission bits
+        for newly created files.
+
+        This value is treated as an octal-integer.
+      version_added: 2.3.4
+      type: string
+      default: "0o077"
+      example: ~
+
 - name: database
   description: ~
   options:
@@ -1643,15 +1656,6 @@
       type: boolean
       example: ~
       default: "true"
-    - name: worker_umask
-      description: |
-        Umask that will be used when starting workers with the ``airflow celery worker``
-        in daemon mode. This control the file-creation mode mask which determines the initial
-        value of file permission bits for newly created files.
-      version_added: 2.0.0
-      type: string
-      example: ~
-      default: "0o077"
     - name: broker_url
       description: |
         The Celery broker URL. Celery supports RabbitMQ, Redis and experimentally
diff --git a/airflow/config_templates/default_airflow.cfg b/airflow/config_templates/default_airflow.cfg
index 86f9cf93fcdca..16f8d8a0d9059 100644
--- a/airflow/config_templates/default_airflow.cfg
+++ b/airflow/config_templates/default_airflow.cfg
@@ -208,6 +208,14 @@ default_pool_task_slot_count = 128
 # mapped tasks from clogging the scheduler.
 max_map_length = 1024
 
+# The default umask to use for process when run in daemon mode (scheduler, worker,  etc.)
+#
+# This controls the file-creation mode mask which determines the initial value of file permission bits
+# for newly created files.
+#
+# This value is treated as an octal-integer.
+daemon_umask = 0o077
+
 [database]
 # The SqlAlchemy connection string to the metadata database.
 # SqlAlchemy supports many different database engines.
@@ -829,11 +837,6 @@ worker_prefetch_multiplier = 1
 # prevent this by setting this to false. However, with this disabled Flower won't work.
 worker_enable_remote_control = true
 
-# Umask that will be used when starting workers with the ``airflow celery worker``
-# in daemon mode. This control the file-creation mode mask which determines the initial
-# value of file permission bits for newly created files.
-worker_umask = 0o077
-
 # The Celery broker URL. Celery supports RabbitMQ, Redis and experimentally
 # a sqlalchemy database. Refer to the Celery documentation for more information.
 broker_url = redis://redis:6379/0
diff --git a/airflow/configuration.py b/airflow/configuration.py
index 4f2caa186e2f7..20dd3c13d93ff 100644
--- a/airflow/configuration.py
+++ b/airflow/configuration.py
@@ -517,7 +517,17 @@ def get_mandatory_value(self, section: str, key: str, **kwargs) -> str:
             raise ValueError(f"The value {section}/{key} should be set!")
         return value
 
+    @overload  # type: ignore[override]
+    def get(self, section: str, key: str, fallback: str = ..., **kwargs) -> str:  # type: ignore[override]
+
+        ...
+
+    @overload  # type: ignore[override]
     def get(self, section: str, key: str, **kwargs) -> Optional[str]:  # type: ignore[override]
+
+        ...
+
+    def get(self, section: str, key: str, **kwargs) -> Optional[str]:  # type: ignore[override, misc]
         section = str(section).lower()
         key = str(key).lower()
 
diff --git a/airflow/settings.py b/airflow/settings.py
index 374960ab3e0c4..be05589f94e8e 100644
--- a/airflow/settings.py
+++ b/airflow/settings.py
@@ -640,3 +640,5 @@ def initialize():
 
 # Prefix used to identify tables holding data moved during migration.
 AIRFLOW_MOVED_TABLE_PREFIX = "_airflow_moved"
+
+DAEMON_UMASK: str = conf.get('core', 'daemon_umask', fallback='0o077')
diff --git a/tests/cli/commands/test_celery_command.py b/tests/cli/commands/test_celery_command.py
index 14a6f52e9dc99..2bc9796cdd671 100644
--- a/tests/cli/commands/test_celery_command.py
+++ b/tests/cli/commands/test_celery_command.py
@@ -354,6 +354,7 @@ def test_run_command_daemon(self, mock_celery_app, mock_daemon, mock_setup_locat
                 pidfile=mock_pid_file.return_value,
                 stderr=mock_open.return_value,
                 stdout=mock_open.return_value,
+                umask=0o077,
             ),
             mock.call.DaemonContext().__enter__(),
             mock.call.DaemonContext().__exit__(None, None, None),
diff --git a/tests/cli/commands/test_kerberos_command.py b/tests/cli/commands/test_kerberos_command.py
index 007bd2f41be0d..855b0515dfacd 100644
--- a/tests/cli/commands/test_kerberos_command.py
+++ b/tests/cli/commands/test_kerberos_command.py
@@ -75,6 +75,7 @@ def test_run_command_daemon(self, mock_krb, mock_daemon, mock_setup_locations, m
                 pidfile=mock_pid_file.return_value,
                 stderr=mock_open.return_value,
                 stdout=mock_open.return_value,
+                umask=0o077,
             ),
             mock.call.DaemonContext().__enter__(),
             mock.call.DaemonContext().__exit__(None, None, None),",
"url": "https://github.com/apache/airflow/commit/b6a2cd1aa34f69a36ea127e4f7f5ba87f4aca420.patch"
},
{
"commit_message": "[PATCH] Configurable umask to all deamonized processes. We previously had this for just the `celery worker` subcommand, this PR extends it to anything that can run in daemon mode airflow/cli/cli_parser.py | 1 - airflow/cli/commands/celery_command.py | 3 +++ airflow/cli/commands/dag_processor_command.py | 2 ++ airflow/cli/commands/kerberos_command.py | 1 + airflow/cli/commands/scheduler_command.py | 1 + airflow/cli/commands/triggerer_command.py | 1 + airflow/cli/commands/webserver_command.py | 1 + airflow/config_templates/config.yml | 22 +++++++++++-------- airflow/config_templates/default_airflow.cfg | 13 ++++++----- airflow/configuration.py | 10 +++++++++ airflow/settings.py | 2 ++ tests/cli/commands/test_celery_command.py | 1 + tests/cli/commands/test_kerberos_command.py | 1 + 13 files changed, 44 insertions(+), 15 deletions(-)",
"patch_text_b64": "From bf01d10cd348e679916034de1befb79ec6e46ff8 Mon Sep 17 00:00:00 2001
From: Ash Berlin-Taylor <ash@apache.org>
Date: Thu, 11 Aug 2022 10:50:04 +0100
Subject: [PATCH] Configurable umask to all deamonized processes.

We previously had this for just the `celery worker` subcommand, this PR
extends it to anything that can run in daemon mode
---
 airflow/cli/cli_parser.py                     |  1 -
 airflow/cli/commands/celery_command.py        |  3 +++
 airflow/cli/commands/dag_processor_command.py |  2 ++
 airflow/cli/commands/kerberos_command.py      |  1 +
 airflow/cli/commands/scheduler_command.py     |  1 +
 airflow/cli/commands/triggerer_command.py     |  1 +
 airflow/cli/commands/webserver_command.py     |  1 +
 airflow/config_templates/config.yml           | 22 +++++++++++--------
 airflow/config_templates/default_airflow.cfg  | 13 ++++++-----
 airflow/configuration.py                      | 10 +++++++++
 airflow/settings.py                           |  2 ++
 tests/cli/commands/test_celery_command.py     |  1 +
 tests/cli/commands/test_kerberos_command.py   |  1 +
 13 files changed, 44 insertions(+), 15 deletions(-)

diff --git a/airflow/cli/cli_parser.py b/airflow/cli/cli_parser.py
index e4be3e978d9f5..4828a37bfc5b0 100644
--- a/airflow/cli/cli_parser.py
+++ b/airflow/cli/cli_parser.py
@@ -671,7 +671,6 @@ def string_lower_type(val):
 ARG_UMASK = Arg(
     ("-u", "--umask"),
     help="Set the umask of celery worker in daemon mode",
-    default=conf.get('celery', 'worker_umask'),
 )
 ARG_WITHOUT_MINGLE = Arg(
     ("--without-mingle",),
diff --git a/airflow/cli/commands/celery_command.py b/airflow/cli/commands/celery_command.py
index d19490caa76c5..c2deb16ff4c20 100644
--- a/airflow/cli/commands/celery_command.py
+++ b/airflow/cli/commands/celery_command.py
@@ -75,6 +75,7 @@ def flower(args):
                 pidfile=TimeoutPIDLockFile(pidfile, -1),
                 stdout=stdout,
                 stderr=stderr,
+                umask=int(settings.DAEMON_UMASK, 8),
             )
             with ctx:
                 celery_app.start(options)
@@ -183,6 +184,8 @@ def worker(args):
         with open(stdout, 'a') as stdout_handle, open(stderr, 'a') as stderr_handle:
             if args.umask:
                 umask = args.umask
+            else:
+                umask = conf.get('celery', 'worker_umask', fallback=settings.DAEMON_UMASK)
 
             stdout_handle.truncate(0)
             stderr_handle.truncate(0)
diff --git a/airflow/cli/commands/dag_processor_command.py b/airflow/cli/commands/dag_processor_command.py
index 4c4e5b46eb7dd..92f7f37ee16d2 100644
--- a/airflow/cli/commands/dag_processor_command.py
+++ b/airflow/cli/commands/dag_processor_command.py
@@ -22,6 +22,7 @@
 import daemon
 from daemon.pidfile import TimeoutPIDLockFile
 
+from airflow import settings
 from airflow.configuration import conf
 from airflow.dag_processing.manager import DagFileProcessorManager
 from airflow.utils import cli as cli_utils
@@ -69,6 +70,7 @@ def dag_processor(args):
                 files_preserve=[handle],
                 stdout=stdout_handle,
                 stderr=stderr_handle,
+                umask=int(settings.DAEMON_UMASK, 8),
             )
             with ctx:
                 try:
diff --git a/airflow/cli/commands/kerberos_command.py b/airflow/cli/commands/kerberos_command.py
index 3a33363df9965..4ccd07092f474 100644
--- a/airflow/cli/commands/kerberos_command.py
+++ b/airflow/cli/commands/kerberos_command.py
@@ -42,6 +42,7 @@ def kerberos(args):
                 pidfile=TimeoutPIDLockFile(pid, -1),
                 stdout=stdout_handle,
                 stderr=stderr_handle,
+                umask=int(settings.DAEMON_UMASK, 8),
             )
 
             with ctx:
diff --git a/airflow/cli/commands/scheduler_command.py b/airflow/cli/commands/scheduler_command.py
index b6f35cff9e737..22a185794fb56 100644
--- a/airflow/cli/commands/scheduler_command.py
+++ b/airflow/cli/commands/scheduler_command.py
@@ -74,6 +74,7 @@ def scheduler(args):
                 files_preserve=[handle],
                 stdout=stdout_handle,
                 stderr=stderr_handle,
+                umask=int(settings.DAEMON_UMASK, 8),
             )
             with ctx:
                 _run_scheduler_job(args=args)
diff --git a/airflow/cli/commands/triggerer_command.py b/airflow/cli/commands/triggerer_command.py
index defe476a8fccf..70fbbda2fcbb3 100644
--- a/airflow/cli/commands/triggerer_command.py
+++ b/airflow/cli/commands/triggerer_command.py
@@ -48,6 +48,7 @@ def triggerer(args):
                 files_preserve=[handle],
                 stdout=stdout_handle,
                 stderr=stderr_handle,
+                umask=int(settings.DAEMON_UMASK, 8),
             )
             with ctx:
                 job.run()
diff --git a/airflow/cli/commands/webserver_command.py b/airflow/cli/commands/webserver_command.py
index da2ed32fc221a..37145c0c816c8 100644
--- a/airflow/cli/commands/webserver_command.py
+++ b/airflow/cli/commands/webserver_command.py
@@ -458,6 +458,7 @@ def monitor_gunicorn(gunicorn_master_pid: int):
                     files_preserve=[handle],
                     stdout=stdout,
                     stderr=stderr,
+                    umask=int(settings.DAEMON_UMASK, 8),
                 )
                 with ctx:
                     subprocess.Popen(run_args, close_fds=True)
diff --git a/airflow/config_templates/config.yml b/airflow/config_templates/config.yml
index cbb808137196c..92c1b13619377 100644
--- a/airflow/config_templates/config.yml
+++ b/airflow/config_templates/config.yml
@@ -374,6 +374,19 @@
       example: ~
       default: "1024"
 
+    - name: daemon_umask
+      description: |
+        The default umask to use for process when run in daemon mode (scheduler, worker,  etc.)
+
+        This control the file-creation mode mask which determines the initial value of file permission bits
+        for newly created files.
+
+        This value is treated as an octal-integer.
+      version_added: 2.3.4
+      type: string
+      default: "0o077"
+      example: ~
+
 - name: database
   description: ~
   options:
@@ -1652,15 +1665,6 @@
       type: boolean
       example: ~
       default: "true"
-    - name: worker_umask
-      description: |
-        Umask that will be used when starting workers with the ``airflow celery worker``
-        in daemon mode. This control the file-creation mode mask which determines the initial
-        value of file permission bits for newly created files.
-      version_added: 2.0.0
-      type: string
-      example: ~
-      default: "0o077"
     - name: broker_url
       description: |
         The Celery broker URL. Celery supports RabbitMQ, Redis and experimentally
diff --git a/airflow/config_templates/default_airflow.cfg b/airflow/config_templates/default_airflow.cfg
index 34046f4cb49cb..0703ef6b96694 100644
--- a/airflow/config_templates/default_airflow.cfg
+++ b/airflow/config_templates/default_airflow.cfg
@@ -212,6 +212,14 @@ default_pool_task_slot_count = 128
 # mapped tasks from clogging the scheduler.
 max_map_length = 1024
 
+# The default umask to use for process when run in daemon mode (scheduler, worker,  etc.)
+#
+# This control the file-creation mode mask which determines the initial value of file permission bits
+# for newly created files.
+#
+# This value is treated as an octal-integer.
+daemon_umask = 0o077
+
 [database]
 # The SqlAlchemy connection string to the metadata database.
 # SqlAlchemy supports many different database engines.
@@ -834,11 +842,6 @@ worker_prefetch_multiplier = 1
 # prevent this by setting this to false. However, with this disabled Flower won't work.
 worker_enable_remote_control = true
 
-# Umask that will be used when starting workers with the ``airflow celery worker``
-# in daemon mode. This control the file-creation mode mask which determines the initial
-# value of file permission bits for newly created files.
-worker_umask = 0o077
-
 # The Celery broker URL. Celery supports RabbitMQ, Redis and experimentally
 # a sqlalchemy database. Refer to the Celery documentation for more information.
 broker_url = redis://redis:6379/0
diff --git a/airflow/configuration.py b/airflow/configuration.py
index 5e84de6ea4b4e..61d2260e5c05b 100644
--- a/airflow/configuration.py
+++ b/airflow/configuration.py
@@ -522,7 +522,17 @@ def get_mandatory_value(self, section: str, key: str, **kwargs) -> str:
             raise ValueError(f"The value {section}/{key} should be set!")
         return value
 
+    @overload  # type: ignore[override]
+    def get(self, section: str, key: str, fallback: str = ..., **kwargs) -> str:  # type: ignore[override]
+
+        ...
+
+    @overload  # type: ignore[override]
     def get(self, section: str, key: str, **kwargs) -> Optional[str]:  # type: ignore[override]
+
+        ...
+
+    def get(self, section: str, key: str, **kwargs) -> Optional[str]:  # type: ignore[override, misc]
         section = str(section).lower()
         key = str(key).lower()
 
diff --git a/airflow/settings.py b/airflow/settings.py
index bea68ec8cfc10..beaed3b4599b0 100644
--- a/airflow/settings.py
+++ b/airflow/settings.py
@@ -640,3 +640,5 @@ def initialize():
 
 # Prefix used to identify tables holding data moved during migration.
 AIRFLOW_MOVED_TABLE_PREFIX = "_airflow_moved"
+
+DAEMON_UMASK: str = conf.get('core', 'daemon_umask', fallback='0o077')
diff --git a/tests/cli/commands/test_celery_command.py b/tests/cli/commands/test_celery_command.py
index 304d7a7c70a1c..cf430903e3ec7 100644
--- a/tests/cli/commands/test_celery_command.py
+++ b/tests/cli/commands/test_celery_command.py
@@ -354,6 +354,7 @@ def test_run_command_daemon(self, mock_celery_app, mock_daemon, mock_setup_locat
                 pidfile=mock_pid_file.return_value,
                 stderr=mock_open.return_value,
                 stdout=mock_open.return_value,
+                umask=0o077,
             ),
             mock.call.DaemonContext().__enter__(),
             mock.call.DaemonContext().__exit__(None, None, None),
diff --git a/tests/cli/commands/test_kerberos_command.py b/tests/cli/commands/test_kerberos_command.py
index 63b14cd9a8b1d..b03cdfd20c362 100644
--- a/tests/cli/commands/test_kerberos_command.py
+++ b/tests/cli/commands/test_kerberos_command.py
@@ -75,6 +75,7 @@ def test_run_command_daemon(self, mock_krb, mock_daemon, mock_setup_locations, m
                 pidfile=mock_pid_file.return_value,
                 stderr=mock_open.return_value,
                 stdout=mock_open.return_value,
+                umask=0o077,
             ),
             mock.call.DaemonContext().__enter__(),
             mock.call.DaemonContext().__exit__(None, None, None),",
"url": "https://github.com/apache/airflow/commit/bf01d10cd348e679916034de1befb79ec6e46ff8.patch"
},
{
"commit_message": "[PATCH] Apply suggestions from code review airflow/config_templates/config.yml | 2 +- airflow/config_templates/default_airflow.cfg | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/airflow/commit/c14ea8f0f34944d2ecfa9021d167602e8b2b8b90.patch"
}
] | null |
GHSA-x377-f64p-hf5j
|
PyCrypto does not properly reseed PRNG before allowing access
| null |
[
{
"commit_message": "[PATCH] Random: Make Crypto.Random.atfork() set last_reseed=None (CVE-2013-1445) == Summary == In PyCrypto before v2.6.1, the Crypto.Random pseudo-random number generator (PRNG) exhibits a race condition that may cause it to generate the same 'random' output in multiple processes that are forked from each other. Depending on the application, this could reveal sensitive information or cryptographic keys to remote attackers. An application may be affected if, within 100 milliseconds, it performs the following steps (which may be summarized as \"read-fork-read-read\"): 1. Read from the Crypto.Random PRNG, causing an internal reseed; 2. Fork the process and invoke Crypto.Random.atfork() in the child; 3. Read from the Crypto.Random PRNG again, in at least two different processes (parent and child, or multiple children). Only applications that invoke Crypto.Random.atfork() and perform the above steps are affected by this issue. Other applications are unaffected. Note: Some PyCrypto functions, such as key generation and PKCS#1-related functions, implicitly read from the Crypto.Random PRNG. == Technical details == Crypto.Random uses Fortuna[1] to generate random numbers. The flow of entropy looks something like this: /dev/urandom -\\ +-> \"accumulator\" --> \"generator\" --> output other sources -/ (entropy pools) (AES-CTR) - The \"accumulator\" maintains several pools that collect entropy from the environment. - The \"generator\" is a deterministic PRNG that is reseeded by the accumulator. Reseeding normally occurs during each request for random numbers, but never more than once every 100 ms (the \"minimum reseed interval\"). When a process is forked, the parent's state is duplicated in the child. In order to continue using the PRNG, the child process must invoke Crypto.Random.atfork(), which collects new entropy from /dev/urandom and adds it to the accumulator. When new PRNG output is subsequently requested, some of the new entropy in the accumulator is used to reseed the generator, causing the output of the child to diverge from its parent. However, in previous versions of PyCrypto, Crypto.Random.atfork() did not explicitly reset the child's rate-limiter, so if the child requested PRNG output before the minimum reseed interval of 100 ms had elapsed, it would generate its output using state inherited from its parent. This created a race condition between the parent process and its forked children that could cause them to produce identical PRNG output for the duration of the 100 ms minimum reseed interval. == Demonstration == Here is some sample code that illustrates the problem: from binascii import hexlify import multiprocessing, pprint, time import Crypto.Random def task_main(arg): a = Crypto.Random.get_random_bytes(8) time.sleep(0.1) b = Crypto.Random.get_random_bytes(8) rdy, ack = arg rdy.set() ack.wait() return \"%s,%s\" % (hexlify(a).decode(), hexlify(b).decode()) n_procs = 4 manager = multiprocessing.Manager() rdys = [manager.Event() for i in range(n_procs)] acks = [manager.Event() for i in range(n_procs)] Crypto.Random.get_random_bytes(1) pool = multiprocessing.Pool(processes=n_procs, initializer=Crypto.Random.atfork) res_async = pool.map_async(task_main, zip(rdys, acks)) pool.close() [rdy.wait() for rdy in rdys] [ack.set() for ack in acks] res = res_async.get() pprint.pprint(sorted(res)) pool.join() The output should be random, but it looked like this: ['c607803ae01aa8c0,2e4de6457a304b34', 'c607803ae01aa8c0,af80d08942b4c987', 'c607803ae01aa8c0,b0e4c0853de927c4', 'c607803ae01aa8c0,f0362585b3fceba4'] == Solution == The solution is to upgrade to PyCrypto v2.6.1 or later, which properly resets the rate-limiter when Crypto.Random.atfork() is invoked in the child. == References == [1] N. Ferguson and B. Schneier, _Practical Cryptography_, Indianapolis: Wiley, 2003, pp. 155-184. .../Random/Fortuna/FortunaAccumulator.py | 9 + lib/Crypto/Random/_UserFriendlyRNG.py | 15 ++ lib/Crypto/SelfTest/Random/__init__.py | 1 + .../SelfTest/Random/test__UserFriendlyRNG.py | 171 ++++++++++++++++++ 4 files changed, 196 insertions(+) create mode 100644 lib/Crypto/SelfTest/Random/test__UserFriendlyRNG.py",
"patch_text_b64": "From 19dcf7b15d61b7dc1a125a367151de40df6ef175 Mon Sep 17 00:00:00 2001
From: Dwayne Litzenberger <dlitz@dlitz.net>
Date: Mon, 14 Oct 2013 14:37:35 -0700
Subject: [PATCH] Random: Make Crypto.Random.atfork() set last_reseed=None
 (CVE-2013-1445)

== Summary ==

In PyCrypto before v2.6.1, the Crypto.Random pseudo-random number
generator (PRNG) exhibits a race condition that may cause it to generate
the same 'random' output in multiple processes that are forked from each
other.  Depending on the application, this could reveal sensitive
information or cryptographic keys to remote attackers.

An application may be affected if, within 100 milliseconds, it performs
the following steps (which may be summarized as "read-fork-read-read"):

1. Read from the Crypto.Random PRNG, causing an internal reseed;
2. Fork the process and invoke Crypto.Random.atfork() in the child;
3. Read from the Crypto.Random PRNG again, in at least two different
   processes (parent and child, or multiple children).

Only applications that invoke Crypto.Random.atfork() and perform the
above steps are affected by this issue.  Other applications are
unaffected.

Note: Some PyCrypto functions, such as key generation and PKCS#1-related
functions, implicitly read from the Crypto.Random PRNG.

== Technical details ==

Crypto.Random uses Fortuna[1] to generate random numbers.  The flow of
entropy looks something like this:

    /dev/urandom  -\
                    +-> "accumulator" --> "generator" --> output
    other sources -/   (entropy pools)     (AES-CTR)

- The "accumulator" maintains several pools that collect entropy from
  the environment.

- The "generator" is a deterministic PRNG that is reseeded by the
  accumulator.  Reseeding normally occurs during each request for random
  numbers, but never more than once every 100 ms (the "minimum reseed
  interval").

When a process is forked, the parent's state is duplicated in the child.
In order to continue using the PRNG, the child process must invoke
Crypto.Random.atfork(), which collects new entropy from /dev/urandom and
adds it to the accumulator.  When new PRNG output is subsequently
requested, some of the new entropy in the accumulator is used to reseed
the generator, causing the output of the child to diverge from its
parent.

However, in previous versions of PyCrypto, Crypto.Random.atfork() did
not explicitly reset the child's rate-limiter, so if the child requested
PRNG output before the minimum reseed interval of 100 ms had elapsed, it
would generate its output using state inherited from its parent.

This created a race condition between the parent process and its forked
children that could cause them to produce identical PRNG output for the
duration of the 100 ms minimum reseed interval.

== Demonstration ==

Here is some sample code that illustrates the problem:

    from binascii import hexlify
    import multiprocessing, pprint, time
    import Crypto.Random

    def task_main(arg):
        a = Crypto.Random.get_random_bytes(8)
        time.sleep(0.1)
        b = Crypto.Random.get_random_bytes(8)
        rdy, ack = arg
        rdy.set()
        ack.wait()
        return "%s,%s" % (hexlify(a).decode(),
                          hexlify(b).decode())

    n_procs = 4
    manager = multiprocessing.Manager()
    rdys = [manager.Event() for i in range(n_procs)]
    acks = [manager.Event() for i in range(n_procs)]
    Crypto.Random.get_random_bytes(1)
    pool = multiprocessing.Pool(processes=n_procs,
                                initializer=Crypto.Random.atfork)
    res_async = pool.map_async(task_main, zip(rdys, acks))
    pool.close()
    [rdy.wait() for rdy in rdys]
    [ack.set() for ack in acks]
    res = res_async.get()
    pprint.pprint(sorted(res))
    pool.join()

The output should be random, but it looked like this:

    ['c607803ae01aa8c0,2e4de6457a304b34',
     'c607803ae01aa8c0,af80d08942b4c987',
     'c607803ae01aa8c0,b0e4c0853de927c4',
     'c607803ae01aa8c0,f0362585b3fceba4']

== Solution ==

The solution is to upgrade to PyCrypto v2.6.1 or later, which properly
resets the rate-limiter when Crypto.Random.atfork() is invoked in the
child.

== References ==

[1] N. Ferguson and B. Schneier, _Practical Cryptography_,
    Indianapolis: Wiley, 2003, pp. 155-184.
---
 .../Random/Fortuna/FortunaAccumulator.py      |   9 +
 lib/Crypto/Random/_UserFriendlyRNG.py         |  15 ++
 lib/Crypto/SelfTest/Random/__init__.py        |   1 +
 .../SelfTest/Random/test__UserFriendlyRNG.py  | 171 ++++++++++++++++++
 4 files changed, 196 insertions(+)
 create mode 100644 lib/Crypto/SelfTest/Random/test__UserFriendlyRNG.py

diff --git a/lib/Crypto/Random/Fortuna/FortunaAccumulator.py b/lib/Crypto/Random/Fortuna/FortunaAccumulator.py
index 5ebbe2b1..1ec6f3cd 100644
--- a/lib/Crypto/Random/Fortuna/FortunaAccumulator.py
+++ b/lib/Crypto/Random/Fortuna/FortunaAccumulator.py
@@ -109,6 +109,15 @@ def __init__(self):
         self.pools = [FortunaPool() for i in range(32)]     # 32 pools
         assert(self.pools[0] is not self.pools[1])
 
+    def _forget_last_reseed(self):
+        # This is not part of the standard Fortuna definition, and using this
+        # function frequently can weaken Fortuna's ability to resist a state
+        # compromise extension attack, but we need this in order to properly
+        # implement Crypto.Random.atfork().  Otherwise, forked child processes
+        # might continue to use their parent's PRNG state for up to 100ms in
+        # some cases. (e.g. CVE-2013-1445)
+        self.last_reseed = None
+
     def random_data(self, bytes):
         current_time = time.time()
         if (self.last_reseed is not None and self.last_reseed > current_time): # Avoid float comparison to None to make Py3k happy
diff --git a/lib/Crypto/Random/_UserFriendlyRNG.py b/lib/Crypto/Random/_UserFriendlyRNG.py
index c2a2eae2..957e006f 100644
--- a/lib/Crypto/Random/_UserFriendlyRNG.py
+++ b/lib/Crypto/Random/_UserFriendlyRNG.py
@@ -90,9 +90,24 @@ def reinit(self):
         """Initialize the random number generator and seed it with entropy from
         the operating system.
         """
+
+        # Save the pid (helps ensure that Crypto.Random.atfork() gets called)
         self._pid = os.getpid()
+
+        # Collect entropy from the operating system and feed it to
+        # FortunaAccumulator
         self._ec.reinit()
 
+        # Override FortunaAccumulator's 100ms minimum re-seed interval.  This
+        # is necessary to avoid a race condition between this function and
+        # self.read(), which that can otherwise cause forked child processes to
+        # produce identical output.  (e.g. CVE-2013-1445)
+        #
+        # Note that if this function can be called frequently by an attacker,
+        # (and if the bits from OSRNG are insufficiently random) it will weaken
+        # Fortuna's ability to resist a state compromise extension attack.
+        self._fa._forget_last_reseed()
+
     def close(self):
         self.closed = True
         self._osrng = None
diff --git a/lib/Crypto/SelfTest/Random/__init__.py b/lib/Crypto/SelfTest/Random/__init__.py
index 48d84ff1..f972bf0b 100644
--- a/lib/Crypto/SelfTest/Random/__init__.py
+++ b/lib/Crypto/SelfTest/Random/__init__.py
@@ -32,6 +32,7 @@ def get_tests(config={}):
     from Crypto.SelfTest.Random import OSRNG;               tests += OSRNG.get_tests(config=config)
     from Crypto.SelfTest.Random import test_random;         tests += test_random.get_tests(config=config)
     from Crypto.SelfTest.Random import test_rpoolcompat;    tests += test_rpoolcompat.get_tests(config=config)
+    from Crypto.SelfTest.Random import test__UserFriendlyRNG; tests += test__UserFriendlyRNG.get_tests(config=config)
     return tests
 
 if __name__ == '__main__':
diff --git a/lib/Crypto/SelfTest/Random/test__UserFriendlyRNG.py b/lib/Crypto/SelfTest/Random/test__UserFriendlyRNG.py
new file mode 100644
index 00000000..771a6635
--- /dev/null
+++ b/lib/Crypto/SelfTest/Random/test__UserFriendlyRNG.py
@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+# Self-tests for the user-friendly Crypto.Random interface
+#
+# Written in 2013 by Dwayne C. Litzenberger <dlitz@dlitz.net>
+#
+# ===================================================================
+# The contents of this file are dedicated to the public domain.  To
+# the extent that dedication to the public domain is not available,
+# everyone is granted a worldwide, perpetual, royalty-free,
+# non-exclusive license to exercise all rights associated with the
+# contents of this file for any purpose whatsoever.
+# No rights are reserved.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+# ===================================================================
+
+"""Self-test suite for generic Crypto.Random stuff """
+
+from __future__ import nested_scopes
+
+__revision__ = "$Id$"
+
+import binascii
+import pprint
+import unittest
+import os
+import time
+import sys
+if sys.version_info[0] == 2 and sys.version_info[1] == 1:
+    from Crypto.Util.py21compat import *
+from Crypto.Util.py3compat import *
+
+try:
+    import multiprocessing
+except ImportError:
+    multiprocessing = None
+
+import Crypto.Random._UserFriendlyRNG
+import Crypto.Random.random
+
+class RNGForkTest(unittest.TestCase):
+
+    def _get_reseed_count(self):
+        """
+        Get `FortunaAccumulator.reseed_count`, the global count of the
+        number of times that the PRNG has been reseeded.
+        """
+        rng_singleton = Crypto.Random._UserFriendlyRNG._get_singleton()
+        rng_singleton._lock.acquire()
+        try:
+            return rng_singleton._fa.reseed_count
+        finally:
+            rng_singleton._lock.release()
+
+    def runTest(self):
+        # Regression test for CVE-2013-1445.  We had a bug where, under the
+        # right conditions, two processes might see the same random sequence.
+
+        if sys.platform.startswith('win'):  # windows can't fork
+            assert not hasattr(os, 'fork')    # ... right?
+            return
+
+        # Wait 150 ms so that we don't trigger the rate-limit prematurely.
+        time.sleep(0.15)
+
+        reseed_count_before = self._get_reseed_count()
+
+        # One or both of these calls together should trigger a reseed right here.
+        Crypto.Random._UserFriendlyRNG._get_singleton().reinit()
+        Crypto.Random.get_random_bytes(1)
+
+        reseed_count_after = self._get_reseed_count()
+        self.assertNotEqual(reseed_count_before, reseed_count_after)  # sanity check: test should reseed parent before forking
+
+        rfiles = []
+        for i in range(10):
+            rfd, wfd = os.pipe()
+            if os.fork() == 0:
+                # child
+                os.close(rfd)
+                f = os.fdopen(wfd, "wb")
+
+                Crypto.Random.atfork()
+
+                data = Crypto.Random.get_random_bytes(16)
+
+                f.write(data)
+                f.close()
+                os._exit(0)
+            # parent
+            os.close(wfd)
+            rfiles.append(os.fdopen(rfd, "rb"))
+
+        results = []
+        results_dict = {}
+        for f in rfiles:
+            data = binascii.hexlify(f.read())
+            results.append(data)
+            results_dict[data] = 1
+            f.close()
+
+        if len(results) != len(results_dict.keys()):
+            raise AssertionError("RNG output duplicated across fork():\n%s" %
+                                 (pprint.pformat(results)))
+
+
+# For RNGMultiprocessingForkTest
+def _task_main(q):
+    a = Crypto.Random.get_random_bytes(16)
+    time.sleep(0.1)     # wait 100 ms
+    b = Crypto.Random.get_random_bytes(16)
+    q.put(binascii.b2a_hex(a))
+    q.put(binascii.b2a_hex(b))
+    q.put(None)      # Wait for acknowledgment
+
+
+class RNGMultiprocessingForkTest(unittest.TestCase):
+
+    def runTest(self):
+        # Another regression test for CVE-2013-1445.  This is basically the
+        # same as RNGForkTest, but less compatible with old versions of Python,
+        # and a little easier to read.
+
+        n_procs = 5
+        manager = multiprocessing.Manager()
+        queues = [manager.Queue(1) for i in range(n_procs)]
+
+        # Reseed the pool
+        time.sleep(0.15)
+        Crypto.Random._UserFriendlyRNG._get_singleton().reinit()
+        Crypto.Random.get_random_bytes(1)
+
+        # Start the child processes
+        pool = multiprocessing.Pool(processes=n_procs, initializer=Crypto.Random.atfork)
+        map_result = pool.map_async(_task_main, queues)
+
+        # Get the results, ensuring that no pool processes are reused.
+        aa = [queues[i].get(30) for i in range(n_procs)]
+        bb = [queues[i].get(30) for i in range(n_procs)]
+        res = list(zip(aa, bb))
+
+        # Shut down the pool
+        map_result.get(30)
+        pool.close()
+        pool.join()
+
+        # Check that the results are unique
+        if len(set(aa)) != len(aa) or len(set(res)) != len(res):
+            raise AssertionError("RNG output duplicated across fork():\n%s" %
+                                 (pprint.pformat(res),))
+
+
+def get_tests(config={}):
+    tests = []
+    tests += [RNGForkTest()]
+    if multiprocessing is not None:
+        tests += [RNGMultiprocessingForkTest()]
+    return tests
+
+if __name__ == '__main__':
+    suite = lambda: unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')
+
+# vim:set ts=4 sw=4 sts=4 expandtab:",
"url": "https://github.com/dlitz/pycrypto/commit/19dcf7b15d61b7dc1a125a367151de40df6ef175.patch"
}
] | null |
GHSA-w799-rf9r-4rqc
| null |
[
{
"commit_message": "[PATCH] SECURITY: Fix DoS on overly long input from Postfix MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Thanks to Mateusz Jończyk who reported this issue and gave valuable feedback for its resolution. PostSRSd would hang on an overly long GET request, because the fread()/fwrite() logic in the subprocess would get confused by the remaining input line in its buffer. Theoretically, this error should never occur, as Postfix is supposed to send valid email addresses only, which are shorter than the buffer, even assuming every single character is percent-encoded. However, Postfix sometimes does seem to send malformed request with multiple concatenated email addresses. I'm not sure if there's a reliable way to trigger this condition by an external attacker, but it is a security bug in PostSRSd nevertheless. postsrsd.c | 56 ++++++++++++++++++++++++----------------- run_postsrsd_tests.bats | 40 ++++++++++++++++++++++++++--- 2 files changed, 69 insertions(+), 27 deletions(-)",
"patch_text_b64": "From 077be98d8c8a9847e4ae0c7dc09e7474cbe27db2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timo=20R=C3=B6hling?= <timo@gaussglocke.de>
Date: Sun, 21 Mar 2021 15:27:55 +0100
Subject: [PATCH] SECURITY: Fix DoS on overly long input from Postfix
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Thanks to Mateusz Jończyk who reported this issue and gave valuable
feedback for its resolution.

PostSRSd would hang on an overly long GET request, because the
fread()/fwrite() logic in the subprocess would get confused by the
remaining input line in its buffer.

Theoretically, this error should never occur, as Postfix is supposed to
send valid email addresses only, which are shorter than the buffer, even
assuming every single character is percent-encoded. However, Postfix
sometimes does seem to send malformed request with multiple concatenated
email addresses. I'm not sure if there's a reliable way to trigger this
condition by an external attacker, but it is a security bug in PostSRSd
nevertheless.
---
 postsrsd.c              | 56 ++++++++++++++++++++++++-----------------
 run_postsrsd_tests.bats | 40 ++++++++++++++++++++++++++---
 2 files changed, 69 insertions(+), 27 deletions(-)

diff --git a/postsrsd.c b/postsrsd.c
index 21276a9..a31b988 100644
--- a/postsrsd.c
+++ b/postsrsd.c
@@ -645,7 +645,7 @@ int main(int argc, char **argv)
     while (TRUE)
     {
         int conn;
-        FILE *fp;
+        FILE *fp_read, *fp_write;
         char linebuf[1024], *line;
         char keybuf[1024], *key;
 
@@ -674,47 +674,57 @@ int main(int argc, char **argv)
                      * daemon process from restarting */
                     for (i = 0; i < socket_count; ++i)
                         close(sockets[i]);
-
-                    fp = fdopen(conn, "r+");
-                    if (fp == NULL)
-                        exit(EXIT_FAILURE);
-                    fds[0].fd = conn;
-                    fds[0].events = POLLIN;
-                    if (poll(fds, 1, timeout * 1000) <= 0)
+                    /* create separate input/output streams */
+                    fp_read = fdopen(conn, "r");
+                    if (fp_read == NULL)
+                        return EXIT_FAILURE;
+                    fp_write = fdopen(dup(conn), "w");
+                    if (fp_write == NULL)
                         return EXIT_FAILURE;
-                    line = fgets(linebuf, sizeof(linebuf), fp);
-                    while (line)
+                    errno = 0;
+                    alarm(timeout);
+                    if (errno != 0)
+                        return EXIT_FAILURE;
+                    while ((line = fgets(linebuf, sizeof(linebuf), fp_read)))
                     {
-                        fseek(fp, 0, SEEK_CUR); /* Workaround for Solaris */
                         char *token;
+                        alarm(0);
+                        if (strlen(line) >= sizeof(linebuf) - 1)
+                        {
+                            fprintf(fp_write, "500 Invalid request\n");
+                            fflush(fp_write);
+                            return EXIT_FAILURE;
+                        }
                         token = strtok(line, " \r\n");
                         if (token == NULL || strcmp(token, "get") != 0)
                         {
-                            fprintf(fp, "500 Invalid request\n");
-                            fflush(fp);
+                            fprintf(fp_write, "500 Invalid request\n");
+                            fflush(fp_write);
                             return EXIT_FAILURE;
                         }
                         token = strtok(NULL, "\r\n");
                         if (!token)
                         {
-                            fprintf(fp, "500 Invalid request\n");
-                            fflush(fp);
+                            fprintf(fp_write, "500 Invalid request\n");
+                            fflush(fp_write);
                             return EXIT_FAILURE;
                         }
                         key = url_decode(keybuf, sizeof(keybuf), token);
                         if (!key)
                         {
-                            fprintf(fp, "500 Invalid request\n");
-                            fflush(fp);
+                            fprintf(fp_write, "500 Invalid request\n");
+                            fflush(fp_write);
                             return EXIT_FAILURE;
                         }
-                        handler[sc](srs, fp, key, domain, excludes);
-                        fflush(fp);
-                        if (poll(fds, 1, timeout * 1000) <= 0)
-                            break;
-                        line = fgets(linebuf, sizeof(linebuf), fp);
+                        handler[sc](srs, fp_write, key, domain, excludes);
+                        fflush(fp_write);
+                        errno = 0;
+                        alarm(timeout);
+                        if (errno != 0)
+                            return EXIT_FAILURE;
                     }
-                    fclose(fp);
+                    fclose(fp_write);
+                    fclose(fp_read);
                     return EXIT_SUCCESS;
                 }
                 close(conn);
diff --git a/run_postsrsd_tests.bats b/run_postsrsd_tests.bats
index f4b04bb..3d52a50 100755
--- a/run_postsrsd_tests.bats
+++ b/run_postsrsd_tests.bats
@@ -3,7 +3,7 @@
 
 if [ ! -x "$POSTSRSD" ]
 then
-	for builddir in . build* obj*
+	for builddir in . build* obj* _build*
 	do
 		if [ -x "${builddir}/postsrsd" ]
 		then
@@ -15,7 +15,7 @@ fi
 if [ ! -x "$POSTSRSD" ]
 then
 	cat>&2 <<- EOF
-	cannot find postsrsd executable (looked in ., build*, obj*)
+	cannot find postsrsd executable (looked in ., build*, obj*, _build*)
 	please build the executable first, or set the POSTSRSD
 	environment variable if it is in a different location.
 
@@ -26,12 +26,19 @@ fi
 LANG=C.UTF-8
 
 
+fillchar()
+{
+        local count="$1"
+        local char="$2"
+        eval 'printf "'"$char"'%.0s" {1..'"$count"'}'
+}
+
 start_postsrsd_at()
 {
 	echo 'tops3cr3t' > "$BATS_TMPDIR/postsrsd.secret"
 	local faketime="$1"
 	shift
-	faketime "${faketime}" ${POSTSRSD} -D -f 10001 -r 10002 -p "$BATS_TMPDIR/postsrsd.pid" -s "$BATS_TMPDIR/postsrsd.secret" -d example.com "$@"
+	faketime "${faketime}" ${POSTSRSD} -D -t1 -f 10001 -r 10002 -p "$BATS_TMPDIR/postsrsd.pid" -s "$BATS_TMPDIR/postsrsd.secret" -d example.com "$@"
 }
 
 stop_postsrsd()
@@ -159,7 +166,7 @@ teardown()
 	[[ "$line" =~ ^"500 Domain excluded" ]]
 }
 
-@test "SRS invalid requests" {
+@test "Malformed or invalid requests" {
 	start_postsrsd_at "2020-01-01 00:01:00 UTC"
 	exec 9<>/dev/tcp/127.0.0.1/10001
 	echo>&9 "get"
@@ -173,4 +180,29 @@ teardown()
 	echo>&9 "get encoding%error@otherdomain.com"
 	read<&9 line
 	[[ "$line" =~ ^500 ]]
+	exec 9<>/dev/tcp/127.0.0.1/10001
+	# Try to overflow the input buffer
+	echo>&9 "get too_long@`fillchar 1024 a`.com"
+	read<&9 line
+	[[ "$line" =~ ^500 ]]
+}
+
+@test "Pipelining multiple requests" {
+	start_postsrsd_at "2020-01-01 00:01:00 UTC"
+	exec 9<>/dev/tcp/127.0.0.1/10001
+	# Send two requests at once and see if PostSRSd answers both
+	echo>&9 -e "get test@domain1.com\nget test@domain2.com"
+	read<&9 line
+	[[ "$line" =~ ^200 ]]
+	read<&9 line
+	[[ "$line" =~ ^200 ]]
+}
+
+@test "Session timeout" {
+	start_postsrsd_at "2020-01-01 00:01:00 UTC"
+	exec 9<>/dev/tcp/127.0.0.1/10001
+	# Wait until PostSRSd disconnects due to inactivity
+	sleep 2
+	echo >&9 "get test@example.com"
+	! read <&9 line
 }",
"url": "https://github.com/roehling/postsrsd/commit/077be98d8c8a9847e4ae0c7dc09e7474cbe27db2.patch"
}
] | null |
|
CVE-2025-66405
|
Portkey.ai Gateway: Server-Side Request Forgery (SSRF) in Custom Host
|
Portkey.ai Gateway is a blazing fast AI Gateway with integrated guardrails. Prior to 1.14.0, the gateway determined the destination baseURL by prioritizing the value in the x-portkey-custom-host request header. The proxy route then appends the client-specified path to perform an external fetch. This can be maliciously used by users for SSRF attacks. This vulnerability is fixed in 1.14.0.
|
[
{
"commit_message": "[PATCH 1/7] fix: custom host validator to protect from ssrf attack src/middlewares/requestValidator/index.ts | 135 +++++++++++++++++++++- 1 file changed, 134 insertions(+), 1 deletion(-)",
"patch_text_b64": "From c171d83deccdc2c8b3ad15bdbc6072ddad8d9d88 Mon Sep 17 00:00:00 2001
From: sk-portkey <sai.t@portkey.ai>
Date: Tue, 7 Oct 2025 16:13:08 +0530
Subject: [PATCH 1/7] fix: custom host validator to protect from ssrf attack

---
 src/middlewares/requestValidator/index.ts | 135 +++++++++++++++++++++-
 1 file changed, 134 insertions(+), 1 deletion(-)

diff --git a/src/middlewares/requestValidator/index.ts b/src/middlewares/requestValidator/index.ts
index 7707c94d0..c08b79e8f 100644
--- a/src/middlewares/requestValidator/index.ts
+++ b/src/middlewares/requestValidator/index.ts
@@ -66,7 +66,7 @@ export const requestValidator = (c: Context, next: any) => {
   }
 
   const customHostHeader = requestHeaders[`x-${POWERED_BY}-custom-host`];
-  if (customHostHeader && customHostHeader.indexOf('api.portkey') > -1) {
+  if (customHostHeader && !isValidCustomHost(customHostHeader)) {
     return new Response(
       JSON.stringify({
         status: 'failure',
@@ -153,3 +153,136 @@ export const requestValidator = (c: Context, next: any) => {
   }
   return next();
 };
+
+function isValidCustomHost(customHost: string) {
+  try {
+    const value = customHost.trim().toLowerCase();
+
+    // Project-specific and obvious disallowed schemes/hosts
+    if (value.indexOf('api.portkey') > -1) return false;
+    if (value.startsWith('file://')) return false;
+    if (value.startsWith('data:')) return false;
+    if (value.startsWith('gopher:')) return false;
+
+    const url = new URL(customHost);
+    const protocol = url.protocol.toLowerCase();
+
+    // Allow only HTTP(S)
+    if (protocol !== 'http:' && protocol !== 'https:') return false;
+
+    // Disallow credentials and obfuscation
+    if (url.username || url.password) return false;
+    if (customHost.includes('@')) return false;
+
+    const host = url.hostname.toLowerCase();
+
+    // Lenient allowance for local development
+    const localAllow =
+      host === 'localhost' ||
+      host.endsWith('.localhost') ||
+      host === '127.0.0.1' ||
+      host === '::1' ||
+      host === 'host.docker.internal';
+    if (localAllow) {
+      // Still validate port range if provided
+      if (url.port) {
+        const p = parseInt(url.port, 10);
+        if (!(p > 0 && p <= 65535)) return false;
+      }
+      return true;
+    }
+
+    // Block obvious internal/unsafe hosts
+    if (
+      host === '0.0.0.0' ||
+      host === '169.254.169.254' // cloud metadata
+    ) {
+      return false;
+    }
+
+    // Block internal/special-use TLDs often used in SSRF attempts
+    const blockedTlds = [
+      '.local',
+      '.localdomain',
+      '.internal',
+      '.intranet',
+      '.lan',
+      '.home',
+      '.corp',
+      '.test',
+      '.invalid',
+      '.onion',
+    ];
+    if (blockedTlds.some((tld) => host.endsWith(tld))) return false;
+
+    // Block private/reserved IPs (IPv4)
+    if (isIPv4(host)) {
+      if (isPrivateIPv4(host) || isReservedIPv4(host)) return false;
+    }
+
+    // Block private/reserved IPv6 and IPv4-mapped IPv6
+    if (host.includes(':')) {
+      if (isLocalOrPrivateIPv6(host)) return false;
+      const mapped = host.match(/::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/i);
+      if (mapped) {
+        const ip4 = mapped[1];
+        if (isPrivateIPv4(ip4) || isReservedIPv4(ip4)) return false;
+      }
+    }
+
+    // Validate port if present
+    if (url.port) {
+      const p = parseInt(url.port, 10);
+      if (!(p > 0 && p <= 65535)) return false;
+    }
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isIPv4(ip: string): boolean {
+  const parts = ip.split('.');
+  if (parts.length !== 4) return false;
+  return parts.every(
+    (p) => /^\d{1,3}$/.test(p) && Number(p) >= 0 && Number(p) <= 255
+  );
+}
+
+function ipv4ToInt(ip: string): number {
+  const [a, b, c, d] = ip.split('.').map((n) => Number(n));
+  return ((a << 24) >>> 0) + (b << 16) + (c << 8) + d;
+}
+
+function inRange(ip: string, start: string, end: string): boolean {
+  const x = ipv4ToInt(ip);
+  return x >= ipv4ToInt(start) && x <= ipv4ToInt(end);
+}
+
+function isPrivateIPv4(ip: string): boolean {
+  return (
+    inRange(ip, '10.0.0.0', '10.255.255.255') || // 10/8
+    inRange(ip, '172.16.0.0', '172.31.255.255') || // 172.16/12
+    inRange(ip, '192.168.0.0', '192.168.255.255') // 192.168/16
+  );
+}
+
+function isReservedIPv4(ip: string): boolean {
+  return (
+    inRange(ip, '127.0.0.0', '127.255.255.255') || // loopback
+    inRange(ip, '169.254.0.0', '169.254.255.255') || // link-local
+    inRange(ip, '100.64.0.0', '100.127.255.255') || // CGNAT
+    inRange(ip, '0.0.0.0', '0.255.255.255') || // "this" network
+    inRange(ip, '224.0.0.0', '255.255.255.255') // multicast/reserved/broadcast
+  );
+}
+
+function isLocalOrPrivateIPv6(host: string): boolean {
+  const h = host.toLowerCase();
+  if (h === '::1' || h === '::') return true; // loopback/unspecified
+  if (h.startsWith('fc') || h.startsWith('fd')) return true; // fc00::/7 (ULA)
+  if (h.startsWith('fe80')) return true; // fe80::/10 (link-local)
+  if (h.startsWith('fec0')) return true; // fec0::/10 (site-local, deprecated)
+  return false;
+}

From 49f99f82f88d813e1dfcde5c4eb24e7dd2fb2652 Mon Sep 17 00:00:00 2001
From: sk-portkey <sai.t@portkey.ai>
Date: Tue, 4 Nov 2025 15:59:49 +0530
Subject: [PATCH 2/7] chore: fixes

---
 src/middlewares/requestValidator/index.ts | 159 +++++++++++++++++++---
 1 file changed, 142 insertions(+), 17 deletions(-)

diff --git a/src/middlewares/requestValidator/index.ts b/src/middlewares/requestValidator/index.ts
index c08b79e8f..9cabe3420 100644
--- a/src/middlewares/requestValidator/index.ts
+++ b/src/middlewares/requestValidator/index.ts
@@ -2,6 +2,22 @@ import { Context } from 'hono';
 import { CONTENT_TYPES, POWERED_BY, VALID_PROVIDERS } from '../../globals';
 import { configSchema } from './schema/config';
 
+// Parse allowed custom hosts from environment variable
+// Format: comma-separated list of domains/IPs (e.g., "localhost,127.0.0.1,example.com")
+const ALLOWED_CUSTOM_HOSTS = (() => {
+  const envVar = process.env.ALLOWED_CUSTOM_HOSTS;
+  if (!envVar) {
+    // Default allowed hosts for local development
+    return new Set(['localhost', '127.0.0.1', '::1', 'host.docker.internal']);
+  }
+  return new Set(
+    envVar
+      .split(',')
+      .map((h) => h.trim().toLowerCase())
+      .filter((h) => h.length > 0)
+  );
+})();
+
 export const requestValidator = (c: Context, next: any) => {
   const requestHeaders = Object.fromEntries(c.req.raw.headers);
 
@@ -158,11 +174,19 @@ function isValidCustomHost(customHost: string) {
   try {
     const value = customHost.trim().toLowerCase();
 
+    // Block empty or whitespace-only hosts
+    if (!value || value.length === 0) return false;
+
+    // Block URLs with control characters or excessive whitespace
+    if (/[\x00-\x1F\x7F]/.test(customHost)) return false;
+
     // Project-specific and obvious disallowed schemes/hosts
     if (value.indexOf('api.portkey') > -1) return false;
     if (value.startsWith('file://')) return false;
     if (value.startsWith('data:')) return false;
     if (value.startsWith('gopher:')) return false;
+    if (value.startsWith('ftp://')) return false;
+    if (value.startsWith('ftps://')) return false;
 
     const url = new URL(customHost);
     const protocol = url.protocol.toLowerCase();
@@ -176,14 +200,25 @@ function isValidCustomHost(customHost: string) {
 
     const host = url.hostname.toLowerCase();
 
-    // Lenient allowance for local development
-    const localAllow =
-      host === 'localhost' ||
-      host.endsWith('.localhost') ||
-      host === '127.0.0.1' ||
-      host === '::1' ||
-      host === 'host.docker.internal';
-    if (localAllow) {
+    // Block empty hostname
+    if (!host || host.length === 0) return false;
+
+    // Block URLs with encoded characters in hostname (potential bypass attempt)
+    if (host.includes('%')) return false;
+
+    // Block suspicious characters that might indicate injection attempts
+    if (/[\s<>{}|\\^`]/.test(host)) return false;
+
+    // Block trailing dots in hostname (can cause DNS rebinding issues)
+    if (host.endsWith('.')) return false;
+
+    // Check against configurable allowed hosts (for local development or trusted domains)
+    const isAllowedHost =
+      ALLOWED_CUSTOM_HOSTS.has(host) ||
+      // Allow subdomains of .localhost
+      (ALLOWED_CUSTOM_HOSTS.has('localhost') && host.endsWith('.localhost'));
+
+    if (isAllowedHost) {
       // Still validate port range if provided
       if (url.port) {
         const p = parseInt(url.port, 10);
@@ -192,11 +227,21 @@ function isValidCustomHost(customHost: string) {
       return true;
     }
 
-    // Block obvious internal/unsafe hosts
-    if (
-      host === '0.0.0.0' ||
-      host === '169.254.169.254' // cloud metadata
-    ) {
+    // Block obvious internal/unsafe hosts and cloud metadata endpoints
+    const blockedHosts = [
+      '0.0.0.0',
+      '169.254.169.254', // AWS, Azure, GCP metadata (IPv4)
+      'metadata.google.internal', // GCP metadata
+      'metadata', // Kubernetes metadata
+      'metadata.azure.com', // Azure instance metadata
+      'instance-data', // AWS instance metadata alt
+    ];
+    if (blockedHosts.includes(host)) {
+      return false;
+    }
+
+    // Block AWS IMDSv2 endpoint variations
+    if (host.startsWith('169.254.169.') || host.startsWith('fd00:ec2::')) {
       return false;
     }
 
@@ -212,14 +257,20 @@ function isValidCustomHost(customHost: string) {
       '.test',
       '.invalid',
       '.onion',
+      '.localhost', // Block nested localhost subdomains for non-exact matches
     ];
-    if (blockedTlds.some((tld) => host.endsWith(tld))) return false;
+    if (blockedTlds.some((tld) => host.endsWith(tld) && host !== 'localhost')) {
+      return false;
+    }
 
     // Block private/reserved IPs (IPv4)
     if (isIPv4(host)) {
       if (isPrivateIPv4(host) || isReservedIPv4(host)) return false;
     }
 
+    // Check for alternative IP representations (decimal, hex, octal)
+    if (isAlternativeIPRepresentation(host)) return false;
+
     // Block private/reserved IPv6 and IPv4-mapped IPv6
     if (host.includes(':')) {
       if (isLocalOrPrivateIPv6(host)) return false;
@@ -228,6 +279,12 @@ function isValidCustomHost(customHost: string) {
         const ip4 = mapped[1];
         if (isPrivateIPv4(ip4) || isReservedIPv4(ip4)) return false;
       }
+      // Also check for other IPv4-embedded IPv6 formats
+      const embeddedIPv4 = host.match(/::(\d{1,3}(?:\.\d{1,3}){3})$/i);
+      if (embeddedIPv4) {
+        const ip4 = embeddedIPv4[1];
+        if (isPrivateIPv4(ip4) || isReservedIPv4(ip4)) return false;
+      }
     }
 
     // Validate port if present
@@ -245,9 +302,21 @@ function isValidCustomHost(customHost: string) {
 function isIPv4(ip: string): boolean {
   const parts = ip.split('.');
   if (parts.length !== 4) return false;
-  return parts.every(
-    (p) => /^\d{1,3}$/.test(p) && Number(p) >= 0 && Number(p) <= 255
-  );
+  return parts.every((part) => {
+    // Must be 1-3 digits
+    if (!/^\d{1,3}$/.test(part)) return false;
+
+    const num = Number(part);
+
+    // Must be in range 0-255
+    if (num < 0 || num > 255) return false;
+
+    // Reject leading zeros (except for "0" itself)
+    // This prevents octal interpretation ambiguity
+    if (part.length > 1 && part.startsWith('0')) return false;
+
+    return true;
+  });
 }
 
 function ipv4ToInt(ip: string): number {
@@ -286,3 +355,59 @@ function isLocalOrPrivateIPv6(host: string): boolean {
   if (h.startsWith('fec0')) return true; // fec0::/10 (site-local, deprecated)
   return false;
 }
+
+function isAlternativeIPRepresentation(host: string): boolean {
+  // Check for decimal IP (e.g., 2130706433 for 127.0.0.1)
+  // Valid range: 0 to 4294967295 (2^32 - 1)
+  if (/^\d{1,10}$/.test(host)) {
+    const num = parseInt(host, 10);
+    if (num >= 0 && num <= 0xffffffff) {
+      // Convert to dotted decimal and check if it's private/reserved
+      const a = (num >>> 24) & 0xff;
+      const b = (num >>> 16) & 0xff;
+      const c = (num >>> 8) & 0xff;
+      const d = num & 0xff;
+      const ip = `${a}.${b}.${c}.${d}`;
+      // Block if it resolves to a private or reserved IP
+      if (isPrivateIPv4(ip) || isReservedIPv4(ip)) return true;
+      // Also block public IPs in decimal format to prevent confusion
+      return true;
+    }
+  }
+
+  // Check for hex IP (e.g., 0x7f000001 for 127.0.0.1)
+  if (/^0x[0-9a-f]{1,8}$/i.test(host)) {
+    const num = parseInt(host, 16);
+    if (num >= 0 && num <= 0xffffffff) {
+      const a = (num >>> 24) & 0xff;
+      const b = (num >>> 16) & 0xff;
+      const c = (num >>> 8) & 0xff;
+      const d = num & 0xff;
+      const ip = `${a}.${b}.${c}.${d}`;
+      return true; // Block all hex IPs
+    }
+  }
+
+  // Check for octal IP parts (e.g., 0177.0.0.1 for 127.0.0.1)
+  const parts = host.split('.');
+  if (parts.length === 4 && parts.some((p) => /^0\d+$/.test(p))) {
+    // Has octal notation - block it
+    return true;
+  }
+
+  // Check for mixed hex notation (e.g., 0x7f.0.0.1)
+  if (parts.length === 4 && parts.some((p) => /^0x[0-9a-f]+$/i.test(p))) {
+    // Has hex notation - block it
+    return true;
+  }
+
+  // Check for shortened IP formats (e.g., 127.1 -> 127.0.0.1)
+  if (parts.length >= 2 && parts.length < 4) {
+    if (parts.every((p) => /^\d+$/.test(p) && Number(p) <= 255)) {
+      // Looks like a shortened IP format - block it
+      return true;
+    }
+  }
+
+  return false;
+}

From c26e722d082edab71083ec33a9a06cb8f081779a Mon Sep 17 00:00:00 2001
From: sk-portkey <sai.t@portkey.ai>
Date: Tue, 4 Nov 2025 16:20:51 +0530
Subject: [PATCH 3/7] chore: use env for conditional env fetch

---
 src/middlewares/requestValidator/index.ts | 20 +++++++++++---------
 src/utils/env.ts                          |  4 ++++
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/src/middlewares/requestValidator/index.ts b/src/middlewares/requestValidator/index.ts
index 9cabe3420..14115c40e 100644
--- a/src/middlewares/requestValidator/index.ts
+++ b/src/middlewares/requestValidator/index.ts
@@ -1,11 +1,12 @@
 import { Context } from 'hono';
 import { CONTENT_TYPES, POWERED_BY, VALID_PROVIDERS } from '../../globals';
 import { configSchema } from './schema/config';
+import { Environment } from '../../utils/env';
 
 // Parse allowed custom hosts from environment variable
 // Format: comma-separated list of domains/IPs (e.g., "localhost,127.0.0.1,example.com")
-const ALLOWED_CUSTOM_HOSTS = (() => {
-  const envVar = process.env.ALLOWED_CUSTOM_HOSTS;
+const ALLOWED_CUSTOM_HOSTS = (c: Context) => {
+  const envVar = Environment(c)?.ALLOWED_CUSTOM_HOSTS;
   if (!envVar) {
     // Default allowed hosts for local development
     return new Set(['localhost', '127.0.0.1', '::1', 'host.docker.internal']);
@@ -13,10 +14,10 @@ const ALLOWED_CUSTOM_HOSTS = (() => {
   return new Set(
     envVar
       .split(',')
-      .map((h) => h.trim().toLowerCase())
-      .filter((h) => h.length > 0)
+      .map((h: string) => h.trim().toLowerCase())
+      .filter((h: string) => h.length > 0)
   );
-})();
+};
 
 export const requestValidator = (c: Context, next: any) => {
   const requestHeaders = Object.fromEntries(c.req.raw.headers);
@@ -82,7 +83,7 @@ export const requestValidator = (c: Context, next: any) => {
   }
 
   const customHostHeader = requestHeaders[`x-${POWERED_BY}-custom-host`];
-  if (customHostHeader && !isValidCustomHost(customHostHeader)) {
+  if (customHostHeader && !isValidCustomHost(c, customHostHeader)) {
     return new Response(
       JSON.stringify({
         status: 'failure',
@@ -170,7 +171,7 @@ export const requestValidator = (c: Context, next: any) => {
   return next();
 };
 
-function isValidCustomHost(customHost: string) {
+function isValidCustomHost(c: Context, customHost: string) {
   try {
     const value = customHost.trim().toLowerCase();
 
@@ -212,11 +213,12 @@ function isValidCustomHost(customHost: string) {
     // Block trailing dots in hostname (can cause DNS rebinding issues)
     if (host.endsWith('.')) return false;
 
+    const allowedHosts = ALLOWED_CUSTOM_HOSTS(c);
     // Check against configurable allowed hosts (for local development or trusted domains)
     const isAllowedHost =
-      ALLOWED_CUSTOM_HOSTS.has(host) ||
+      allowedHosts.has(host) ||
       // Allow subdomains of .localhost
-      (ALLOWED_CUSTOM_HOSTS.has('localhost') && host.endsWith('.localhost'));
+      (allowedHosts.has('localhost') && host.endsWith('.localhost'));
 
     if (isAllowedHost) {
       // Still validate port range if provided
diff --git a/src/utils/env.ts b/src/utils/env.ts
index a2b082cd2..7784ec766 100644
--- a/src/utils/env.ts
+++ b/src/utils/env.ts
@@ -119,6 +119,10 @@ const nodeEnv = {
 
   HTTP_PROXY: getValueOrFileContents(process.env.HTTP_PROXY),
   HTTPS_PROXY: getValueOrFileContents(process.env.HTTPS_PROXY),
+
+  ALLOWED_CUSTOM_HOSTS: getValueOrFileContents(
+    process.env.ALLOWED_CUSTOM_HOSTS
+  ),
 };
 
 export const Environment = (c?: Context) => {

From cc0f76de7432e8bd99182c28671020c9d94d7767 Mon Sep 17 00:00:00 2001
From: sk-portkey <sai.t@portkey.ai>
Date: Tue, 4 Nov 2025 16:49:31 +0530
Subject: [PATCH 4/7] chore: semantic name update

---
 src/middlewares/requestValidator/index.ts | 14 +++++++-------
 src/utils/env.ts                          |  4 ++--
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/middlewares/requestValidator/index.ts b/src/middlewares/requestValidator/index.ts
index 14115c40e..0a8da3a7e 100644
--- a/src/middlewares/requestValidator/index.ts
+++ b/src/middlewares/requestValidator/index.ts
@@ -5,8 +5,8 @@ import { Environment } from '../../utils/env';
 
 // Parse allowed custom hosts from environment variable
 // Format: comma-separated list of domains/IPs (e.g., "localhost,127.0.0.1,example.com")
-const ALLOWED_CUSTOM_HOSTS = (c: Context) => {
-  const envVar = Environment(c)?.ALLOWED_CUSTOM_HOSTS;
+const TRUSTED_CUSTOM_HOSTS = (c: Context) => {
+  const envVar = Environment(c)?.TRUSTED_CUSTOM_HOSTS;
   if (!envVar) {
     // Default allowed hosts for local development
     return new Set(['localhost', '127.0.0.1', '::1', 'host.docker.internal']);
@@ -213,14 +213,14 @@ function isValidCustomHost(c: Context, customHost: string) {
     // Block trailing dots in hostname (can cause DNS rebinding issues)
     if (host.endsWith('.')) return false;
 
-    const allowedHosts = ALLOWED_CUSTOM_HOSTS(c);
+    const trustedHosts = TRUSTED_CUSTOM_HOSTS(c);
     // Check against configurable allowed hosts (for local development or trusted domains)
-    const isAllowedHost =
-      allowedHosts.has(host) ||
+    const isTrustedHost =
+      trustedHosts.has(host) ||
       // Allow subdomains of .localhost
-      (allowedHosts.has('localhost') && host.endsWith('.localhost'));
+      (trustedHosts.has('localhost') && host.endsWith('.localhost'));
 
-    if (isAllowedHost) {
+    if (isTrustedHost) {
       // Still validate port range if provided
       if (url.port) {
         const p = parseInt(url.port, 10);
diff --git a/src/utils/env.ts b/src/utils/env.ts
index 7784ec766..021c0d2da 100644
--- a/src/utils/env.ts
+++ b/src/utils/env.ts
@@ -120,8 +120,8 @@ const nodeEnv = {
   HTTP_PROXY: getValueOrFileContents(process.env.HTTP_PROXY),
   HTTPS_PROXY: getValueOrFileContents(process.env.HTTPS_PROXY),
 
-  ALLOWED_CUSTOM_HOSTS: getValueOrFileContents(
-    process.env.ALLOWED_CUSTOM_HOSTS
+  TRUSTED_CUSTOM_HOSTS: getValueOrFileContents(
+    process.env.TRUSTED_CUSTOM_HOSTS
   ),
 };
 

From caee0ef59a4f5098a3759bf7d8326e3e5a50dc2b Mon Sep 17 00:00:00 2001
From: sk-portkey <sai.t@portkey.ai>
Date: Tue, 4 Nov 2025 17:52:59 +0530
Subject: [PATCH 5/7] chore: code optimisations

---
 src/middlewares/requestValidator/index.ts | 244 ++++++++++++----------
 1 file changed, 139 insertions(+), 105 deletions(-)

diff --git a/src/middlewares/requestValidator/index.ts b/src/middlewares/requestValidator/index.ts
index 0a8da3a7e..c38e821ba 100644
--- a/src/middlewares/requestValidator/index.ts
+++ b/src/middlewares/requestValidator/index.ts
@@ -3,6 +3,48 @@ import { CONTENT_TYPES, POWERED_BY, VALID_PROVIDERS } from '../../globals';
 import { configSchema } from './schema/config';
 import { Environment } from '../../utils/env';
 
+// Regex patterns for validation (defined once for reusability)
+const VALIDATION_PATTERNS = {
+  CONTROL_CHARS: /[\x00-\x1F\x7F]/,
+  SUSPICIOUS_CHARS: /[\s<>{}|\\^`]/,
+  DIGITS_1_3: /^\d{1,3}$/,
+  DIGITS_1_10: /^\d{1,10}$/,
+  DIGITS_ONLY: /^\d+$/,
+  HEX_IP: /^0x[0-9a-f]{1,8}$/i,
+  ALTERNATIVE_IP_PART: /^0[0-9a-fx]/i, // Starts with 0 followed by digits or x (octal or hex)
+  IPV6_MAPPED_IPV4: /::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/i,
+  IPV6_EMBEDDED_IPV4: /::(\d{1,3}(?:\.\d{1,3}){3})$/i,
+  HOMOGRAPH_ATTACK: /^[a-z0-9.-]+$/,
+};
+
+// Disallowed URL schemes
+const DISALLOWED_SCHEMES = ['file://', 'data:', 'gopher:', 'ftp://', 'ftps://'];
+
+// Blocked hosts (cloud metadata endpoints and internal IPs)
+const BLOCKED_HOSTS = [
+  '0.0.0.0',
+  '169.254.169.254', // AWS, Azure, GCP metadata (IPv4)
+  'metadata.google.internal', // GCP metadata
+  'metadata', // Kubernetes metadata
+  'metadata.azure.com', // Azure instance metadata
+  'instance-data', // AWS instance metadata alt
+];
+
+// Blocked TLDs for SSRF protection
+const BLOCKED_TLDS = [
+  '.local',
+  '.localdomain',
+  '.internal',
+  '.intranet',
+  '.lan',
+  '.home',
+  '.corp',
+  '.test',
+  '.invalid',
+  '.onion',
+  '.localhost',
+];
+
 // Parse allowed custom hosts from environment variable
 // Format: comma-separated list of domains/IPs (e.g., "localhost,127.0.0.1,example.com")
 const TRUSTED_CUSTOM_HOSTS = (c: Context) => {
@@ -19,6 +61,22 @@ const TRUSTED_CUSTOM_HOSTS = (c: Context) => {
   );
 };
 
+// Pre-computed IPv4 range boundaries for performance optimization
+const IPV4_RANGES = {
+  PRIVATE: [
+    { start: ipv4ToInt('10.0.0.0'), end: ipv4ToInt('10.255.255.255') }, // 10/8
+    { start: ipv4ToInt('172.16.0.0'), end: ipv4ToInt('172.31.255.255') }, // 172.16/12
+    { start: ipv4ToInt('192.168.0.0'), end: ipv4ToInt('192.168.255.255') }, // 192.168/16
+  ],
+  RESERVED: [
+    { start: ipv4ToInt('127.0.0.0'), end: ipv4ToInt('127.255.255.255') }, // loopback
+    { start: ipv4ToInt('169.254.0.0'), end: ipv4ToInt('169.254.255.255') }, // link-local
+    { start: ipv4ToInt('100.64.0.0'), end: ipv4ToInt('100.127.255.255') }, // CGNAT
+    { start: ipv4ToInt('0.0.0.0'), end: ipv4ToInt('0.255.255.255') }, // "this" network
+    { start: ipv4ToInt('224.0.0.0'), end: ipv4ToInt('255.255.255.255') }, // multicast/reserved/broadcast
+  ],
+};
+
 export const requestValidator = (c: Context, next: any) => {
   const requestHeaders = Object.fromEntries(c.req.raw.headers);
 
@@ -170,27 +228,23 @@ export const requestValidator = (c: Context, next: any) => {
   }
   return next();
 };
-
 function isValidCustomHost(c: Context, customHost: string) {
   try {
     const value = customHost.trim().toLowerCase();
 
     // Block empty or whitespace-only hosts
-    if (!value || value.length === 0) return false;
+    if (!value) return false;
 
     // Block URLs with control characters or excessive whitespace
-    if (/[\x00-\x1F\x7F]/.test(customHost)) return false;
+    if (VALIDATION_PATTERNS.CONTROL_CHARS.test(customHost)) return false;
 
     // Project-specific and obvious disallowed schemes/hosts
     if (value.indexOf('api.portkey') > -1) return false;
-    if (value.startsWith('file://')) return false;
-    if (value.startsWith('data:')) return false;
-    if (value.startsWith('gopher:')) return false;
-    if (value.startsWith('ftp://')) return false;
-    if (value.startsWith('ftps://')) return false;
+    if (DISALLOWED_SCHEMES.some((scheme) => value.startsWith(scheme)))
+      return false;
 
     const url = new URL(customHost);
-    const protocol = url.protocol.toLowerCase();
+    const protocol = url.protocol;
 
     // Allow only HTTP(S)
     if (protocol !== 'http:' && protocol !== 'https:') return false;
@@ -199,20 +253,31 @@ function isValidCustomHost(c: Context, customHost: string) {
     if (url.username || url.password) return false;
     if (customHost.includes('@')) return false;
 
-    const host = url.hostname.toLowerCase();
+    const host = url.hostname;
 
     // Block empty hostname
-    if (!host || host.length === 0) return false;
+    if (!host) return false;
 
     // Block URLs with encoded characters in hostname (potential bypass attempt)
     if (host.includes('%')) return false;
 
     // Block suspicious characters that might indicate injection attempts
-    if (/[\s<>{}|\\^`]/.test(host)) return false;
+    if (VALIDATION_PATTERNS.SUSPICIOUS_CHARS.test(host)) return false;
+
+    // Block non-ASCII characters in hostname (homograph attack protection)
+    // Prevents Unicode lookalike characters from spoofing legitimate domains
+    if (!VALIDATION_PATTERNS.HOMOGRAPH_ATTACK.test(host)) return false;
 
     // Block trailing dots in hostname (can cause DNS rebinding issues)
     if (host.endsWith('.')) return false;
 
+    // Split hostname once for reuse in multiple checks
+    const hostParts = host.split('.');
+
+    // Block excessive subdomain depth (potential DNS rebinding attack)
+    // Limits the number of labels to prevent abuse
+    if (hostParts.length > 10) return false;
+
     const trustedHosts = TRUSTED_CUSTOM_HOSTS(c);
     // Check against configurable allowed hosts (for local development or trusted domains)
     const isTrustedHost =
@@ -222,25 +287,12 @@ function isValidCustomHost(c: Context, customHost: string) {
 
     if (isTrustedHost) {
       // Still validate port range if provided
-      if (url.port) {
-        const p = parseInt(url.port, 10);
-        if (!(p > 0 && p <= 65535)) return false;
-      }
+      if (url.port && !isValidPort(url.port)) return false;
       return true;
     }
 
     // Block obvious internal/unsafe hosts and cloud metadata endpoints
-    const blockedHosts = [
-      '0.0.0.0',
-      '169.254.169.254', // AWS, Azure, GCP metadata (IPv4)
-      'metadata.google.internal', // GCP metadata
-      'metadata', // Kubernetes metadata
-      'metadata.azure.com', // Azure instance metadata
-      'instance-data', // AWS instance metadata alt
-    ];
-    if (blockedHosts.includes(host)) {
-      return false;
-    }
+    if (BLOCKED_HOSTS.includes(host as any)) return false;
 
     // Block AWS IMDSv2 endpoint variations
     if (host.startsWith('169.254.169.') || host.startsWith('fd00:ec2::')) {
@@ -248,52 +300,37 @@ function isValidCustomHost(c: Context, customHost: string) {
     }
 
     // Block internal/special-use TLDs often used in SSRF attempts
-    const blockedTlds = [
-      '.local',
-      '.localdomain',
-      '.internal',
-      '.intranet',
-      '.lan',
-      '.home',
-      '.corp',
-      '.test',
-      '.invalid',
-      '.onion',
-      '.localhost', // Block nested localhost subdomains for non-exact matches
-    ];
-    if (blockedTlds.some((tld) => host.endsWith(tld) && host !== 'localhost')) {
+    if (
+      BLOCKED_TLDS.some((tld) => host.endsWith(tld) && host !== 'localhost')
+    ) {
       return false;
     }
 
     // Block private/reserved IPs (IPv4)
-    if (isIPv4(host)) {
-      if (isPrivateIPv4(host) || isReservedIPv4(host)) return false;
+    if (isIPv4(hostParts) && (isPrivateIPv4(host) || isReservedIPv4(host))) {
+      return false;
     }
 
     // Check for alternative IP representations (decimal, hex, octal)
-    if (isAlternativeIPRepresentation(host)) return false;
+    if (isAlternativeIPRepresentation(host, hostParts)) return false;
 
     // Block private/reserved IPv6 and IPv4-mapped IPv6
     if (host.includes(':')) {
       if (isLocalOrPrivateIPv6(host)) return false;
-      const mapped = host.match(/::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/i);
-      if (mapped) {
-        const ip4 = mapped[1];
-        if (isPrivateIPv4(ip4) || isReservedIPv4(ip4)) return false;
-      }
-      // Also check for other IPv4-embedded IPv6 formats
-      const embeddedIPv4 = host.match(/::(\d{1,3}(?:\.\d{1,3}){3})$/i);
-      if (embeddedIPv4) {
-        const ip4 = embeddedIPv4[1];
+
+      // Check both IPv6-mapped and embedded IPv4 patterns
+      const ipv4Match =
+        host.match(VALIDATION_PATTERNS.IPV6_MAPPED_IPV4) ||
+        host.match(VALIDATION_PATTERNS.IPV6_EMBEDDED_IPV4);
+
+      if (ipv4Match) {
+        const ip4 = ipv4Match[1];
         if (isPrivateIPv4(ip4) || isReservedIPv4(ip4)) return false;
       }
     }
 
     // Validate port if present
-    if (url.port) {
-      const p = parseInt(url.port, 10);
-      if (!(p > 0 && p <= 65535)) return false;
-    }
+    if (url.port && !isValidPort(url.port)) return false;
 
     return true;
   } catch {
@@ -301,12 +338,32 @@ function isValidCustomHost(c: Context, customHost: string) {
   }
 }
 
-function isIPv4(ip: string): boolean {
-  const parts = ip.split('.');
+// Helper function to convert integer to IPv4 dotted decimal notation
+function intToIPv4(num: number): string {
+  const a = (num >>> 24) & 0xff;
+  const b = (num >>> 16) & 0xff;
+  const c = (num >>> 8) & 0xff;
+  const d = num & 0xff;
+  return `${a}.${b}.${c}.${d}`;
+}
+
+// Helper function to convert IPv4 dotted decimal to integer
+function ipv4ToInt(ip: string): number {
+  const [a, b, c, d] = ip.split('.').map((n) => Number(n));
+  return ((a << 24) >>> 0) + (b << 16) + (c << 8) + d;
+}
+
+// Helper function to validate port numbers
+function isValidPort(port: string): boolean {
+  const p = parseInt(port, 10);
+  return p > 0 && p <= 65535;
+}
+
+function isIPv4(parts: string[]): boolean {
   if (parts.length !== 4) return false;
   return parts.every((part) => {
     // Must be 1-3 digits
-    if (!/^\d{1,3}$/.test(part)) return false;
+    if (!VALIDATION_PATTERNS.DIGITS_1_3.test(part)) return false;
 
     const num = Number(part);
 
@@ -321,31 +378,17 @@ function isIPv4(ip: string): boolean {
   });
 }
 
-function ipv4ToInt(ip: string): number {
-  const [a, b, c, d] = ip.split('.').map((n) => Number(n));
-  return ((a << 24) >>> 0) + (b << 16) + (c << 8) + d;
-}
-
-function inRange(ip: string, start: string, end: string): boolean {
-  const x = ipv4ToInt(ip);
-  return x >= ipv4ToInt(start) && x <= ipv4ToInt(end);
-}
-
 function isPrivateIPv4(ip: string): boolean {
-  return (
-    inRange(ip, '10.0.0.0', '10.255.255.255') || // 10/8
-    inRange(ip, '172.16.0.0', '172.31.255.255') || // 172.16/12
-    inRange(ip, '192.168.0.0', '192.168.255.255') // 192.168/16
+  const ipInt = ipv4ToInt(ip);
+  return IPV4_RANGES.PRIVATE.some(
+    (range) => ipInt >= range.start && ipInt <= range.end
   );
 }
 
 function isReservedIPv4(ip: string): boolean {
-  return (
-    inRange(ip, '127.0.0.0', '127.255.255.255') || // loopback
-    inRange(ip, '169.254.0.0', '169.254.255.255') || // link-local
-    inRange(ip, '100.64.0.0', '100.127.255.255') || // CGNAT
-    inRange(ip, '0.0.0.0', '0.255.255.255') || // "this" network
-    inRange(ip, '224.0.0.0', '255.255.255.255') // multicast/reserved/broadcast
+  const ipInt = ipv4ToInt(ip);
+  return IPV4_RANGES.RESERVED.some(
+    (range) => ipInt >= range.start && ipInt <= range.end
   );
 }
 
@@ -358,18 +401,14 @@ function isLocalOrPrivateIPv6(host: string): boolean {
   return false;
 }
 
-function isAlternativeIPRepresentation(host: string): boolean {
+function isAlternativeIPRepresentation(host: string, parts: string[]): boolean {
   // Check for decimal IP (e.g., 2130706433 for 127.0.0.1)
   // Valid range: 0 to 4294967295 (2^32 - 1)
-  if (/^\d{1,10}$/.test(host)) {
+  if (VALIDATION_PATTERNS.DIGITS_1_10.test(host)) {
     const num = parseInt(host, 10);
     if (num >= 0 && num <= 0xffffffff) {
       // Convert to dotted decimal and check if it's private/reserved
-      const a = (num >>> 24) & 0xff;
-      const b = (num >>> 16) & 0xff;
-      const c = (num >>> 8) & 0xff;
-      const d = num & 0xff;
-      const ip = `${a}.${b}.${c}.${d}`;
+      const ip = intToIPv4(num);
       // Block if it resolves to a private or reserved IP
       if (isPrivateIPv4(ip) || isReservedIPv4(ip)) return true;
       // Also block public IPs in decimal format to prevent confusion
@@ -378,34 +417,29 @@ function isAlternativeIPRepresentation(host: string): boolean {
   }
 
   // Check for hex IP (e.g., 0x7f000001 for 127.0.0.1)
-  if (/^0x[0-9a-f]{1,8}$/i.test(host)) {
+  if (VALIDATION_PATTERNS.HEX_IP.test(host)) {
     const num = parseInt(host, 16);
     if (num >= 0 && num <= 0xffffffff) {
-      const a = (num >>> 24) & 0xff;
-      const b = (num >>> 16) & 0xff;
-      const c = (num >>> 8) & 0xff;
-      const d = num & 0xff;
-      const ip = `${a}.${b}.${c}.${d}`;
-      return true; // Block all hex IPs
+      return true; // Block all hex IPs (no need to convert)
     }
   }
 
-  // Check for octal IP parts (e.g., 0177.0.0.1 for 127.0.0.1)
-  const parts = host.split('.');
-  if (parts.length === 4 && parts.some((p) => /^0\d+$/.test(p))) {
-    // Has octal notation - block it
-    return true;
-  }
-
-  // Check for mixed hex notation (e.g., 0x7f.0.0.1)
-  if (parts.length === 4 && parts.some((p) => /^0x[0-9a-f]+$/i.test(p))) {
-    // Has hex notation - block it
+  // Check for octal or hex notation in any part (e.g., 0177.0.0.1 or 0x7f.0.0.1)
+  if (
+    parts.length === 4 &&
+    parts.some((p) => VALIDATION_PATTERNS.ALTERNATIVE_IP_PART.test(p))
+  ) {
+    // Has octal or hex notation - block it
     return true;
   }
 
   // Check for shortened IP formats (e.g., 127.1 -> 127.0.0.1)
   if (parts.length >= 2 && parts.length < 4) {
-    if (parts.every((p) => /^\d+$/.test(p) && Number(p) <= 255)) {
+    if (
+      parts.every(
+        (p) => VALIDATION_PATTERNS.DIGITS_ONLY.test(p) && Number(p) <= 255
+      )
+    ) {
       // Looks like a shortened IP format - block it
       return true;
     }

From 5688b5b797a8d8c436312b6fe5f34fc306d7bd74 Mon Sep 17 00:00:00 2001
From: sk-portkey <sai.t@portkey.ai>
Date: Fri, 7 Nov 2025 12:27:35 +0530
Subject: [PATCH 6/7] chore: validate custom at multiple places

---
 src/handlers/services/providerContext.ts          | 5 +++++
 src/middlewares/requestValidator/index.ts         | 5 +++--
 src/middlewares/requestValidator/schema/config.ts | 3 ++-
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/handlers/services/providerContext.ts b/src/handlers/services/providerContext.ts
index 7fec4f428..b21a3b0a6 100644
--- a/src/handlers/services/providerContext.ts
+++ b/src/handlers/services/providerContext.ts
@@ -9,6 +9,7 @@ import Providers from '../../providers';
 import { RequestContext } from './requestContext';
 import { ANTHROPIC, AZURE_OPEN_AI } from '../../globals';
 import { GatewayError } from '../../errors/GatewayError';
+import { isValidCustomHost } from '../../middlewares/requestValidator';
 
 export class ProviderContext {
   constructor(private provider: string) {
@@ -94,6 +95,10 @@ export class ProviderContext {
   }
 
   async getFullURL(context: RequestContext): Promise<string> {
+    const customHost = context.customHost;
+    if (customHost && !isValidCustomHost(customHost, context.honoContext)) {
+      throw new GatewayError('Invalid custom host');
+    }
     const baseURL = context.customHost || (await this.getBaseURL(context));
     let url: string;
     if (context.endpoint === 'proxy') {
diff --git a/src/middlewares/requestValidator/index.ts b/src/middlewares/requestValidator/index.ts
index c38e821ba..991561e02 100644
--- a/src/middlewares/requestValidator/index.ts
+++ b/src/middlewares/requestValidator/index.ts
@@ -141,7 +141,7 @@ export const requestValidator = (c: Context, next: any) => {
   }
 
   const customHostHeader = requestHeaders[`x-${POWERED_BY}-custom-host`];
-  if (customHostHeader && !isValidCustomHost(c, customHostHeader)) {
+  if (customHostHeader && !isValidCustomHost(customHostHeader, c)) {
     return new Response(
       JSON.stringify({
         status: 'failure',
@@ -228,7 +228,8 @@ export const requestValidator = (c: Context, next: any) => {
   }
   return next();
 };
-function isValidCustomHost(c: Context, customHost: string) {
+
+export function isValidCustomHost(customHost: string, c?: Context) {
   try {
     const value = customHost.trim().toLowerCase();
 
diff --git a/src/middlewares/requestValidator/schema/config.ts b/src/middlewares/requestValidator/schema/config.ts
index 1e46fb4e9..e217408cb 100644
--- a/src/middlewares/requestValidator/schema/config.ts
+++ b/src/middlewares/requestValidator/schema/config.ts
@@ -5,6 +5,7 @@ import {
   GOOGLE_VERTEX_AI,
   TRITON,
 } from '../../../globals';
+import { isValidCustomHost } from '..';
 
 export const configSchema: any = z
   .object({
@@ -149,7 +150,7 @@ export const configSchema: any = z
   .refine(
     (value) => {
       const customHost = value.custom_host;
-      if (customHost && customHost.indexOf('api.portkey') > -1) {
+      if (customHost && !isValidCustomHost(customHost)) {
         return false;
       }
       return true;

From c3e1171fa68a6a2c333f8c8ab4c71d05eb2793bd Mon Sep 17 00:00:00 2001
From: sk-portkey <sai.t@portkey.ai>
Date: Fri, 7 Nov 2025 12:39:01 +0530
Subject: [PATCH 7/7] chore: remove redundant validation from request context

---
 src/handlers/services/providerContext.ts | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/handlers/services/providerContext.ts b/src/handlers/services/providerContext.ts
index b21a3b0a6..7fec4f428 100644
--- a/src/handlers/services/providerContext.ts
+++ b/src/handlers/services/providerContext.ts
@@ -9,7 +9,6 @@ import Providers from '../../providers';
 import { RequestContext } from './requestContext';
 import { ANTHROPIC, AZURE_OPEN_AI } from '../../globals';
 import { GatewayError } from '../../errors/GatewayError';
-import { isValidCustomHost } from '../../middlewares/requestValidator';
 
 export class ProviderContext {
   constructor(private provider: string) {
@@ -95,10 +94,6 @@ export class ProviderContext {
   }
 
   async getFullURL(context: RequestContext): Promise<string> {
-    const customHost = context.customHost;
-    if (customHost && !isValidCustomHost(customHost, context.honoContext)) {
-      throw new GatewayError('Invalid custom host');
-    }
     const baseURL = context.customHost || (await this.getBaseURL(context));
     let url: string;
     if (context.endpoint === 'proxy') {",
"url": "https://github.com/Portkey-AI/gateway/commit/b5a7825ba5f4e6918deb32d9969899ce2229a885.patch"
}
] |
CWE-918: Server-Side Request Forgery (SSRF)
|
GHSA-mw67-65x5-h28p
| null |
[
{
"commit_message": "[PATCH] ksmbd: check nt_len to be at least CIFS_ENCPWD_SIZE in ksmbd_decode_ntlmssp_auth_blob MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit \"nt_len - CIFS_ENCPWD_SIZE\" is passed directly from ksmbd_decode_ntlmssp_auth_blob to ksmbd_auth_ntlmv2. Malicious requests can set nt_len to less than CIFS_ENCPWD_SIZE, which results in a negative number (or large unsigned value) used for a subsequent memcpy in ksmbd_auth_ntlvm2 and can cause a panic. Fixes: e2f3448 (\"cifsd: add server-side procedures for SMB3\") Cc: stable@vger.kernel.org Signed-off-by: William Liu <will@willsroot.io> Signed-off-by: Hrvoje Mišetić <misetichrvoje@gmail.com> Signed-off-by: Namjae Jeon <linkinjeon@kernel.org> auth.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA4ODI0YjdhZjQwOWY1MWYxMzE2ZTkyZTk4ODdjMmZkNDhjMGIyNmQ2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBXaWxsaWFtIExpdSA8d2lsbEB3aWxsc3Jvb3QuaW8+CkRhdGU6IEZyaSwgMzAgRGVjIDIwMjIgMDk6MTM6MzUgKzA5MDAKU3ViamVjdDogW1BBVENIXSBrc21iZDogY2hlY2sgbnRfbGVuIHRvIGJlIGF0IGxlYXN0IENJRlNfRU5DUFdEX1NJWkUgaW4KIGtzbWJkX2RlY29kZV9udGxtc3NwX2F1dGhfYmxvYgpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAoKIm50X2xlbiAtIENJRlNfRU5DUFdEX1NJWkUiIGlzIHBhc3NlZCBkaXJlY3RseSBmcm9tCmtzbWJkX2RlY29kZV9udGxtc3NwX2F1dGhfYmxvYiB0byBrc21iZF9hdXRoX250bG12Mi4gTWFsaWNpb3VzIHJlcXVlc3RzCmNhbiBzZXQgbnRfbGVuIHRvIGxlc3MgdGhhbiBDSUZTX0VOQ1BXRF9TSVpFLCB3aGljaCByZXN1bHRzIGluIGEgbmVnYXRpdmUKbnVtYmVyIChvciBsYXJnZSB1bnNpZ25lZCB2YWx1ZSkgdXNlZCBmb3IgYSBzdWJzZXF1ZW50IG1lbWNweSBpbgprc21iZF9hdXRoX250bHZtMiBhbmQgY2FuIGNhdXNlIGEgcGFuaWMuCgpGaXhlczogZTJmMzQ0OCAoImNpZnNkOiBhZGQgc2VydmVyLXNpZGUgcHJvY2VkdXJlcyBmb3IgU01CMyIpCkNjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnClNpZ25lZC1vZmYtYnk6IFdpbGxpYW0gTGl1IDx3aWxsQHdpbGxzcm9vdC5pbz4KU2lnbmVkLW9mZi1ieTogSHJ2b2plIE1pxaFldGnEhyA8bWlzZXRpY2hydm9qZUBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IE5hbWphZSBKZW9uIDxsaW5raW5qZW9uQGtlcm5lbC5vcmc+Ci0tLQogYXV0aC5jIHwgMyArKy0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9hdXRoLmMgYi9hdXRoLmMKaW5kZXggOTkyNjc3ZmQuLmVmNjIwNDUyIDEwMDY0NAotLS0gYS9hdXRoLmMKKysrIGIvYXV0aC5jCkBAIC01ODMsNyArNTgzLDggQEAgaW50IGtzbWJkX2RlY29kZV9udGxtc3NwX2F1dGhfYmxvYihzdHJ1Y3QgYXV0aGVudGljYXRlX21lc3NhZ2UgKmF1dGhibG9iLAogCWRuX29mZiA9IGxlMzJfdG9fY3B1KGF1dGhibG9iLT5Eb21haW5OYW1lLkJ1ZmZlck9mZnNldCk7CiAJZG5fbGVuID0gbGUxNl90b19jcHUoYXV0aGJsb2ItPkRvbWFpbk5hbWUuTGVuZ3RoKTsKIAotCWlmIChibG9iX2xlbiA8ICh1NjQpZG5fb2ZmICsgZG5fbGVuIHx8IGJsb2JfbGVuIDwgKHU2NCludF9vZmYgKyBudF9sZW4pCisJaWYgKGJsb2JfbGVuIDwgKHU2NClkbl9vZmYgKyBkbl9sZW4gfHwgYmxvYl9sZW4gPCAodTY0KW50X29mZiArIG50X2xlbiB8fAorCSAgICBudF9sZW4gPCBDSUZTX0VOQ1BXRF9TSVpFKQogCQlyZXR1cm4gLUVJTlZBTDsKIAogI2lmZGVmIENPTkZJR19TTUJfSU5TRUNVUkVfU0VSVkVS",
"url": "https://github.com/cifsd-team/ksmbd/commit/8824b7af409f51f1316e92e9887c2fd48c0b26d6.patch"
}
] | null |
|
CVE-2021-20286
|
A flaw was found in libnbd 1.7.3. An assertion failure in nbd_unlocked_opt_go in ilb/opt.c may lead to denial of service.
|
[
{
"commit_message": "[PATCH] opt_go: Tolerate unplanned server death While debugging some experimental nbdkit code that was triggering an assertion failure in nbdkit, I noticed a secondary failure of nbdsh also dying from an assertion: libnbd: debug: nbdsh: nbd_opt_go: transition: NEWSTYLE.OPT_GO.SEND -> DEAD libnbd: debug: nbdsh: nbd_opt_go: option queued, ignoring state machine failure nbdsh: opt.c:86: nbd_unlocked_opt_go: Assertion `nbd_internal_is_state_negotiating (get_next_state (h))' failed. Although my trigger was from non-production nbdkit code, libnbd should never die from an assertion failure merely because a server disappeared at the wrong moment during an incomplete reply to NBD_OPT_GO or NBD_OPT_INFO. If this is assigned a CVE, a followup patch will add mention of it in docs/libnbd-security.pod. Fixes: bbf1c51392 (api: Give aio_opt_go a completion callback) lib/opt.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://gitlab.com/nbdkit/libnbd/-/commit/fb4440de9cc76e9c14bd3ddf3333e78621f40ad0"
}
] |
CWE-617
|
|
GHSA-6898-wx94-8jq8
|
Potential Command Injection in libnotify
| null |
[
{
"commit_message": "[PATCH] Replacing call to exec with execFile. lib/libnotify.js | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)",
"patch_text_b64": "RnJvbSA4ZTJlNzMwNjA4ODYyNDUwM2JhNWVlYzU5MmI1MDJjNGY5N2Q4ODQ2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBOZWFsIFBvb2xlIDxuZWFsQGNzLmJyb3duLmVkdT4KRGF0ZTogVHVlLCAxNCBNYXkgMjAxMyAxNTozOTowNSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFJlcGxhY2luZyBjYWxsIHRvIGV4ZWMgd2l0aCBleGVjRmlsZS4KCi0tLQogbGliL2xpYm5vdGlmeS5qcyB8IDkgKysrKy0tLS0tCiAxIGZpbGUgY2hhbmdlZCwgNCBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2xpYi9saWJub3RpZnkuanMgYi9saWIvbGlibm90aWZ5LmpzCmluZGV4IDJjMTU2N2IuLjdlNTkyNjcgMTAwNjQ0Ci0tLSBhL2xpYi9saWJub3RpZnkuanMKKysrIGIvbGliL2xpYm5vdGlmeS5qcwpAQCAtNTUsMTggKzU1LDE3IEBAIGV4cG9ydHMuYmluVmVyc2lvbiA9IGZ1bmN0aW9uKGNhbGxiYWNrKSB7CiAKIGV4cG9ydHMubm90aWZ5ID0gZnVuY3Rpb24obXNnLCBvcHRpb25zLCBjYWxsYmFjaykgewogICB2YXIgaW1hZ2UsCi0gICAgICBhcmdzID0gWydub3RpZnktc2VuZCcsJyInICsgbXNnICsgJyInXSwKKyAgICAgIGFyZ3MgPSBbbXNnXSwKICAgICAgIG9wdGlvbnMgPSBvcHRpb25zIHx8IHt9CiAgIHRoaXMuYmluVmVyc2lvbihmdW5jdGlvbihlcnIsIHZlcnNpb24pewogICAgIGlmIChlcnIpIHJldHVybiBjYWxsYmFjayhlcnIpCi0gICAgaWYgKGltYWdlID0gb3B0aW9ucy5pbWFnZSkgYXJncy5wdXNoKCctaSAnICsgaW1hZ2UpCisgICAgaWYgKGltYWdlID0gb3B0aW9ucy5pbWFnZSkgYXJncy5wdXNoKCctaScsIGltYWdlKQogICAgIGlmIChvcHRpb25zLnRpbWUpIGFyZ3MucHVzaCgnLXQnLCBvcHRpb25zLnRpbWUpCiAgICAgaWYgKG9wdGlvbnMuY2F0ZWdvcnkpIGFyZ3MucHVzaCgnLWMnLCBvcHRpb25zLmNhdGVnb3J5KQogICAgIGlmIChvcHRpb25zLnVyZ2VuY3kpIGFyZ3MucHVzaCgnLXUnLCBvcHRpb25zLnVyZ2VuY3kpCiAgICAgaWYgKG9wdGlvbnMudGl0bGUpIHsKLSAgICAgIGFyZ3Muc2hpZnQoKQotICAgICAgYXJncy51bnNoaWZ0KCdub3RpZnktc2VuZCcsICciJysgb3B0aW9ucy50aXRsZSArJyInKQorICAgICAgYXJncy51bnNoaWZ0KG9wdGlvbnMudGl0bGUpCiAgICAgfQotICAgIGNoaWxkX3Byb2Nlc3MuZXhlYyhhcmdzLmpvaW4oJyAnKSwgY2FsbGJhY2spCisgICAgY2hpbGRfcHJvY2Vzcy5leGVjRmlsZSgnbm90aWZ5LXNlbmQnLCBhcmdzLCB7fSwgY2FsbGJhY2spCiAgIH0pCiB9",
"url": "https://github.com/mytrile/node-libnotify/commit/dfe7801d73a0dda10663a0ff3d0ec8b4d5f0d448.patch"
}
] | null |
CVE-2021-38160
|
In drivers/char/virtio_console.c in the Linux kernel before 5.13.4, data corruption or loss can be triggered by an untrusted device that supplies a buf->len value exceeding the buffer size. NOTE: the vendor indicates that the cited data corruption is not a vulnerability in any existing use case; the length validation was added solely for robustness in the face of anomalous host OS behavior
|
[
{
"commit_message": "[PATCH] virtio_console: Assure used length from device is limited The buf->len might come from an untrusted device. This ensures the value would not exceed the size of the buffer to avoid data corruption or loss. Signed-off-by: Xie Yongji <xieyongji@bytedance.com> Acked-by: Jason Wang <jasowang@redhat.com> Link: https://lore.kernel.org/r/20210525125622.1203-1-xieyongji@bytedance.com Signed-off-by: Michael S. Tsirkin <mst@redhat.com> drivers/char/virtio_console.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSBkMDBkOGRhNTg2OWEyNjA4ZTk3Y2ZlZGUwOTRkZmM1ZTExNDYyYTQ2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBYaWUgWW9uZ2ppIDx4aWV5b25namlAYnl0ZWRhbmNlLmNvbT4KRGF0ZTogVHVlLCAyNSBNYXkgMjAyMSAyMDo1NjoyMiArMDgwMApTdWJqZWN0OiBbUEFUQ0hdIHZpcnRpb19jb25zb2xlOiBBc3N1cmUgdXNlZCBsZW5ndGggZnJvbSBkZXZpY2UgaXMgbGltaXRlZAoKVGhlIGJ1Zi0+bGVuIG1pZ2h0IGNvbWUgZnJvbSBhbiB1bnRydXN0ZWQgZGV2aWNlLiBUaGlzCmVuc3VyZXMgdGhlIHZhbHVlIHdvdWxkIG5vdCBleGNlZWQgdGhlIHNpemUgb2YgdGhlIGJ1ZmZlcgp0byBhdm9pZCBkYXRhIGNvcnJ1cHRpb24gb3IgbG9zcy4KClNpZ25lZC1vZmYtYnk6IFhpZSBZb25namkgPHhpZXlvbmdqaUBieXRlZGFuY2UuY29tPgpBY2tlZC1ieTogSmFzb24gV2FuZyA8amFzb3dhbmdAcmVkaGF0LmNvbT4KTGluazogaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvci8yMDIxMDUyNTEyNTYyMi4xMjAzLTEteGlleW9uZ2ppQGJ5dGVkYW5jZS5jb20KU2lnbmVkLW9mZi1ieTogTWljaGFlbCBTLiBUc2lya2luIDxtc3RAcmVkaGF0LmNvbT4KLS0tCiBkcml2ZXJzL2NoYXIvdmlydGlvX2NvbnNvbGUuYyB8IDQgKystLQogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvdmlydGlvX2NvbnNvbGUuYyBiL2RyaXZlcnMvY2hhci92aXJ0aW9fY29uc29sZS5jCmluZGV4IDU5ZGZkOWM0MjFhMWVhLi43ZWFmMzAzYTdhODZmOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3ZpcnRpb19jb25zb2xlLmMKKysrIGIvZHJpdmVycy9jaGFyL3ZpcnRpb19jb25zb2xlLmMKQEAgLTQ3NSw3ICs0NzUsNyBAQCBzdGF0aWMgc3RydWN0IHBvcnRfYnVmZmVyICpnZXRfaW5idWYoc3RydWN0IHBvcnQgKnBvcnQpCiAKIAlidWYgPSB2aXJ0cXVldWVfZ2V0X2J1Zihwb3J0LT5pbl92cSwgJmxlbik7CiAJaWYgKGJ1ZikgewotCQlidWYtPmxlbiA9IGxlbjsKKwkJYnVmLT5sZW4gPSBtaW5fdChzaXplX3QsIGxlbiwgYnVmLT5zaXplKTsKIAkJYnVmLT5vZmZzZXQgPSAwOwogCQlwb3J0LT5zdGF0cy5ieXRlc19yZWNlaXZlZCArPSBsZW47CiAJfQpAQCAtMTcwOSw3ICsxNzA5LDcgQEAgc3RhdGljIHZvaWQgY29udHJvbF93b3JrX2hhbmRsZXIoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogCXdoaWxlICgoYnVmID0gdmlydHF1ZXVlX2dldF9idWYodnEsICZsZW4pKSkgewogCQlzcGluX3VubG9jaygmcG9ydGRldi0+Y19pdnFfbG9jayk7CiAKLQkJYnVmLT5sZW4gPSBsZW47CisJCWJ1Zi0+bGVuID0gbWluX3Qoc2l6ZV90LCBsZW4sIGJ1Zi0+c2l6ZSk7CiAJCWJ1Zi0+b2Zmc2V0ID0gMDsKIAogCQloYW5kbGVfY29udHJvbF9tZXNzYWdlKHZxLT52ZGV2LCBwb3J0ZGV2LCBidWYpOw==",
"url": "https://github.com/torvalds/linux/commit/d00d8da5869a2608e97cfede094dfc5e11462a46.patch"
}
] |
n/a
|
|
GHSA-xcvw-hh99-qm73
|
Liferay Portal is vulnerable to XSS through its workflow process builder
| null |
[
{
"commit_message": "[PATCH] LPD-15212 Check the workflow XML file for malicious content .../source-builder/SourceBuilder.js | 25 ++++++++++++++++++- .../source-builder/xmlUtil.js | 16 ++++++++++++ 2 files changed, 40 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/liferay/liferay-portal/commit/3acad2d8683688ce022abf2dfbab9fb500c5a619.patch"
}
] | null |
GHSA-4r62-v4vq-hr96
|
Regular Expression Denial of Service (REDoS) in Marked
| null |
[
{
"commit_message": "[PATCH] fix: Total rework of Emphasis/Strong (#1864) BREAKING CHANGE: `em` and `strong` tokenizers have been merged into one `emStrong` tokenizer lib/marked.esm.js | 164 ++++++++---------- lib/marked.js | 153 ++++++++-------- marked.min.js | 2 +- src/Lexer.js | 22 +-- src/Tokenizer.js | 71 +++++--- src/rules.js | 71 ++------ test/specs/bug/adjacent_lists.html | 1 + test/specs/bug/adjacent_lists.md | 1 + test/specs/commonmark/commonmark.0.29.json | 66 +++---- test/specs/gfm/commonmark.0.29.json | 66 +++---- test/specs/new/em_list_links.html | 17 +- .../original/strong_and_em_together.html | 7 - test/specs/original/strong_and_em_together.md | 7 - test/specs/redos/quadratic_underscores.js | 4 + 14 files changed, 280 insertions(+), 372 deletions(-) create mode 100644 test/specs/bug/adjacent_lists.html create mode 100644 test/specs/bug/adjacent_lists.md delete mode 100644 test/specs/original/strong_and_em_together.html delete mode 100644 test/specs/original/strong_and_em_together.md create mode 100644 test/specs/redos/quadratic_underscores.js",
"patch_text_b64": "From 7293251c438e3ee968970f7609f1a27f9007bccd Mon Sep 17 00:00:00 2001
From: Trevor Buckner <calculuschild@gmail.com>
Date: Sun, 7 Feb 2021 17:25:01 -0500
Subject: [PATCH] fix: Total rework of Emphasis/Strong (#1864)

BREAKING CHANGE: `em` and `strong` tokenizers have been merged into one `emStrong` tokenizer
---
 lib/marked.esm.js                             | 164 ++++++++----------
 lib/marked.js                                 | 153 ++++++++--------
 marked.min.js                                 |   2 +-
 src/Lexer.js                                  |  22 +--
 src/Tokenizer.js                              |  71 +++++---
 src/rules.js                                  |  71 ++------
 test/specs/bug/adjacent_lists.html            |   1 +
 test/specs/bug/adjacent_lists.md              |   1 +
 test/specs/commonmark/commonmark.0.29.json    |  66 +++----
 test/specs/gfm/commonmark.0.29.json           |  66 +++----
 test/specs/new/em_list_links.html             |  17 +-
 .../original/strong_and_em_together.html      |   7 -
 test/specs/original/strong_and_em_together.md |   7 -
 test/specs/redos/quadratic_underscores.js     |   4 +
 14 files changed, 280 insertions(+), 372 deletions(-)
 create mode 100644 test/specs/bug/adjacent_lists.html
 create mode 100644 test/specs/bug/adjacent_lists.md
 delete mode 100644 test/specs/original/strong_and_em_together.html
 delete mode 100644 test/specs/original/strong_and_em_together.md
 create mode 100644 test/specs/redos/quadratic_underscores.js

diff --git a/lib/marked.esm.js b/lib/marked.esm.js
index 31ed6e80be..d40c19a59d 100644
--- a/lib/marked.esm.js
+++ b/lib/marked.esm.js
@@ -839,46 +839,61 @@ var Tokenizer_1 = class Tokenizer {
     }
   }
 
-  strong(src, maskedSrc, prevChar = '') {
-    let match = this.rules.inline.strong.start.exec(src);
+  emStrong(src, maskedSrc, prevChar = '') {
+    let match = this.rules.inline.emStrong.lDelim.exec(src);
+    if (!match) return;
 
-    if (match && (!match[1] || (match[1] && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))))) {
-      maskedSrc = maskedSrc.slice(-1 * src.length);
-      const endReg = match[0] === '**' ? this.rules.inline.strong.endAst : this.rules.inline.strong.endUnd;
+    if (match[3] && prevChar.match(/[\p{L}\p{N}]/u)) return; // _ can't be between two alphanumerics. \p{L}\p{N} includes non-english alphabet/numbers as well
 
+    const nextChar = match[1] || match[2] || '';
+
+    if (!nextChar || (nextChar && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar)))) {
+      const lLength = match[0].length - 1;
+      let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
+
+      const endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
       endReg.lastIndex = 0;
 
-      let cap;
+      maskedSrc = maskedSrc.slice(-1 * src.length + lLength); // Bump maskedSrc to same section of string as src (move to lexer?)
+
       while ((match = endReg.exec(maskedSrc)) != null) {
-        cap = this.rules.inline.strong.middle.exec(maskedSrc.slice(0, match.index + 3));
-        if (cap) {
-          return {
-            type: 'strong',
-            raw: src.slice(0, cap[0].length),
-            text: src.slice(2, cap[0].length - 2)
-          };
+        rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+
+        if (!rDelim) continue; // matched the first alternative in rules.js (skip the * in __abc*abc__)
+
+        rLength = rDelim.length;
+
+        if (match[3] || match[4]) { // found another Left Delim
+          delimTotal += rLength;
+          continue;
+        } else if (match[5] || match[6]) { // either Left or Right Delim
+          if (lLength % 3 && !((lLength + rLength) % 3)) {
+            midDelimTotal += rLength;
+            continue; // CommonMark Emphasis Rules 9-10
+          }
         }
-      }
-    }
-  }
 
-  em(src, maskedSrc, prevChar = '') {
-    let match = this.rules.inline.em.start.exec(src);
+        delimTotal -= rLength;
 
-    if (match && (!match[1] || (match[1] && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))))) {
-      maskedSrc = maskedSrc.slice(-1 * src.length);
-      const endReg = match[0] === '*' ? this.rules.inline.em.endAst : this.rules.inline.em.endUnd;
+        if (delimTotal > 0) continue; // Haven't found enough closing delimiters
 
-      endReg.lastIndex = 0;
+        // If this is the last rDelimiter, remove extra characters. *a*** -> *a*
+        if (delimTotal + midDelimTotal - rLength <= 0 && !maskedSrc.slice(endReg.lastIndex).match(endReg)) {
+          rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
+        }
 
-      let cap;
-      while ((match = endReg.exec(maskedSrc)) != null) {
-        cap = this.rules.inline.em.middle.exec(maskedSrc.slice(0, match.index + 2));
-        if (cap) {
+        if (Math.min(lLength, rLength) % 2) {
           return {
             type: 'em',
-            raw: src.slice(0, cap[0].length),
-            text: src.slice(1, cap[0].length - 1)
+            raw: src.slice(0, lLength + match.index + rLength + 1),
+            text: src.slice(1, lLength + match.index + rLength)
+          };
+        }
+        if (Math.min(lLength, rLength) % 2 === 0) {
+          return {
+            type: 'strong',
+            raw: src.slice(0, lLength + match.index + rLength + 1),
+            text: src.slice(2, lLength + match.index + rLength - 1)
           };
         }
       }
@@ -1182,74 +1197,41 @@ const inline = {
   reflink: /^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,
   nolink: /^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,
   reflinkSearch: 'reflink|nolink(?!\\()',
-  strong: {
-    start: /^(?:(\*\*(?=[*punctuation]))|\*\*)(?![\s])|__/, // (1) returns if starts w/ punctuation
-    middle: /^\*\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*\*$|^__(?![\s])((?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?)__$/,
-    endAst: /[^punctuation\s]\*\*(?!\*)|[punctuation]\*\*(?!\*)(?:(?=[punctuation_\s]|$))/, // last char can't be punct, or final * must also be followed by punct (or endline)
-    endUnd: /[^\s]__(?!_)(?:(?=[punctuation*\s])|$)/ // last char can't be a space, and final _ must preceed punct or \s (or endline)
-  },
-  em: {
-    start: /^(?:(\*(?=[punctuation]))|\*)(?![*\s])|_/, // (1) returns if starts w/ punctuation
-    middle: /^\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*$|^_(?![_\s])(?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?_$/,
-    endAst: /[^punctuation\s]\*(?!\*)|[punctuation]\*(?!\*)(?:(?=[punctuation_\s]|$))/, // last char can't be punct, or final * must also be followed by punct (or endline)
-    endUnd: /[^\s]_(?!_)(?:(?=[punctuation*\s])|$)/ // last char can't be a space, and final _ must preceed punct or \s (or endline)
+  emStrong: {
+    lDelim: /^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/,
+    //        (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
+    //        () Skip other delimiter (1) #***                (2) a***#, a***                   (3) #***a, ***a                 (4) ***#              (5) #***#                 (6) a***a
+    rDelimAst: /\_\_[^_]*?\*[^_]*?\_\_|[punct_](\*+)(?=[\s]|$)|[^punct*_\s](\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|[^punct*_\s](\*+)(?=[^punct*_\s])/,
+    rDelimUnd: /\*\*[^*]*?\_[^*]*?\*\*|[punct*](\_+)(?=[\s]|$)|[^punct*_\s](\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/ // ^- Not allowed for _
   },
   code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
   br: /^( {2,}|\\)\n(?!\s*$)/,
   del: noopTest$1,
-  text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*]|\b_|$)|[^ ](?= {2,}\n)))/,
-  punctuation: /^([\s*punctuation])/
+  text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,
+  punctuation: /^([\spunctuation])/
 };
 
-// list of punctuation marks from common mark spec
-// without * and _ to workaround cases with double emphasis
+// list of punctuation marks from CommonMark spec
+// without * and _ to handle the different emphasis markers * and _
 inline._punctuation = '!"#$%&\'()+\\-.,/:;<=>?@\\[\\]`^{|}~';
 inline.punctuation = edit$1(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex();
 
 // sequences em should skip over [title](link), `code`, <html>
-inline._blockSkip = '\\[[^\\]]*?\\]\\([^\\)]*?\\)|`[^`]*?`|<[^>]*?>';
-inline._overlapSkip = '__[^_]*?__|\\*\\*\\[^\\*\\]*?\\*\\*';
+inline.blockSkip = /\[[^\]]*?\]\([^\)]*?\)|`[^`]*?`|<[^>]*?>/g;
+inline.escapedEmSt = /\\\*|\\_/g;
 
 inline._comment = edit$1(block._comment).replace('(?:-->|$)', '-->').getRegex();
 
-inline.em.start = edit$1(inline.em.start)
-  .replace(/punctuation/g, inline._punctuation)
+inline.emStrong.lDelim = edit$1(inline.emStrong.lDelim)
+  .replace(/punct/g, inline._punctuation)
   .getRegex();
 
-inline.em.middle = edit$1(inline.em.middle)
-  .replace(/punctuation/g, inline._punctuation)
-  .replace(/overlapSkip/g, inline._overlapSkip)
+inline.emStrong.rDelimAst = edit$1(inline.emStrong.rDelimAst, 'g')
+  .replace(/punct/g, inline._punctuation)
   .getRegex();
 
-inline.em.endAst = edit$1(inline.em.endAst, 'g')
-  .replace(/punctuation/g, inline._punctuation)
-  .getRegex();
-
-inline.em.endUnd = edit$1(inline.em.endUnd, 'g')
-  .replace(/punctuation/g, inline._punctuation)
-  .getRegex();
-
-inline.strong.start = edit$1(inline.strong.start)
-  .replace(/punctuation/g, inline._punctuation)
-  .getRegex();
-
-inline.strong.middle = edit$1(inline.strong.middle)
-  .replace(/punctuation/g, inline._punctuation)
-  .replace(/overlapSkip/g, inline._overlapSkip)
-  .getRegex();
-
-inline.strong.endAst = edit$1(inline.strong.endAst, 'g')
-  .replace(/punctuation/g, inline._punctuation)
-  .getRegex();
-
-inline.strong.endUnd = edit$1(inline.strong.endUnd, 'g')
-  .replace(/punctuation/g, inline._punctuation)
-  .getRegex();
-
-inline.blockSkip = edit$1(inline._blockSkip, 'g')
-  .getRegex();
-
-inline.overlapSkip = edit$1(inline._overlapSkip, 'g')
+inline.emStrong.rDelimUnd = edit$1(inline.emStrong.rDelimUnd, 'g')
+  .replace(/punct/g, inline._punctuation)
   .getRegex();
 
 inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;
@@ -1328,7 +1310,7 @@ inline.gfm = merge$1({}, inline.normal, {
   url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
   _backpedal: /(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,
   del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
-  text: /^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/
+  text: /^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/
 });
 
 inline.gfm.url = edit$1(inline.gfm.url, 'i')
@@ -1704,11 +1686,17 @@ var Lexer_1 = class Lexer {
       maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString$1('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
     }
 
+    // Mask out escaped em & strong delimiters
+    while ((match = this.tokenizer.rules.inline.escapedEmSt.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex);
+    }
+
     while (src) {
       if (!keepPrevChar) {
         prevChar = '';
       }
       keepPrevChar = false;
+
       // escape
       if (token = this.tokenizer.escape(src)) {
         src = src.substring(token.raw.length);
@@ -1757,16 +1745,8 @@ var Lexer_1 = class Lexer {
         continue;
       }
 
-      // strong
-      if (token = this.tokenizer.strong(src, maskedSrc, prevChar)) {
-        src = src.substring(token.raw.length);
-        token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
-        tokens.push(token);
-        continue;
-      }
-
-      // em
-      if (token = this.tokenizer.em(src, maskedSrc, prevChar)) {
+      // em & strong
+      if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
         src = src.substring(token.raw.length);
         token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
         tokens.push(token);
@@ -1812,7 +1792,9 @@ var Lexer_1 = class Lexer {
       // text
       if (token = this.tokenizer.inlineText(src, inRawBlock, smartypants)) {
         src = src.substring(token.raw.length);
-        prevChar = token.raw.slice(-1);
+        if (token.raw.slice(-1) !== '_') { // Track prevChar before string of ____ started
+          prevChar = token.raw.slice(-1);
+        }
         keepPrevChar = true;
         lastToken = tokens[tokens.length - 1];
         if (lastToken && lastToken.type === 'text') {
diff --git a/lib/marked.js b/lib/marked.js
index 904a9f1077..731b513a4f 100644
--- a/lib/marked.js
+++ b/lib/marked.js
@@ -937,54 +937,66 @@
       }
     };
 
-    _proto.strong = function strong(src, maskedSrc, prevChar) {
+    _proto.emStrong = function emStrong(src, maskedSrc, prevChar) {
       if (prevChar === void 0) {
         prevChar = '';
       }
 
-      var match = this.rules.inline.strong.start.exec(src);
+      var match = this.rules.inline.emStrong.lDelim.exec(src);
+      if (!match) return;
+      if (match[3] && prevChar.match(/(?:[0-9A-Za-z\xAA\xB2\xB3\xB5\xB9\xBA\xBC-\xBE\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u0660-\u0669\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07C0-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0966-\u096F\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09E6-\u09F1\u09F4-\u09F9\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AE6-\u0AEF\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B66-\u0B6F\u0B71-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0BE6-\u0BF2\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C66-\u0C6F\u0C78-\u0C7E\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CE6-\u0CEF\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D58-\u0D61\u0D66-\u0D78\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DE6-\u0DEF\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F20-\u0F33\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F-\u1049\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u1090-\u1099\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1369-\u137C\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u17E0-\u17E9\u17F0-\u17F9\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A16\u1A20-\u1A54\u1A80-\u1A89\u1A90-\u1A99\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B50-\u1B59\u1B83-\u1BA0\u1BAE-\u1BE5\u1C00-\u1C23\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2070\u2071\u2074-\u2079\u207F-\u2089\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2150-\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2CFD\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u3192-\u3195\u31A0-\u31BF\u31F0-\u31FF\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA830-\uA835\uA840-\uA873\uA882-\uA8B3\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA900-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF-\uA9D9\uA9E0-\uA9E4\uA9E6-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD07-\uDD33\uDD40-\uDD78\uDD8A\uDD8B\uDE80-\uDE9C\uDEA0-\uDED0\uDEE1-\uDEFB\uDF00-\uDF23\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC58-\uDC76\uDC79-\uDC9E\uDCA7-\uDCAF\uDCE0-\uDCF2\uDCF4\uDCF5\uDCFB-\uDD1B\uDD20-\uDD39\uDD80-\uDDB7\uDDBC-\uDDCF\uDDD2-\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE40-\uDE48\uDE60-\uDE7E\uDE80-\uDE9F\uDEC0-\uDEC7\uDEC9-\uDEE4\uDEEB-\uDEEF\uDF00-\uDF35\uDF40-\uDF55\uDF58-\uDF72\uDF78-\uDF91\uDFA9-\uDFAF]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDCFA-\uDD23\uDD30-\uDD39\uDE60-\uDE7E\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF27\uDF30-\uDF45\uDF51-\uDF54\uDFB0-\uDFCB\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC52-\uDC6F\uDC83-\uDCAF\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD03-\uDD26\uDD36-\uDD3F\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDD0-\uDDDA\uDDDC\uDDE1-\uDDF4\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDEF0-\uDEF9\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC50-\uDC59\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE50-\uDE59\uDE80-\uDEAA\uDEB8\uDEC0-\uDEC9\uDF00-\uDF1A\uDF30-\uDF3B]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCF2\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDD50-\uDD59\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC50-\uDC6C\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD50-\uDD59\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDDA0-\uDDA9\uDEE0-\uDEF2\uDFB0\uDFC0-\uDFD4]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF50-\uDF59\uDF5B-\uDF61\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE96\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD834[\uDEE0-\uDEF3\uDF60-\uDF78]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD40-\uDD49\uDD4E\uDEC0-\uDEEB\uDEF0-\uDEF9]|\uD83A[\uDC00-\uDCC4\uDCC7-\uDCCF\uDD00-\uDD43\uDD4B\uDD50-\uDD59]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD83C[\uDD00-\uDD0C]|\uD83E[\uDFF0-\uDFF9]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A])/)) return; // _ can't be between two alphanumerics. \p{L}\p{N} includes non-english alphabet/numbers as well
 
-      if (match && (!match[1] || match[1] && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar)))) {
-        maskedSrc = maskedSrc.slice(-1 * src.length);
-        var endReg = match[0] === '**' ? this.rules.inline.strong.endAst : this.rules.inline.strong.endUnd;
+      var nextChar = match[1] || match[2] || '';
+
+      if (!nextChar || nextChar && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))) {
+        var lLength = match[0].length - 1;
+        var rDelim,
+            rLength,
+            delimTotal = lLength,
+            midDelimTotal = 0;
+        var endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
         endReg.lastIndex = 0;
-        var cap;
+        maskedSrc = maskedSrc.slice(-1 * src.length + lLength); // Bump maskedSrc to same section of string as src (move to lexer?)
 
         while ((match = endReg.exec(maskedSrc)) != null) {
-          cap = this.rules.inline.strong.middle.exec(maskedSrc.slice(0, match.index + 3));
-
-          if (cap) {
-            return {
-              type: 'strong',
-              raw: src.slice(0, cap[0].length),
-              text: src.slice(2, cap[0].length - 2)
-            };
+          rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+          if (!rDelim) continue; // matched the first alternative in rules.js (skip the * in __abc*abc__)
+
+          rLength = rDelim.length;
+
+          if (match[3] || match[4]) {
+            // found another Left Delim
+            delimTotal += rLength;
+            continue;
+          } else if (match[5] || match[6]) {
+            // either Left or Right Delim
+            if (lLength % 3 && !((lLength + rLength) % 3)) {
+              midDelimTotal += rLength;
+              continue; // CommonMark Emphasis Rules 9-10
+            }
           }
-        }
-      }
-    };
 
-    _proto.em = function em(src, maskedSrc, prevChar) {
-      if (prevChar === void 0) {
-        prevChar = '';
-      }
-
-      var match = this.rules.inline.em.start.exec(src);
-
-      if (match && (!match[1] || match[1] && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar)))) {
-        maskedSrc = maskedSrc.slice(-1 * src.length);
-        var endReg = match[0] === '*' ? this.rules.inline.em.endAst : this.rules.inline.em.endUnd;
-        endReg.lastIndex = 0;
-        var cap;
+          delimTotal -= rLength;
+          if (delimTotal > 0) continue; // Haven't found enough closing delimiters
+          // If this is the last rDelimiter, remove extra characters. *a*** -> *a*
 
-        while ((match = endReg.exec(maskedSrc)) != null) {
-          cap = this.rules.inline.em.middle.exec(maskedSrc.slice(0, match.index + 2));
+          if (delimTotal + midDelimTotal - rLength <= 0 && !maskedSrc.slice(endReg.lastIndex).match(endReg)) {
+            rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
+          }
 
-          if (cap) {
+          if (Math.min(lLength, rLength) % 2) {
             return {
               type: 'em',
-              raw: src.slice(0, cap[0].length),
-              text: src.slice(1, cap[0].length - 1)
+              raw: src.slice(0, lLength + match.index + rLength + 1),
+              text: src.slice(1, lLength + match.index + rLength)
+            };
+          }
+
+          if (Math.min(lLength, rLength) % 2 === 0) {
+            return {
+              type: 'strong',
+              raw: src.slice(0, lLength + match.index + rLength + 1),
+              text: src.slice(2, lLength + match.index + rLength - 1)
             };
           }
         }
@@ -1233,48 +1245,31 @@
     reflink: /^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,
     nolink: /^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,
     reflinkSearch: 'reflink|nolink(?!\\()',
-    strong: {
-      start: /^(?:(\*\*(?=[*punctuation]))|\*\*)(?![\s])|__/,
-      // (1) returns if starts w/ punctuation
-      middle: /^\*\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*\*$|^__(?![\s])((?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?)__$/,
-      endAst: /[^punctuation\s]\*\*(?!\*)|[punctuation]\*\*(?!\*)(?:(?=[punctuation_\s]|$))/,
-      // last char can't be punct, or final * must also be followed by punct (or endline)
-      endUnd: /[^\s]__(?!_)(?:(?=[punctuation*\s])|$)/ // last char can't be a space, and final _ must preceed punct or \s (or endline)
-
-    },
-    em: {
-      start: /^(?:(\*(?=[punctuation]))|\*)(?![*\s])|_/,
-      // (1) returns if starts w/ punctuation
-      middle: /^\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*$|^_(?![_\s])(?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?_$/,
-      endAst: /[^punctuation\s]\*(?!\*)|[punctuation]\*(?!\*)(?:(?=[punctuation_\s]|$))/,
-      // last char can't be punct, or final * must also be followed by punct (or endline)
-      endUnd: /[^\s]_(?!_)(?:(?=[punctuation*\s])|$)/ // last char can't be a space, and final _ must preceed punct or \s (or endline)
+    emStrong: {
+      lDelim: /^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/,
+      //        (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
+      //        () Skip other delimiter (1) #***                (2) a***#, a***                   (3) #***a, ***a                 (4) ***#              (5) #***#                 (6) a***a
+      rDelimAst: /\_\_[^_]*?\*[^_]*?\_\_|[punct_](\*+)(?=[\s]|$)|[^punct*_\s](\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|[^punct*_\s](\*+)(?=[^punct*_\s])/,
+      rDelimUnd: /\*\*[^*]*?\_[^*]*?\*\*|[punct*](\_+)(?=[\s]|$)|[^punct*_\s](\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/ // ^- Not allowed for _
 
     },
     code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
     br: /^( {2,}|\\)\n(?!\s*$)/,
     del: noopTest$1,
-    text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*]|\b_|$)|[^ ](?= {2,}\n)))/,
-    punctuation: /^([\s*punctuation])/
-  }; // list of punctuation marks from common mark spec
-  // without * and _ to workaround cases with double emphasis
+    text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,
+    punctuation: /^([\spunctuation])/
+  }; // list of punctuation marks from CommonMark spec
+  // without * and _ to handle the different emphasis markers * and _
 
   inline._punctuation = '!"#$%&\'()+\\-.,/:;<=>?@\\[\\]`^{|}~';
   inline.punctuation = edit$1(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex(); // sequences em should skip over [title](link), `code`, <html>
 
-  inline._blockSkip = '\\[[^\\]]*?\\]\\([^\\)]*?\\)|`[^`]*?`|<[^>]*?>';
-  inline._overlapSkip = '__[^_]*?__|\\*\\*\\[^\\*\\]*?\\*\\*';
+  inline.blockSkip = /\[[^\]]*?\]\([^\)]*?\)|`[^`]*?`|<[^>]*?>/g;
+  inline.escapedEmSt = /\\\*|\\_/g;
   inline._comment = edit$1(block._comment).replace('(?:-->|$)', '-->').getRegex();
-  inline.em.start = edit$1(inline.em.start).replace(/punctuation/g, inline._punctuation).getRegex();
-  inline.em.middle = edit$1(inline.em.middle).replace(/punctuation/g, inline._punctuation).replace(/overlapSkip/g, inline._overlapSkip).getRegex();
-  inline.em.endAst = edit$1(inline.em.endAst, 'g').replace(/punctuation/g, inline._punctuation).getRegex();
-  inline.em.endUnd = edit$1(inline.em.endUnd, 'g').replace(/punctuation/g, inline._punctuation).getRegex();
-  inline.strong.start = edit$1(inline.strong.start).replace(/punctuation/g, inline._punctuation).getRegex();
-  inline.strong.middle = edit$1(inline.strong.middle).replace(/punctuation/g, inline._punctuation).replace(/overlapSkip/g, inline._overlapSkip).getRegex();
-  inline.strong.endAst = edit$1(inline.strong.endAst, 'g').replace(/punctuation/g, inline._punctuation).getRegex();
-  inline.strong.endUnd = edit$1(inline.strong.endUnd, 'g').replace(/punctuation/g, inline._punctuation).getRegex();
-  inline.blockSkip = edit$1(inline._blockSkip, 'g').getRegex();
-  inline.overlapSkip = edit$1(inline._overlapSkip, 'g').getRegex();
+  inline.emStrong.lDelim = edit$1(inline.emStrong.lDelim).replace(/punct/g, inline._punctuation).getRegex();
+  inline.emStrong.rDelimAst = edit$1(inline.emStrong.rDelimAst, 'g').replace(/punct/g, inline._punctuation).getRegex();
+  inline.emStrong.rDelimUnd = edit$1(inline.emStrong.rDelimUnd, 'g').replace(/punct/g, inline._punctuation).getRegex();
   inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;
   inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
   inline._email = /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/;
@@ -1322,7 +1317,7 @@
     url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
     _backpedal: /(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,
     del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
-    text: /^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/
+    text: /^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/
   });
   inline.gfm.url = edit$1(inline.gfm.url, 'i').replace('email', inline.gfm._extended_email).getRegex();
   /**
@@ -1721,6 +1716,11 @@
 
       while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
         maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString$1('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+      } // Mask out escaped em & strong delimiters
+
+
+      while ((match = this.tokenizer.rules.inline.escapedEmSt.exec(maskedSrc)) != null) {
+        maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex);
       }
 
       while (src) {
@@ -1781,18 +1781,10 @@
           }
 
           continue;
-        } // strong
+        } // em & strong
 
 
-        if (token = this.tokenizer.strong(src, maskedSrc, prevChar)) {
-          src = src.substring(token.raw.length);
-          token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
-          tokens.push(token);
-          continue;
-        } // em
-
-
-        if (token = this.tokenizer.em(src, maskedSrc, prevChar)) {
+        if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
           src = src.substring(token.raw.length);
           token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
           tokens.push(token);
@@ -1838,7 +1830,12 @@
 
         if (token = this.tokenizer.inlineText(src, inRawBlock, smartypants)) {
           src = src.substring(token.raw.length);
-          prevChar = token.raw.slice(-1);
+
+          if (token.raw.slice(-1) !== '_') {
+            // Track prevChar before string of ____ started
+            prevChar = token.raw.slice(-1);
+          }
+
           keepPrevChar = true;
           lastToken = tokens[tokens.length - 1];
 
diff --git a/marked.min.js b/marked.min.js
index 10e78525f2..46bf2d712e 100644
--- a/marked.min.js
+++ b/marked.min.js
@@ -3,4 +3,4 @@
  * Copyright (c) 2011-2021, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).marked=t()}(this,function(){"use strict";function i(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function s(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function p(e,t){var n;if("undefined"!=typeof Symbol&&null!=e[Symbol.iterator])return(n=e[Symbol.iterator]()).next.bind(n);if(Array.isArray(e)||(n=function(e,t){if(e){if("string"==typeof e)return s(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);return"Map"===(n="Object"===n&&e.constructor?e.constructor.name:n)||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?s(e,t):void 0}}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0;return function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}function n(e){return c[e]}var e,t=(function(t){function e(){return{baseUrl:null,breaks:!1,gfm:!0,headerIds:!0,headerPrefix:"",highlight:null,langPrefix:"language-",mangle:!0,pedantic:!1,renderer:null,sanitize:!1,sanitizer:null,silent:!1,smartLists:!1,smartypants:!1,tokenizer:null,walkTokens:null,xhtml:!1}}t.exports={defaults:e(),getDefaults:e,changeDefaults:function(e){t.exports.defaults=e}}}(e={exports:{}}),e.exports),r=/[&<>"']/,l=/[&<>"']/g,a=/[<>"']|&(?!#?\w+;)/,o=/[<>"']|&(?!#?\w+;)/g,c={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"};var u=/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/gi;function h(e){return e.replace(u,function(e,t){return"colon"===(t=t.toLowerCase())?":":"#"===t.charAt(0)?"x"===t.charAt(1)?String.fromCharCode(parseInt(t.substring(2),16)):String.fromCharCode(+t.substring(1)):""})}var g=/(^|[^\[])\^/g;var f=/[^\w:]/g,d=/^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;var k={},b=/^[^:]+:\/*[^/]*$/,m=/^([^:]+:)[\s\S]*$/,x=/^([^:]+:\/*[^/]*)[\s\S]*$/;function w(e,t){k[" "+e]||(b.test(e)?k[" "+e]=e+"/":k[" "+e]=v(e,"/",!0));var n=-1===(e=k[" "+e]).indexOf(":");return"//"===t.substring(0,2)?n?t:e.replace(m,"$1")+t:"/"===t.charAt(0)?n?t:e.replace(x,"$1")+t:e+t}function v(e,t,n){var r=e.length;if(0===r)return"";for(var i=0;i<r;){var s=e.charAt(r-i-1);if(s!==t||n){if(s===t||!n)break;i++}else i++}return e.substr(0,r-i)}var _=function(e,t){if(t){if(r.test(e))return e.replace(l,n)}else if(a.test(e))return e.replace(o,n);return e},y=h,z=function(n,e){n=n.source||n,e=e||"";var r={replace:function(e,t){return t=(t=t.source||t).replace(g,"$1"),n=n.replace(e,t),r},getRegex:function(){return new RegExp(n,e)}};return r},$=function(e,t,n){if(e){var r;try{r=decodeURIComponent(h(n)).replace(f,"").toLowerCase()}catch(e){return null}if(0===r.indexOf("javascript:")||0===r.indexOf("vbscript:")||0===r.indexOf("data:"))return null}t&&!d.test(n)&&(n=w(t,n));try{n=encodeURI(n).replace(/%25/g,"%")}catch(e){return null}return n},S={exec:function(){}},A=function(e){for(var t,n,r=1;r<arguments.length;r++)for(n in t=arguments[r])Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n]);return e},R=function(e,t){var n=e.replace(/\|/g,function(e,t,n){for(var r=!1,i=t;0<=--i&&"\\"===n[i];)r=!r;return r?"|":" |"}).split(/ \|/),r=0;if(n.length>t)n.splice(t);else for(;n.length<t;)n.push("");for(;r<n.length;r++)n[r]=n[r].trim().replace(/\\\|/g,"|");return n},T=function(e,t){if(-1===e.indexOf(t[1]))return-1;for(var n=e.length,r=0,i=0;i<n;i++)if("\\"===e[i])i++;else if(e[i]===t[0])r++;else if(e[i]===t[1]&&--r<0)return i;return-1},I=function(e){e&&e.sanitize&&!e.silent&&console.warn("marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options")},Z=function(e,t){if(t<1)return"";for(var n="";1<t;)1&t&&(n+=e),t>>=1,e+=e;return n+e},q=t.defaults,O=v,C=R,U=_,j=T;function E(e,t,n){var r=t.href,i=t.title?U(t.title):null,t=e[1].replace(/\\([\[\]])/g,"$1");return"!"!==e[0].charAt(0)?{type:"link",raw:n,href:r,title:i,text:t}:{type:"image",raw:n,href:r,title:i,text:U(t)}}var P=function(){function e(e){this.options=e||q}var t=e.prototype;return t.space=function(e){e=this.rules.block.newline.exec(e);if(e)return 1<e[0].length?{type:"space",raw:e[0]}:{raw:"\n"}},t.code=function(e,t){e=this.rules.block.code.exec(e);if(e){t=t[t.length-1];if(t&&"paragraph"===t.type)return{raw:e[0],text:e[0].trimRight()};t=e[0].replace(/^ {1,4}/gm,"");return{type:"code",raw:e[0],codeBlockStyle:"indented",text:this.options.pedantic?t:O(t,"\n")}}},t.fences=function(e){var t=this.rules.block.fences.exec(e);if(t){var n=t[0],e=function(e,t){if(null===(e=e.match(/^(\s+)(?:```)/)))return t;var n=e[1];return t.split("\n").map(function(e){var t=e.match(/^\s+/);return null!==t&&t[0].length>=n.length?e.slice(n.length):e}).join("\n")}(n,t[3]||"");return{type:"code",raw:n,lang:t[2]&&t[2].trim(),text:e}}},t.heading=function(e){var t=this.rules.block.heading.exec(e);if(t){var n=t[2].trim();return/#$/.test(n)&&(e=O(n,"#"),!this.options.pedantic&&e&&!/ $/.test(e)||(n=e.trim())),{type:"heading",raw:t[0],depth:t[1].length,text:n}}},t.nptable=function(e){e=this.rules.block.nptable.exec(e);if(e){var t={type:"table",header:C(e[1].replace(/^ *| *\| *$/g,"")),align:e[2].replace(/^ *|\| *$/g,"").split(/ *\| */),cells:e[3]?e[3].replace(/\n$/,"").split("\n"):[],raw:e[0]};if(t.header.length===t.align.length){for(var n=t.align.length,r=0;r<n;r++)/^ *-+: *$/.test(t.align[r])?t.align[r]="right":/^ *:-+: *$/.test(t.align[r])?t.align[r]="center":/^ *:-+ *$/.test(t.align[r])?t.align[r]="left":t.align[r]=null;for(n=t.cells.length,r=0;r<n;r++)t.cells[r]=C(t.cells[r],t.header.length);return t}}},t.hr=function(e){e=this.rules.block.hr.exec(e);if(e)return{type:"hr",raw:e[0]}},t.blockquote=function(e){var t=this.rules.block.blockquote.exec(e);if(t){e=t[0].replace(/^ *> ?/gm,"");return{type:"blockquote",raw:t[0],text:e}}},t.list=function(e){e=this.rules.block.list.exec(e);if(e){for(var t,n,r,i,s,l=e[0],a=e[2],o=1<a.length,c={type:"list",raw:l,ordered:o,start:o?+a.slice(0,-1):"",loose:!1,items:[]},u=e[0].match(this.rules.block.item),p=!1,h=u.length,g=this.rules.block.listItemStart.exec(u[0]),f=0;f<h;f++){if(l=t=u[f],f!==h-1){if(r=this.rules.block.listItemStart.exec(u[f+1]),this.options.pedantic?r[1].length>g[1].length:r[1].length>g[0].length||3<r[1].length){u.splice(f,2,u[f]+"\n"+u[f+1]),f--,h--;continue}(!this.options.pedantic||this.options.smartLists?r[2][r[2].length-1]!==a[a.length-1]:o==(1===r[2].length))&&(n=u.slice(f+1).join("\n"),c.raw=c.raw.substring(0,c.raw.length-n.length),f=h-1),g=r}r=t.length,~(t=t.replace(/^ *([*+-]|\d+[.)]) ?/,"")).indexOf("\n ")&&(r-=t.length,t=this.options.pedantic?t.replace(/^ {1,4}/gm,""):t.replace(new RegExp("^ {1,"+r+"}","gm"),"")),r=p||/\n\n(?!\s*$)/.test(t),f!==h-1&&(p="\n"===t.charAt(t.length-1),r=r||p),r&&(c.loose=!0),this.options.gfm&&(s=void 0,(i=/^\[[ xX]\] /.test(t))&&(s=" "!==t[1],t=t.replace(/^\[[ xX]\] +/,""))),c.items.push({type:"list_item",raw:l,task:i,checked:s,loose:r,text:t})}return c}},t.html=function(e){e=this.rules.block.html.exec(e);if(e)return{type:this.options.sanitize?"paragraph":"html",raw:e[0],pre:!this.options.sanitizer&&("pre"===e[1]||"script"===e[1]||"style"===e[1]),text:this.options.sanitize?this.options.sanitizer?this.options.sanitizer(e[0]):U(e[0]):e[0]}},t.def=function(e){e=this.rules.block.def.exec(e);if(e)return e[3]&&(e[3]=e[3].substring(1,e[3].length-1)),{tag:e[1].toLowerCase().replace(/\s+/g," "),raw:e[0],href:e[2],title:e[3]}},t.table=function(e){e=this.rules.block.table.exec(e);if(e){var t={type:"table",header:C(e[1].replace(/^ *| *\| *$/g,"")),align:e[2].replace(/^ *|\| *$/g,"").split(/ *\| */),cells:e[3]?e[3].replace(/\n$/,"").split("\n"):[]};if(t.header.length===t.align.length){t.raw=e[0];for(var n=t.align.length,r=0;r<n;r++)/^ *-+: *$/.test(t.align[r])?t.align[r]="right":/^ *:-+: *$/.test(t.align[r])?t.align[r]="center":/^ *:-+ *$/.test(t.align[r])?t.align[r]="left":t.align[r]=null;for(n=t.cells.length,r=0;r<n;r++)t.cells[r]=C(t.cells[r].replace(/^ *\| *| *\| *$/g,""),t.header.length);return t}}},t.lheading=function(e){e=this.rules.block.lheading.exec(e);if(e)return{type:"heading",raw:e[0],depth:"="===e[2].charAt(0)?1:2,text:e[1]}},t.paragraph=function(e){e=this.rules.block.paragraph.exec(e);if(e)return{type:"paragraph",raw:e[0],text:"\n"===e[1].charAt(e[1].length-1)?e[1].slice(0,-1):e[1]}},t.text=function(e,t){e=this.rules.block.text.exec(e);if(e){t=t[t.length-1];return t&&"text"===t.type?{raw:e[0],text:e[0]}:{type:"text",raw:e[0],text:e[0]}}},t.escape=function(e){e=this.rules.inline.escape.exec(e);if(e)return{type:"escape",raw:e[0],text:U(e[1])}},t.tag=function(e,t,n){e=this.rules.inline.tag.exec(e);if(e)return!t&&/^<a /i.test(e[0])?t=!0:t&&/^<\/a>/i.test(e[0])&&(t=!1),!n&&/^<(pre|code|kbd|script)(\s|>)/i.test(e[0])?n=!0:n&&/^<\/(pre|code|kbd|script)(\s|>)/i.test(e[0])&&(n=!1),{type:this.options.sanitize?"text":"html",raw:e[0],inLink:t,inRawBlock:n,text:this.options.sanitize?this.options.sanitizer?this.options.sanitizer(e[0]):U(e[0]):e[0]}},t.link=function(e){var t=this.rules.inline.link.exec(e);if(t){var n=t[2].trim();if(!this.options.pedantic&&/^</.test(n)){if(!/>$/.test(n))return;e=O(n.slice(0,-1),"\\");if((n.length-e.length)%2==0)return}else{var r=j(t[2],"()");-1<r&&(s=(0===t[0].indexOf("!")?5:4)+t[1].length+r,t[2]=t[2].substring(0,r),t[0]=t[0].substring(0,s).trim(),t[3]="")}var i,r=t[2],s="";return this.options.pedantic?(i=/^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(r))&&(r=i[1],s=i[3]):s=t[3]?t[3].slice(1,-1):"",r=r.trim(),E(t,{href:(r=/^</.test(r)?this.options.pedantic&&!/>$/.test(n)?r.slice(1):r.slice(1,-1):r)&&r.replace(this.rules.inline._escapes,"$1"),title:s&&s.replace(this.rules.inline._escapes,"$1")},t[0])}},t.reflink=function(e,t){if((n=this.rules.inline.reflink.exec(e))||(n=this.rules.inline.nolink.exec(e))){e=(n[2]||n[1]).replace(/\s+/g," ");if((e=t[e.toLowerCase()])&&e.href)return E(n,e,n[0]);var n=n[0].charAt(0);return{type:"text",raw:n,text:n}}},t.strong=function(e,t,n){void 0===n&&(n="");var r=this.rules.inline.strong.start.exec(e);if(r&&(!r[1]||r[1]&&(""===n||this.rules.inline.punctuation.exec(n)))){t=t.slice(-1*e.length);var i,s="**"===r[0]?this.rules.inline.strong.endAst:this.rules.inline.strong.endUnd;for(s.lastIndex=0;null!=(r=s.exec(t));)if(i=this.rules.inline.strong.middle.exec(t.slice(0,r.index+3)))return{type:"strong",raw:e.slice(0,i[0].length),text:e.slice(2,i[0].length-2)}}},t.em=function(e,t,n){void 0===n&&(n="");var r=this.rules.inline.em.start.exec(e);if(r&&(!r[1]||r[1]&&(""===n||this.rules.inline.punctuation.exec(n)))){t=t.slice(-1*e.length);var i,s="*"===r[0]?this.rules.inline.em.endAst:this.rules.inline.em.endUnd;for(s.lastIndex=0;null!=(r=s.exec(t));)if(i=this.rules.inline.em.middle.exec(t.slice(0,r.index+2)))return{type:"em",raw:e.slice(0,i[0].length),text:e.slice(1,i[0].length-1)}}},t.codespan=function(e){var t=this.rules.inline.code.exec(e);if(t){var n=t[2].replace(/\n/g," "),r=/[^ ]/.test(n),e=/^ /.test(n)&&/ $/.test(n);return r&&e&&(n=n.substring(1,n.length-1)),n=U(n,!0),{type:"codespan",raw:t[0],text:n}}},t.br=function(e){e=this.rules.inline.br.exec(e);if(e)return{type:"br",raw:e[0]}},t.del=function(e){e=this.rules.inline.del.exec(e);if(e)return{type:"del",raw:e[0],text:e[2]}},t.autolink=function(e,t){e=this.rules.inline.autolink.exec(e);if(e){var n,t="@"===e[2]?"mailto:"+(n=U(this.options.mangle?t(e[1]):e[1])):n=U(e[1]);return{type:"link",raw:e[0],text:n,href:t,tokens:[{type:"text",raw:n,text:n}]}}},t.url=function(e,t){var n,r,i,s;if(n=this.rules.inline.url.exec(e)){if("@"===n[2])i="mailto:"+(r=U(this.options.mangle?t(n[0]):n[0]));else{for(;s=n[0],n[0]=this.rules.inline._backpedal.exec(n[0])[0],s!==n[0];);r=U(n[0]),i="www."===n[1]?"http://"+r:r}return{type:"link",raw:n[0],text:r,href:i,tokens:[{type:"text",raw:r,text:r}]}}},t.inlineText=function(e,t,n){e=this.rules.inline.text.exec(e);if(e){n=t?this.options.sanitize?this.options.sanitizer?this.options.sanitizer(e[0]):U(e[0]):e[0]:U(this.options.smartypants?n(e[0]):e[0]);return{type:"text",raw:e[0],text:n}}},e}(),R=S,T=z,S=A,z={newline:/^(?: *(?:\n|$))+/,code:/^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,fences:/^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?:\n+|$)|$)/,hr:/^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,heading:/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,blockquote:/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,list:/^( {0,3})(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?! {0,3}bull )\n*|\s*$)/,html:"^ {0,3}(?:<(script|pre|style)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:\\n{2,}|$)|<(?!script|pre|style)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)|</(?!script|pre|style)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$))",def:/^ {0,3}\[(label)\]: *\n? *<?([^\s>]+)>?(?:(?: +\n? *| *\n *)(title))? *(?:\n+|$)/,nptable:R,table:R,lheading:/^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,_paragraph:/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html| +\n)[^\n]+)*)/,text:/^[^\n]+/,_label:/(?!\s*\])(?:\\[\[\]]|[^\[\]])+/,_title:/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/};z.def=T(z.def).replace("label",z._label).replace("title",z._title).getRegex(),z.bullet=/(?:[*+-]|\d{1,9}[.)])/,z.item=/^( *)(bull) ?[^\n]*(?:\n(?! *bull ?)[^\n]*)*/,z.item=T(z.item,"gm").replace(/bull/g,z.bullet).getRegex(),z.listItemStart=T(/^( *)(bull)/).replace("bull",z.bullet).getRegex(),z.list=T(z.list).replace(/bull/g,z.bullet).replace("hr","\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))").replace("def","\\n+(?="+z.def.source+")").getRegex(),z._tag="address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul",z._comment=/<!--(?!-?>)[\s\S]*?(?:-->|$)/,z.html=T(z.html,"i").replace("comment",z._comment).replace("tag",z._tag).replace("attribute",/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),z.paragraph=T(z._paragraph).replace("hr",z.hr).replace("heading"," {0,3}#{1,6} ").replace("|lheading","").replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)").replace("tag",z._tag).getRegex(),z.blockquote=T(z.blockquote).replace("paragraph",z.paragraph).getRegex(),z.normal=S({},z),z.gfm=S({},z.normal,{nptable:"^ *([^|\\n ].*\\|.*)\\n {0,3}([-:]+ *\\|[-| :]*)(?:\\n((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)",table:"^ *\\|(.+)\\n {0,3}\\|?( *[-:]+[-| :]*)(?:\\n *((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)"}),z.gfm.nptable=T(z.gfm.nptable).replace("hr",z.hr).replace("heading"," {0,3}#{1,6} ").replace("blockquote"," {0,3}>").replace("code"," {4}[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)").replace("tag",z._tag).getRegex(),z.gfm.table=T(z.gfm.table).replace("hr",z.hr).replace("heading"," {0,3}#{1,6} ").replace("blockquote"," {0,3}>").replace("code"," {4}[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)").replace("tag",z._tag).getRegex(),z.pedantic=S({},z.normal,{html:T("^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:\"[^\"]*\"|'[^']*'|\\s[^'\"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))").replace("comment",z._comment).replace(/tag/g,"(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),def:/^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,heading:/^(#{1,6})(.*)(?:\n+|$)/,fences:R,paragraph:T(z.normal._paragraph).replace("hr",z.hr).replace("heading"," *#{1,6} *[^\n]").replace("lheading",z.lheading).replace("blockquote"," {0,3}>").replace("|fences","").replace("|list","").replace("|html","").getRegex()});R={escape:/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,autolink:/^<(scheme:[^\s\x00-\x1f<>]*|email)>/,url:R,tag:"^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>",link:/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,reflink:/^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,nolink:/^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,reflinkSearch:"reflink|nolink(?!\\()",strong:{start:/^(?:(\*\*(?=[*punctuation]))|\*\*)(?![\s])|__/,middle:/^\*\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*\*$|^__(?![\s])((?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?)__$/,endAst:/[^punctuation\s]\*\*(?!\*)|[punctuation]\*\*(?!\*)(?:(?=[punctuation_\s]|$))/,endUnd:/[^\s]__(?!_)(?:(?=[punctuation*\s])|$)/},em:{start:/^(?:(\*(?=[punctuation]))|\*)(?![*\s])|_/,middle:/^\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*$|^_(?![_\s])(?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?_$/,endAst:/[^punctuation\s]\*(?!\*)|[punctuation]\*(?!\*)(?:(?=[punctuation_\s]|$))/,endUnd:/[^\s]_(?!_)(?:(?=[punctuation*\s])|$)/},code:/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,br:/^( {2,}|\\)\n(?!\s*$)/,del:R,text:/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*]|\b_|$)|[^ ](?= {2,}\n)))/,punctuation:/^([\s*punctuation])/,_punctuation:"!\"#$%&'()+\\-.,/:;<=>?@\\[\\]`^{|}~"};R.punctuation=T(R.punctuation).replace(/punctuation/g,R._punctuation).getRegex(),R._blockSkip="\\[[^\\]]*?\\]\\([^\\)]*?\\)|`[^`]*?`|<[^>]*?>",R._overlapSkip="__[^_]*?__|\\*\\*\\[^\\*\\]*?\\*\\*",R._comment=T(z._comment).replace("(?:--\x3e|$)","--\x3e").getRegex(),R.em.start=T(R.em.start).replace(/punctuation/g,R._punctuation).getRegex(),R.em.middle=T(R.em.middle).replace(/punctuation/g,R._punctuation).replace(/overlapSkip/g,R._overlapSkip).getRegex(),R.em.endAst=T(R.em.endAst,"g").replace(/punctuation/g,R._punctuation).getRegex(),R.em.endUnd=T(R.em.endUnd,"g").replace(/punctuation/g,R._punctuation).getRegex(),R.strong.start=T(R.strong.start).replace(/punctuation/g,R._punctuation).getRegex(),R.strong.middle=T(R.strong.middle).replace(/punctuation/g,R._punctuation).replace(/overlapSkip/g,R._overlapSkip).getRegex(),R.strong.endAst=T(R.strong.endAst,"g").replace(/punctuation/g,R._punctuation).getRegex(),R.strong.endUnd=T(R.strong.endUnd,"g").replace(/punctuation/g,R._punctuation).getRegex(),R.blockSkip=T(R._blockSkip,"g").getRegex(),R.overlapSkip=T(R._overlapSkip,"g").getRegex(),R._escapes=/\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g,R._scheme=/[a-zA-Z][a-zA-Z0-9+.-]{1,31}/,R._email=/[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/,R.autolink=T(R.autolink).replace("scheme",R._scheme).replace("email",R._email).getRegex(),R._attribute=/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/,R.tag=T(R.tag).replace("comment",R._comment).replace("attribute",R._attribute).getRegex(),R._label=/(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/,R._href=/<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/,R._title=/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/,R.link=T(R.link).replace("label",R._label).replace("href",R._href).replace("title",R._title).getRegex(),R.reflink=T(R.reflink).replace("label",R._label).getRegex(),R.reflinkSearch=T(R.reflinkSearch,"g").replace("reflink",R.reflink).replace("nolink",R.nolink).getRegex(),R.normal=S({},R),R.pedantic=S({},R.normal,{strong:{start:/^__|\*\*/,middle:/^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,endAst:/\*\*(?!\*)/g,endUnd:/__(?!_)/g},em:{start:/^_|\*/,middle:/^()\*(?=\S)([\s\S]*?\S)\*(?!\*)|^_(?=\S)([\s\S]*?\S)_(?!_)/,endAst:/\*(?!\*)/g,endUnd:/_(?!_)/g},link:T(/^!?\[(label)\]\((.*?)\)/).replace("label",R._label).getRegex(),reflink:T(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label",R._label).getRegex()}),R.gfm=S({},R.normal,{escape:T(R.escape).replace("])","~|])").getRegex(),_extended_email:/[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,url:/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,_backpedal:/(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,del:/^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,text:/^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/}),R.gfm.url=T(R.gfm.url,"i").replace("email",R.gfm._extended_email).getRegex(),R.breaks=S({},R.gfm,{br:T(R.br).replace("{2,}","*").getRegex(),text:T(R.gfm.text).replace("\\b_","\\b_| {2,}\\n").replace(/\{2,\}/g,"*").getRegex()});var R={block:z,inline:R},L=t.defaults,D=R.block,N=R.inline,B=Z;function F(e){return e.replace(/---/g,"—").replace(/--/g,"–").replace(/(^|[-\u2014/(\[{"\s])'/g,"$1‘").replace(/'/g,"’").replace(/(^|[-\u2014/(\[{\u2018\s])"/g,"$1“").replace(/"/g,"”").replace(/\.{3}/g,"…")}function M(e){for(var t,n="",r=e.length,i=0;i<r;i++)t=e.charCodeAt(i),n+="&#"+(t=.5<Math.random()?"x"+t.toString(16):t)+";";return n}var X=function(){function n(e){this.tokens=[],this.tokens.links=Object.create(null),this.options=e||L,this.options.tokenizer=this.options.tokenizer||new P,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options;e={block:D.normal,inline:N.normal};this.options.pedantic?(e.block=D.pedantic,e.inline=N.pedantic):this.options.gfm&&(e.block=D.gfm,this.options.breaks?e.inline=N.breaks:e.inline=N.gfm),this.tokenizer.rules=e}n.lex=function(e,t){return new n(t).lex(e)},n.lexInline=function(e,t){return new n(t).inlineTokens(e)};var e,t,r=n.prototype;return r.lex=function(e){return e=e.replace(/\r\n|\r/g,"\n").replace(/\t/g,"    "),this.blockTokens(e,this.tokens,!0),this.inline(this.tokens),this.tokens},r.blockTokens=function(e,t,n){var r,i,s,l;for(void 0===t&&(t=[]),void 0===n&&(n=!0),this.options.pedantic&&(e=e.replace(/^ +$/gm,""));e;)if(r=this.tokenizer.space(e))e=e.substring(r.raw.length),r.type&&t.push(r);else if(r=this.tokenizer.code(e,t))e=e.substring(r.raw.length),r.type?t.push(r):((l=t[t.length-1]).raw+="\n"+r.raw,l.text+="\n"+r.text);else if(r=this.tokenizer.fences(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.heading(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.nptable(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.hr(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.blockquote(e))e=e.substring(r.raw.length),r.tokens=this.blockTokens(r.text,[],n),t.push(r);else if(r=this.tokenizer.list(e)){for(e=e.substring(r.raw.length),s=r.items.length,i=0;i<s;i++)r.items[i].tokens=this.blockTokens(r.items[i].text,[],!1);t.push(r)}else if(r=this.tokenizer.html(e))e=e.substring(r.raw.length),t.push(r);else if(n&&(r=this.tokenizer.def(e)))e=e.substring(r.raw.length),this.tokens.links[r.tag]||(this.tokens.links[r.tag]={href:r.href,title:r.title});else if(r=this.tokenizer.table(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.lheading(e))e=e.substring(r.raw.length),t.push(r);else if(n&&(r=this.tokenizer.paragraph(e)))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.text(e,t))e=e.substring(r.raw.length),r.type?t.push(r):((l=t[t.length-1]).raw+="\n"+r.raw,l.text+="\n"+r.text);else if(e){var a="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(a);break}throw new Error(a)}return t},r.inline=function(e){for(var t,n,r,i,s,l=e.length,a=0;a<l;a++)switch((s=e[a]).type){case"paragraph":case"text":case"heading":s.tokens=[],this.inlineTokens(s.text,s.tokens);break;case"table":for(s.tokens={header:[],cells:[]},r=s.header.length,t=0;t<r;t++)s.tokens.header[t]=[],this.inlineTokens(s.header[t],s.tokens.header[t]);for(r=s.cells.length,t=0;t<r;t++)for(i=s.cells[t],s.tokens.cells[t]=[],n=0;n<i.length;n++)s.tokens.cells[t][n]=[],this.inlineTokens(i[n],s.tokens.cells[t][n]);break;case"blockquote":this.inline(s.tokens);break;case"list":for(r=s.items.length,t=0;t<r;t++)this.inline(s.items[t].tokens)}return e},r.inlineTokens=function(e,t,n,r){var i;void 0===t&&(t=[]),void 0===n&&(n=!1),void 0===r&&(r=!1);var s,l,a,o=e;if(this.tokens.links){var c=Object.keys(this.tokens.links);if(0<c.length)for(;null!=(s=this.tokenizer.rules.inline.reflinkSearch.exec(o));)c.includes(s[0].slice(s[0].lastIndexOf("[")+1,-1))&&(o=o.slice(0,s.index)+"["+B("a",s[0].length-2)+"]"+o.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;null!=(s=this.tokenizer.rules.inline.blockSkip.exec(o));)o=o.slice(0,s.index)+"["+B("a",s[0].length-2)+"]"+o.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);for(;e;)if(l||(a=""),l=!1,i=this.tokenizer.escape(e))e=e.substring(i.raw.length),t.push(i);else if(i=this.tokenizer.tag(e,n,r))e=e.substring(i.raw.length),n=i.inLink,r=i.inRawBlock,t.push(i);else if(i=this.tokenizer.link(e))e=e.substring(i.raw.length),"link"===i.type&&(i.tokens=this.inlineTokens(i.text,[],!0,r)),t.push(i);else if(i=this.tokenizer.reflink(e,this.tokens.links))e=e.substring(i.raw.length),"link"===i.type&&(i.tokens=this.inlineTokens(i.text,[],!0,r)),t.push(i);else if(i=this.tokenizer.strong(e,o,a))e=e.substring(i.raw.length),i.tokens=this.inlineTokens(i.text,[],n,r),t.push(i);else if(i=this.tokenizer.em(e,o,a))e=e.substring(i.raw.length),i.tokens=this.inlineTokens(i.text,[],n,r),t.push(i);else if(i=this.tokenizer.codespan(e))e=e.substring(i.raw.length),t.push(i);else if(i=this.tokenizer.br(e))e=e.substring(i.raw.length),t.push(i);else if(i=this.tokenizer.del(e))e=e.substring(i.raw.length),i.tokens=this.inlineTokens(i.text,[],n,r),t.push(i);else if(i=this.tokenizer.autolink(e,M))e=e.substring(i.raw.length),t.push(i);else if(n||!(i=this.tokenizer.url(e,M))){if(i=this.tokenizer.inlineText(e,r,F))e=e.substring(i.raw.length),a=i.raw.slice(-1),l=!0,t.push(i);else if(e){var u="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(u);break}throw new Error(u)}}else e=e.substring(i.raw.length),t.push(i);return t},e=n,t=[{key:"rules",get:function(){return{block:D,inline:N}}}],(r=null)&&i(e.prototype,r),t&&i(e,t),n}(),G=t.defaults,V=$,H=_,J=function(){function e(e){this.options=e||G}var t=e.prototype;return t.code=function(e,t,n){var r=(t||"").match(/\S*/)[0];return!this.options.highlight||null!=(t=this.options.highlight(e,r))&&t!==e&&(n=!0,e=t),e=e.replace(/\n$/,"")+"\n",r?'<pre><code class="'+this.options.langPrefix+H(r,!0)+'">'+(n?e:H(e,!0))+"</code></pre>\n":"<pre><code>"+(n?e:H(e,!0))+"</code></pre>\n"},t.blockquote=function(e){return"<blockquote>\n"+e+"</blockquote>\n"},t.html=function(e){return e},t.heading=function(e,t,n,r){return this.options.headerIds?"<h"+t+' id="'+this.options.headerPrefix+r.slug(n)+'">'+e+"</h"+t+">\n":"<h"+t+">"+e+"</h"+t+">\n"},t.hr=function(){return this.options.xhtml?"<hr/>\n":"<hr>\n"},t.list=function(e,t,n){var r=t?"ol":"ul";return"<"+r+(t&&1!==n?' start="'+n+'"':"")+">\n"+e+"</"+r+">\n"},t.listitem=function(e){return"<li>"+e+"</li>\n"},t.checkbox=function(e){return"<input "+(e?'checked="" ':"")+'disabled="" type="checkbox"'+(this.options.xhtml?" /":"")+"> "},t.paragraph=function(e){return"<p>"+e+"</p>\n"},t.table=function(e,t){return"<table>\n<thead>\n"+e+"</thead>\n"+(t=t&&"<tbody>"+t+"</tbody>")+"</table>\n"},t.tablerow=function(e){return"<tr>\n"+e+"</tr>\n"},t.tablecell=function(e,t){var n=t.header?"th":"td";return(t.align?"<"+n+' align="'+t.align+'">':"<"+n+">")+e+"</"+n+">\n"},t.strong=function(e){return"<strong>"+e+"</strong>"},t.em=function(e){return"<em>"+e+"</em>"},t.codespan=function(e){return"<code>"+e+"</code>"},t.br=function(){return this.options.xhtml?"<br/>":"<br>"},t.del=function(e){return"<del>"+e+"</del>"},t.link=function(e,t,n){if(null===(e=V(this.options.sanitize,this.options.baseUrl,e)))return n;e='<a href="'+H(e)+'"';return t&&(e+=' title="'+t+'"'),e+=">"+n+"</a>"},t.image=function(e,t,n){if(null===(e=V(this.options.sanitize,this.options.baseUrl,e)))return n;n='<img src="'+e+'" alt="'+n+'"';return t&&(n+=' title="'+t+'"'),n+=this.options.xhtml?"/>":">"},t.text=function(e){return e},e}(),K=function(){function e(){}var t=e.prototype;return t.strong=function(e){return e},t.em=function(e){return e},t.codespan=function(e){return e},t.del=function(e){return e},t.html=function(e){return e},t.text=function(e){return e},t.link=function(e,t,n){return""+n},t.image=function(e,t,n){return""+n},t.br=function(){return""},e}(),Q=function(){function e(){this.seen={}}var t=e.prototype;return t.serialize=function(e){return e.toLowerCase().trim().replace(/<[!\/a-z].*?>/gi,"").replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g,"").replace(/\s/g,"-")},t.getNextSafeSlug=function(e,t){var n=e,r=0;if(this.seen.hasOwnProperty(n))for(r=this.seen[e];n=e+"-"+ ++r,this.seen.hasOwnProperty(n););return t||(this.seen[e]=r,this.seen[n]=0),n},t.slug=function(e,t){void 0===t&&(t={});var n=this.serialize(e);return this.getNextSafeSlug(n,t.dryrun)},e}(),W=t.defaults,Y=y,ee=function(){function n(e){this.options=e||W,this.options.renderer=this.options.renderer||new J,this.renderer=this.options.renderer,this.renderer.options=this.options,this.textRenderer=new K,this.slugger=new Q}n.parse=function(e,t){return new n(t).parse(e)},n.parseInline=function(e,t){return new n(t).parseInline(e)};var e=n.prototype;return e.parse=function(e,t){void 0===t&&(t=!0);for(var n,r,i,s,l,a,o,c,u,p,h,g,f,d,k,b="",m=e.length,x=0;x<m;x++)switch((c=e[x]).type){case"space":continue;case"hr":b+=this.renderer.hr();continue;case"heading":b+=this.renderer.heading(this.parseInline(c.tokens),c.depth,Y(this.parseInline(c.tokens,this.textRenderer)),this.slugger);continue;case"code":b+=this.renderer.code(c.text,c.lang,c.escaped);continue;case"table":for(a=u="",i=c.header.length,n=0;n<i;n++)a+=this.renderer.tablecell(this.parseInline(c.tokens.header[n]),{header:!0,align:c.align[n]});for(u+=this.renderer.tablerow(a),o="",i=c.cells.length,n=0;n<i;n++){for(a="",s=(l=c.tokens.cells[n]).length,r=0;r<s;r++)a+=this.renderer.tablecell(this.parseInline(l[r]),{header:!1,align:c.align[r]});o+=this.renderer.tablerow(a)}b+=this.renderer.table(u,o);continue;case"blockquote":o=this.parse(c.tokens),b+=this.renderer.blockquote(o);continue;case"list":for(u=c.ordered,w=c.start,p=c.loose,i=c.items.length,o="",n=0;n<i;n++)f=(g=c.items[n]).checked,d=g.task,h="",g.task&&(k=this.renderer.checkbox(f),p?0<g.tokens.length&&"text"===g.tokens[0].type?(g.tokens[0].text=k+" "+g.tokens[0].text,g.tokens[0].tokens&&0<g.tokens[0].tokens.length&&"text"===g.tokens[0].tokens[0].type&&(g.tokens[0].tokens[0].text=k+" "+g.tokens[0].tokens[0].text)):g.tokens.unshift({type:"text",text:k}):h+=k),h+=this.parse(g.tokens,p),o+=this.renderer.listitem(h,d,f);b+=this.renderer.list(o,u,w);continue;case"html":b+=this.renderer.html(c.text);continue;case"paragraph":b+=this.renderer.paragraph(this.parseInline(c.tokens));continue;case"text":for(o=c.tokens?this.parseInline(c.tokens):c.text;x+1<m&&"text"===e[x+1].type;)o+="\n"+((c=e[++x]).tokens?this.parseInline(c.tokens):c.text);b+=t?this.renderer.paragraph(o):o;continue;default:var w='Token with "'+c.type+'" type was not found.';if(this.options.silent)return void console.error(w);throw new Error(w)}return b},e.parseInline=function(e,t){t=t||this.renderer;for(var n,r="",i=e.length,s=0;s<i;s++)switch((n=e[s]).type){case"escape":r+=t.text(n.text);break;case"html":r+=t.html(n.text);break;case"link":r+=t.link(n.href,n.title,this.parseInline(n.tokens,t));break;case"image":r+=t.image(n.href,n.title,n.text);break;case"strong":r+=t.strong(this.parseInline(n.tokens,t));break;case"em":r+=t.em(this.parseInline(n.tokens,t));break;case"codespan":r+=t.codespan(n.text);break;case"br":r+=t.br();break;case"del":r+=t.del(this.parseInline(n.tokens,t));break;case"text":r+=t.text(n.text);break;default:var l='Token with "'+n.type+'" type was not found.';if(this.options.silent)return void console.error(l);throw new Error(l)}return r},n}(),te=A,ne=I,re=_,_=t.getDefaults,ie=t.changeDefaults,t=t.defaults;function se(e,n,r){if(null==e)throw new Error("marked(): input parameter is undefined or null");if("string"!=typeof e)throw new Error("marked(): input parameter is of type "+Object.prototype.toString.call(e)+", string expected");if("function"==typeof n&&(r=n,n=null),n=te({},se.defaults,n||{}),ne(n),r){var i,s=n.highlight;try{i=X.lex(e,n)}catch(e){return r(e)}var l=function(t){var e;if(!t)try{e=ee.parse(i,n)}catch(e){t=e}return n.highlight=s,t?r(t):r(null,e)};if(!s||s.length<3)return l();if(delete n.highlight,!i.length)return l();var a=0;return se.walkTokens(i,function(n){"code"===n.type&&(a++,setTimeout(function(){s(n.text,n.lang,function(e,t){return e?l(e):(null!=t&&t!==n.text&&(n.text=t,n.escaped=!0),void(0===--a&&l()))})},0))}),void(0===a&&l())}try{var t=X.lex(e,n);return n.walkTokens&&se.walkTokens(t,n.walkTokens),ee.parse(t,n)}catch(e){if(e.message+="\nPlease report this to https://github.com/markedjs/marked.",n.silent)return"<p>An error occurred:</p><pre>"+re(e.message+"",!0)+"</pre>";throw e}}return se.options=se.setOptions=function(e){return te(se.defaults,e),ie(se.defaults),se},se.getDefaults=_,se.defaults=t,se.use=function(a){var t,n=te({},a);a.renderer&&function(){var e,l=se.defaults.renderer||new J;for(e in a.renderer)!function(i){var s=l[i];l[i]=function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];var r=a.renderer[i].apply(l,t);return r=!1===r?s.apply(l,t):r}}(e);n.renderer=l}(),a.tokenizer&&function(){var e,l=se.defaults.tokenizer||new P;for(e in a.tokenizer)!function(i){var s=l[i];l[i]=function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];var r=a.tokenizer[i].apply(l,t);return r=!1===r?s.apply(l,t):r}}(e);n.tokenizer=l}(),a.walkTokens&&(t=se.defaults.walkTokens,n.walkTokens=function(e){a.walkTokens(e),t&&t(e)}),se.setOptions(n)},se.walkTokens=function(e,t){for(var n,r=p(e);!(n=r()).done;){var i=n.value;switch(t(i),i.type){case"table":for(var s=p(i.tokens.header);!(l=s()).done;){var l=l.value;se.walkTokens(l,t)}for(var a,o=p(i.tokens.cells);!(a=o()).done;)for(var c=p(a.value);!(u=c()).done;){var u=u.value;se.walkTokens(u,t)}break;case"list":se.walkTokens(i.items,t);break;default:i.tokens&&se.walkTokens(i.tokens,t)}}},se.parseInline=function(e,t){if(null==e)throw new Error("marked.parseInline(): input parameter is undefined or null");if("string"!=typeof e)throw new Error("marked.parseInline(): input parameter is of type "+Object.prototype.toString.call(e)+", string expected");t=te({},se.defaults,t||{}),ne(t);try{var n=X.lexInline(e,t);return t.walkTokens&&se.walkTokens(n,t.walkTokens),ee.parseInline(n,t)}catch(e){if(e.message+="\nPlease report this to https://github.com/markedjs/marked.",t.silent)return"<p>An error occurred:</p><pre>"+re(e.message+"",!0)+"</pre>";throw e}},se.Parser=ee,se.parser=ee.parse,se.Renderer=J,se.TextRenderer=K,se.Lexer=X,se.lexer=X.lex,se.Tokenizer=P,se.Slugger=Q,se.parse=se});
\ No newline at end of file
+!function(e,u){"object"==typeof exports&&"undefined"!=typeof module?module.exports=u():"function"==typeof define&&define.amd?define(u):(e="undefined"!=typeof globalThis?globalThis:e||self).marked=u()}(this,function(){"use strict";function r(e,u){for(var t=0;t<u.length;t++){var n=u[t];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}function i(e,u){(null==u||u>e.length)&&(u=e.length);for(var t=0,n=new Array(u);t<u;t++)n[t]=e[t];return n}function c(e,u){var t;if("undefined"!=typeof Symbol&&null!=e[Symbol.iterator])return(t=e[Symbol.iterator]()).next.bind(t);if(Array.isArray(e)||(t=function(e,u){if(e){if("string"==typeof e)return i(e,u);var t=Object.prototype.toString.call(e).slice(8,-1);return"Map"===(t="Object"===t&&e.constructor?e.constructor.name:t)||"Set"===t?Array.from(e):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?i(e,u):void 0}}(e))||u&&e&&"number"==typeof e.length){t&&(e=t);var n=0;return function(){return n>=e.length?{done:!0}:{done:!1,value:e[n++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}function t(e){return D[e]}var e,u=(function(u){function e(){return{baseUrl:null,breaks:!1,gfm:!0,headerIds:!0,headerPrefix:"",highlight:null,langPrefix:"language-",mangle:!0,pedantic:!1,renderer:null,sanitize:!1,sanitizer:null,silent:!1,smartLists:!1,smartypants:!1,tokenizer:null,walkTokens:null,xhtml:!1}}u.exports={defaults:e(),getDefaults:e,changeDefaults:function(e){u.exports.defaults=e}}}(e={exports:{}}),e.exports),n=/[&<>"']/,s=/[&<>"']/g,l=/[<>"']|&(?!#?\w+;)/,a=/[<>"']|&(?!#?\w+;)/g,D={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"};var o=/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/gi;function h(e){return e.replace(o,function(e,u){return"colon"===(u=u.toLowerCase())?":":"#"===u.charAt(0)?"x"===u.charAt(1)?String.fromCharCode(parseInt(u.substring(2),16)):String.fromCharCode(+u.substring(1)):""})}var p=/(^|[^\[])\^/g;var g=/[^\w:]/g,f=/^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;var F={},A=/^[^:]+:\/*[^/]*$/,C=/^([^:]+:)[\s\S]*$/,d=/^([^:]+:\/*[^/]*)[\s\S]*$/;function E(e,u){F[" "+e]||(A.test(e)?F[" "+e]=e+"/":F[" "+e]=k(e,"/",!0));var t=-1===(e=F[" "+e]).indexOf(":");return"//"===u.substring(0,2)?t?u:e.replace(C,"$1")+u:"/"===u.charAt(0)?t?u:e.replace(d,"$1")+u:e+u}function k(e,u,t){var n=e.length;if(0===n)return"";for(var r=0;r<n;){var i=e.charAt(n-r-1);if(i!==u||t){if(i===u||!t)break;r++}else r++}return e.substr(0,n-r)}var m=function(e,u){if(u){if(n.test(e))return e.replace(s,t)}else if(l.test(e))return e.replace(a,t);return e},b=h,x=function(t,e){t=t.source||t,e=e||"";var n={replace:function(e,u){return u=(u=u.source||u).replace(p,"$1"),t=t.replace(e,u),n},getRegex:function(){return new RegExp(t,e)}};return n},B=function(e,u,t){if(e){var n;try{n=decodeURIComponent(h(t)).replace(g,"").toLowerCase()}catch(e){return null}if(0===n.indexOf("javascript:")||0===n.indexOf("vbscript:")||0===n.indexOf("data:"))return null}u&&!f.test(t)&&(t=E(u,t));try{t=encodeURI(t).replace(/%25/g,"%")}catch(e){return null}return t},w={exec:function(){}},v=function(e){for(var u,t,n=1;n<arguments.length;n++)for(t in u=arguments[n])Object.prototype.hasOwnProperty.call(u,t)&&(e[t]=u[t]);return e},y=function(e,u){var t=e.replace(/\|/g,function(e,u,t){for(var n=!1,r=u;0<=--r&&"\\"===t[r];)n=!n;return n?"|":" |"}).split(/ \|/),n=0;if(t.length>u)t.splice(u);else for(;t.length<u;)t.push("");for(;n<t.length;n++)t[n]=t[n].trim().replace(/\\\|/g,"|");return t},_=function(e,u){if(-1===e.indexOf(u[1]))return-1;for(var t=e.length,n=0,r=0;r<t;r++)if("\\"===e[r])r++;else if(e[r]===u[0])n++;else if(e[r]===u[1]&&--n<0)return r;return-1},z=function(e){e&&e.sanitize&&!e.silent&&console.warn("marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options")},$=function(e,u){if(u<1)return"";for(var t="";1<u;)1&u&&(t+=e),u>>=1,e+=e;return t+e},S=u.defaults,T=k,I=y,R=m,Z=_;function q(e,u,t){var n=u.href,r=u.title?R(u.title):null,u=e[1].replace(/\\([\[\]])/g,"$1");return"!"!==e[0].charAt(0)?{type:"link",raw:t,href:n,title:r,text:u}:{type:"image",raw:t,href:n,title:r,text:R(u)}}var O=function(){function e(e){this.options=e||S}var u=e.prototype;return u.space=function(e){e=this.rules.block.newline.exec(e);if(e)return 1<e[0].length?{type:"space",raw:e[0]}:{raw:"\n"}},u.code=function(e,u){e=this.rules.block.code.exec(e);if(e){u=u[u.length-1];if(u&&"paragraph"===u.type)return{raw:e[0],text:e[0].trimRight()};u=e[0].replace(/^ {1,4}/gm,"");return{type:"code",raw:e[0],codeBlockStyle:"indented",text:this.options.pedantic?u:T(u,"\n")}}},u.fences=function(e){var u=this.rules.block.fences.exec(e);if(u){var t=u[0],e=function(e,u){if(null===(e=e.match(/^(\s+)(?:```)/)))return u;var t=e[1];return u.split("\n").map(function(e){var u=e.match(/^\s+/);return null!==u&&u[0].length>=t.length?e.slice(t.length):e}).join("\n")}(t,u[3]||"");return{type:"code",raw:t,lang:u[2]&&u[2].trim(),text:e}}},u.heading=function(e){var u=this.rules.block.heading.exec(e);if(u){var t=u[2].trim();return/#$/.test(t)&&(e=T(t,"#"),!this.options.pedantic&&e&&!/ $/.test(e)||(t=e.trim())),{type:"heading",raw:u[0],depth:u[1].length,text:t}}},u.nptable=function(e){e=this.rules.block.nptable.exec(e);if(e){var u={type:"table",header:I(e[1].replace(/^ *| *\| *$/g,"")),align:e[2].replace(/^ *|\| *$/g,"").split(/ *\| */),cells:e[3]?e[3].replace(/\n$/,"").split("\n"):[],raw:e[0]};if(u.header.length===u.align.length){for(var t=u.align.length,n=0;n<t;n++)/^ *-+: *$/.test(u.align[n])?u.align[n]="right":/^ *:-+: *$/.test(u.align[n])?u.align[n]="center":/^ *:-+ *$/.test(u.align[n])?u.align[n]="left":u.align[n]=null;for(t=u.cells.length,n=0;n<t;n++)u.cells[n]=I(u.cells[n],u.header.length);return u}}},u.hr=function(e){e=this.rules.block.hr.exec(e);if(e)return{type:"hr",raw:e[0]}},u.blockquote=function(e){var u=this.rules.block.blockquote.exec(e);if(u){e=u[0].replace(/^ *> ?/gm,"");return{type:"blockquote",raw:u[0],text:e}}},u.list=function(e){e=this.rules.block.list.exec(e);if(e){for(var u,t,n,r,i,s=e[0],l=e[2],a=1<l.length,D={type:"list",raw:s,ordered:a,start:a?+l.slice(0,-1):"",loose:!1,items:[]},o=e[0].match(this.rules.block.item),c=!1,h=o.length,p=this.rules.block.listItemStart.exec(o[0]),g=0;g<h;g++){if(s=u=o[g],g!==h-1){if(n=this.rules.block.listItemStart.exec(o[g+1]),this.options.pedantic?n[1].length>p[1].length:n[1].length>p[0].length||3<n[1].length){o.splice(g,2,o[g]+"\n"+o[g+1]),g--,h--;continue}(!this.options.pedantic||this.options.smartLists?n[2][n[2].length-1]!==l[l.length-1]:a==(1===n[2].length))&&(t=o.slice(g+1).join("\n"),D.raw=D.raw.substring(0,D.raw.length-t.length),g=h-1),p=n}n=u.length,~(u=u.replace(/^ *([*+-]|\d+[.)]) ?/,"")).indexOf("\n ")&&(n-=u.length,u=this.options.pedantic?u.replace(/^ {1,4}/gm,""):u.replace(new RegExp("^ {1,"+n+"}","gm"),"")),n=c||/\n\n(?!\s*$)/.test(u),g!==h-1&&(c="\n"===u.charAt(u.length-1),n=n||c),n&&(D.loose=!0),this.options.gfm&&(i=void 0,(r=/^\[[ xX]\] /.test(u))&&(i=" "!==u[1],u=u.replace(/^\[[ xX]\] +/,""))),D.items.push({type:"list_item",raw:s,task:r,checked:i,loose:n,text:u})}return D}},u.html=function(e){e=this.rules.block.html.exec(e);if(e)return{type:this.options.sanitize?"paragraph":"html",raw:e[0],pre:!this.options.sanitizer&&("pre"===e[1]||"script"===e[1]||"style"===e[1]),text:this.options.sanitize?this.options.sanitizer?this.options.sanitizer(e[0]):R(e[0]):e[0]}},u.def=function(e){e=this.rules.block.def.exec(e);if(e)return e[3]&&(e[3]=e[3].substring(1,e[3].length-1)),{tag:e[1].toLowerCase().replace(/\s+/g," "),raw:e[0],href:e[2],title:e[3]}},u.table=function(e){e=this.rules.block.table.exec(e);if(e){var u={type:"table",header:I(e[1].replace(/^ *| *\| *$/g,"")),align:e[2].replace(/^ *|\| *$/g,"").split(/ *\| */),cells:e[3]?e[3].replace(/\n$/,"").split("\n"):[]};if(u.header.length===u.align.length){u.raw=e[0];for(var t=u.align.length,n=0;n<t;n++)/^ *-+: *$/.test(u.align[n])?u.align[n]="right":/^ *:-+: *$/.test(u.align[n])?u.align[n]="center":/^ *:-+ *$/.test(u.align[n])?u.align[n]="left":u.align[n]=null;for(t=u.cells.length,n=0;n<t;n++)u.cells[n]=I(u.cells[n].replace(/^ *\| *| *\| *$/g,""),u.header.length);return u}}},u.lheading=function(e){e=this.rules.block.lheading.exec(e);if(e)return{type:"heading",raw:e[0],depth:"="===e[2].charAt(0)?1:2,text:e[1]}},u.paragraph=function(e){e=this.rules.block.paragraph.exec(e);if(e)return{type:"paragraph",raw:e[0],text:"\n"===e[1].charAt(e[1].length-1)?e[1].slice(0,-1):e[1]}},u.text=function(e,u){e=this.rules.block.text.exec(e);if(e){u=u[u.length-1];return u&&"text"===u.type?{raw:e[0],text:e[0]}:{type:"text",raw:e[0],text:e[0]}}},u.escape=function(e){e=this.rules.inline.escape.exec(e);if(e)return{type:"escape",raw:e[0],text:R(e[1])}},u.tag=function(e,u,t){e=this.rules.inline.tag.exec(e);if(e)return!u&&/^<a /i.test(e[0])?u=!0:u&&/^<\/a>/i.test(e[0])&&(u=!1),!t&&/^<(pre|code|kbd|script)(\s|>)/i.test(e[0])?t=!0:t&&/^<\/(pre|code|kbd|script)(\s|>)/i.test(e[0])&&(t=!1),{type:this.options.sanitize?"text":"html",raw:e[0],inLink:u,inRawBlock:t,text:this.options.sanitize?this.options.sanitizer?this.options.sanitizer(e[0]):R(e[0]):e[0]}},u.link=function(e){var u=this.rules.inline.link.exec(e);if(u){var t=u[2].trim();if(!this.options.pedantic&&/^</.test(t)){if(!/>$/.test(t))return;e=T(t.slice(0,-1),"\\");if((t.length-e.length)%2==0)return}else{var n=Z(u[2],"()");-1<n&&(i=(0===u[0].indexOf("!")?5:4)+u[1].length+n,u[2]=u[2].substring(0,n),u[0]=u[0].substring(0,i).trim(),u[3]="")}var r,n=u[2],i="";return this.options.pedantic?(r=/^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(n))&&(n=r[1],i=r[3]):i=u[3]?u[3].slice(1,-1):"",n=n.trim(),q(u,{href:(n=/^</.test(n)?this.options.pedantic&&!/>$/.test(t)?n.slice(1):n.slice(1,-1):n)&&n.replace(this.rules.inline._escapes,"$1"),title:i&&i.replace(this.rules.inline._escapes,"$1")},u[0])}},u.reflink=function(e,u){if((t=this.rules.inline.reflink.exec(e))||(t=this.rules.inline.nolink.exec(e))){e=(t[2]||t[1]).replace(/\s+/g," ");if((e=u[e.toLowerCase()])&&e.href)return q(t,e,t[0]);var t=t[0].charAt(0);return{type:"text",raw:t,text:t}}},u.emStrong=function(e,u,t){void 0===t&&(t="");var n=this.rules.inline.emStrong.lDelim.exec(e);if(n&&(!n[3]||!t.match(/(?:[0-9A-Za-z\xAA\xB2\xB3\xB5\xB9\xBA\xBC-\xBE\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u0660-\u0669\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07C0-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0966-\u096F\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09E6-\u09F1\u09F4-\u09F9\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AE6-\u0AEF\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B66-\u0B6F\u0B71-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0BE6-\u0BF2\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C66-\u0C6F\u0C78-\u0C7E\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CE6-\u0CEF\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D58-\u0D61\u0D66-\u0D78\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DE6-\u0DEF\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F20-\u0F33\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F-\u1049\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u1090-\u1099\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1369-\u137C\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u17E0-\u17E9\u17F0-\u17F9\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A16\u1A20-\u1A54\u1A80-\u1A89\u1A90-\u1A99\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B50-\u1B59\u1B83-\u1BA0\u1BAE-\u1BE5\u1C00-\u1C23\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2070\u2071\u2074-\u2079\u207F-\u2089\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2150-\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2CFD\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u3192-\u3195\u31A0-\u31BF\u31F0-\u31FF\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA830-\uA835\uA840-\uA873\uA882-\uA8B3\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA900-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF-\uA9D9\uA9E0-\uA9E4\uA9E6-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD07-\uDD33\uDD40-\uDD78\uDD8A\uDD8B\uDE80-\uDE9C\uDEA0-\uDED0\uDEE1-\uDEFB\uDF00-\uDF23\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC58-\uDC76\uDC79-\uDC9E\uDCA7-\uDCAF\uDCE0-\uDCF2\uDCF4\uDCF5\uDCFB-\uDD1B\uDD20-\uDD39\uDD80-\uDDB7\uDDBC-\uDDCF\uDDD2-\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE40-\uDE48\uDE60-\uDE7E\uDE80-\uDE9F\uDEC0-\uDEC7\uDEC9-\uDEE4\uDEEB-\uDEEF\uDF00-\uDF35\uDF40-\uDF55\uDF58-\uDF72\uDF78-\uDF91\uDFA9-\uDFAF]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDCFA-\uDD23\uDD30-\uDD39\uDE60-\uDE7E\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF27\uDF30-\uDF45\uDF51-\uDF54\uDFB0-\uDFCB\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC52-\uDC6F\uDC83-\uDCAF\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD03-\uDD26\uDD36-\uDD3F\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDD0-\uDDDA\uDDDC\uDDE1-\uDDF4\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDEF0-\uDEF9\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC50-\uDC59\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE50-\uDE59\uDE80-\uDEAA\uDEB8\uDEC0-\uDEC9\uDF00-\uDF1A\uDF30-\uDF3B]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCF2\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDD50-\uDD59\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC50-\uDC6C\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD50-\uDD59\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDDA0-\uDDA9\uDEE0-\uDEF2\uDFB0\uDFC0-\uDFD4]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF50-\uDF59\uDF5B-\uDF61\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE96\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD834[\uDEE0-\uDEF3\uDF60-\uDF78]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD40-\uDD49\uDD4E\uDEC0-\uDEEB\uDEF0-\uDEF9]|\uD83A[\uDC00-\uDCC4\uDCC7-\uDCCF\uDD00-\uDD43\uDD4B\uDD50-\uDD59]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD83C[\uDD00-\uDD0C]|\uD83E[\uDFF0-\uDFF9]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A])/))){var r=n[1]||n[2]||"";if(!r||r&&(""===t||this.rules.inline.punctuation.exec(t))){var i,s=n[0].length-1,l=s,a=0,D="*"===n[0][0]?this.rules.inline.emStrong.rDelimAst:this.rules.inline.emStrong.rDelimUnd;for(D.lastIndex=0,u=u.slice(-1*e.length+s);null!=(n=D.exec(u));)if(i=n[1]||n[2]||n[3]||n[4]||n[5]||n[6])if(i=i.length,n[3]||n[4])l+=i;else if(!((n[5]||n[6])&&s%3)||(s+i)%3){if(!(0<(l-=i))){if(l+a-i<=0&&!u.slice(D.lastIndex).match(D)&&(i=Math.min(i,i+l+a)),Math.min(s,i)%2)return{type:"em",raw:e.slice(0,s+n.index+i+1),text:e.slice(1,s+n.index+i)};if(Math.min(s,i)%2==0)return{type:"strong",raw:e.slice(0,s+n.index+i+1),text:e.slice(2,s+n.index+i-1)}}}else a+=i}}},u.codespan=function(e){var u=this.rules.inline.code.exec(e);if(u){var t=u[2].replace(/\n/g," "),n=/[^ ]/.test(t),e=/^ /.test(t)&&/ $/.test(t);return n&&e&&(t=t.substring(1,t.length-1)),t=R(t,!0),{type:"codespan",raw:u[0],text:t}}},u.br=function(e){e=this.rules.inline.br.exec(e);if(e)return{type:"br",raw:e[0]}},u.del=function(e){e=this.rules.inline.del.exec(e);if(e)return{type:"del",raw:e[0],text:e[2]}},u.autolink=function(e,u){e=this.rules.inline.autolink.exec(e);if(e){var t,u="@"===e[2]?"mailto:"+(t=R(this.options.mangle?u(e[1]):e[1])):t=R(e[1]);return{type:"link",raw:e[0],text:t,href:u,tokens:[{type:"text",raw:t,text:t}]}}},u.url=function(e,u){var t,n,r,i;if(t=this.rules.inline.url.exec(e)){if("@"===t[2])r="mailto:"+(n=R(this.options.mangle?u(t[0]):t[0]));else{for(;i=t[0],t[0]=this.rules.inline._backpedal.exec(t[0])[0],i!==t[0];);n=R(t[0]),r="www."===t[1]?"http://"+n:n}return{type:"link",raw:t[0],text:n,href:r,tokens:[{type:"text",raw:n,text:n}]}}},u.inlineText=function(e,u,t){e=this.rules.inline.text.exec(e);if(e){t=u?this.options.sanitize?this.options.sanitizer?this.options.sanitizer(e[0]):R(e[0]):e[0]:R(this.options.smartypants?t(e[0]):e[0]);return{type:"text",raw:e[0],text:t}}},e}(),y=w,_=x,w=v,x={newline:/^(?: *(?:\n|$))+/,code:/^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,fences:/^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?:\n+|$)|$)/,hr:/^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,heading:/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,blockquote:/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,list:/^( {0,3})(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?! {0,3}bull )\n*|\s*$)/,html:"^ {0,3}(?:<(script|pre|style)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:\\n{2,}|$)|<(?!script|pre|style)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)|</(?!script|pre|style)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$))",def:/^ {0,3}\[(label)\]: *\n? *<?([^\s>]+)>?(?:(?: +\n? *| *\n *)(title))? *(?:\n+|$)/,nptable:y,table:y,lheading:/^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,_paragraph:/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html| +\n)[^\n]+)*)/,text:/^[^\n]+/,_label:/(?!\s*\])(?:\\[\[\]]|[^\[\]])+/,_title:/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/};x.def=_(x.def).replace("label",x._label).replace("title",x._title).getRegex(),x.bullet=/(?:[*+-]|\d{1,9}[.)])/,x.item=/^( *)(bull) ?[^\n]*(?:\n(?! *bull ?)[^\n]*)*/,x.item=_(x.item,"gm").replace(/bull/g,x.bullet).getRegex(),x.listItemStart=_(/^( *)(bull)/).replace("bull",x.bullet).getRegex(),x.list=_(x.list).replace(/bull/g,x.bullet).replace("hr","\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))").replace("def","\\n+(?="+x.def.source+")").getRegex(),x._tag="address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul",x._comment=/<!--(?!-?>)[\s\S]*?(?:-->|$)/,x.html=_(x.html,"i").replace("comment",x._comment).replace("tag",x._tag).replace("attribute",/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),x.paragraph=_(x._paragraph).replace("hr",x.hr).replace("heading"," {0,3}#{1,6} ").replace("|lheading","").replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)").replace("tag",x._tag).getRegex(),x.blockquote=_(x.blockquote).replace("paragraph",x.paragraph).getRegex(),x.normal=w({},x),x.gfm=w({},x.normal,{nptable:"^ *([^|\\n ].*\\|.*)\\n {0,3}([-:]+ *\\|[-| :]*)(?:\\n((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)",table:"^ *\\|(.+)\\n {0,3}\\|?( *[-:]+[-| :]*)(?:\\n *((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)"}),x.gfm.nptable=_(x.gfm.nptable).replace("hr",x.hr).replace("heading"," {0,3}#{1,6} ").replace("blockquote"," {0,3}>").replace("code"," {4}[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)").replace("tag",x._tag).getRegex(),x.gfm.table=_(x.gfm.table).replace("hr",x.hr).replace("heading"," {0,3}#{1,6} ").replace("blockquote"," {0,3}>").replace("code"," {4}[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)").replace("tag",x._tag).getRegex(),x.pedantic=w({},x.normal,{html:_("^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:\"[^\"]*\"|'[^']*'|\\s[^'\"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))").replace("comment",x._comment).replace(/tag/g,"(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),def:/^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,heading:/^(#{1,6})(.*)(?:\n+|$)/,fences:y,paragraph:_(x.normal._paragraph).replace("hr",x.hr).replace("heading"," *#{1,6} *[^\n]").replace("lheading",x.lheading).replace("blockquote"," {0,3}>").replace("|fences","").replace("|list","").replace("|html","").getRegex()});y={escape:/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,autolink:/^<(scheme:[^\s\x00-\x1f<>]*|email)>/,url:y,tag:"^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>",link:/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,reflink:/^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,nolink:/^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,reflinkSearch:"reflink|nolink(?!\\()",emStrong:{lDelim:/^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/,rDelimAst:/\_\_[^_]*?\*[^_]*?\_\_|[punct_](\*+)(?=[\s]|$)|[^punct*_\s](\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|[^punct*_\s](\*+)(?=[^punct*_\s])/,rDelimUnd:/\*\*[^*]*?\_[^*]*?\*\*|[punct*](\_+)(?=[\s]|$)|[^punct*_\s](\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/},code:/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,br:/^( {2,}|\\)\n(?!\s*$)/,del:y,text:/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,punctuation:/^([\spunctuation])/,_punctuation:"!\"#$%&'()+\\-.,/:;<=>?@\\[\\]`^{|}~"};y.punctuation=_(y.punctuation).replace(/punctuation/g,y._punctuation).getRegex(),y.blockSkip=/\[[^\]]*?\]\([^\)]*?\)|`[^`]*?`|<[^>]*?>/g,y.escapedEmSt=/\\\*|\\_/g,y._comment=_(x._comment).replace("(?:--\x3e|$)","--\x3e").getRegex(),y.emStrong.lDelim=_(y.emStrong.lDelim).replace(/punct/g,y._punctuation).getRegex(),y.emStrong.rDelimAst=_(y.emStrong.rDelimAst,"g").replace(/punct/g,y._punctuation).getRegex(),y.emStrong.rDelimUnd=_(y.emStrong.rDelimUnd,"g").replace(/punct/g,y._punctuation).getRegex(),y._escapes=/\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g,y._scheme=/[a-zA-Z][a-zA-Z0-9+.-]{1,31}/,y._email=/[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/,y.autolink=_(y.autolink).replace("scheme",y._scheme).replace("email",y._email).getRegex(),y._attribute=/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/,y.tag=_(y.tag).replace("comment",y._comment).replace("attribute",y._attribute).getRegex(),y._label=/(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/,y._href=/<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/,y._title=/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/,y.link=_(y.link).replace("label",y._label).replace("href",y._href).replace("title",y._title).getRegex(),y.reflink=_(y.reflink).replace("label",y._label).getRegex(),y.reflinkSearch=_(y.reflinkSearch,"g").replace("reflink",y.reflink).replace("nolink",y.nolink).getRegex(),y.normal=w({},y),y.pedantic=w({},y.normal,{strong:{start:/^__|\*\*/,middle:/^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,endAst:/\*\*(?!\*)/g,endUnd:/__(?!_)/g},em:{start:/^_|\*/,middle:/^()\*(?=\S)([\s\S]*?\S)\*(?!\*)|^_(?=\S)([\s\S]*?\S)_(?!_)/,endAst:/\*(?!\*)/g,endUnd:/_(?!_)/g},link:_(/^!?\[(label)\]\((.*?)\)/).replace("label",y._label).getRegex(),reflink:_(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label",y._label).getRegex()}),y.gfm=w({},y.normal,{escape:_(y.escape).replace("])","~|])").getRegex(),_extended_email:/[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,url:/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,_backpedal:/(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,del:/^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,text:/^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/}),y.gfm.url=_(y.gfm.url,"i").replace("email",y.gfm._extended_email).getRegex(),y.breaks=w({},y.gfm,{br:_(y.br).replace("{2,}","*").getRegex(),text:_(y.gfm.text).replace("\\b_","\\b_| {2,}\\n").replace(/\{2,\}/g,"*").getRegex()});var y={block:x,inline:y},j=u.defaults,U=y.block,P=y.inline,L=$;function M(e){return e.replace(/---/g,"—").replace(/--/g,"–").replace(/(^|[-\u2014/(\[{"\s])'/g,"$1‘").replace(/'/g,"’").replace(/(^|[-\u2014/(\[{\u2018\s])"/g,"$1“").replace(/"/g,"”").replace(/\.{3}/g,"…")}function N(e){for(var u,t="",n=e.length,r=0;r<n;r++)u=e.charCodeAt(r),t+="&#"+(u=.5<Math.random()?"x"+u.toString(16):u)+";";return t}var X=function(){function t(e){this.tokens=[],this.tokens.links=Object.create(null),this.options=e||j,this.options.tokenizer=this.options.tokenizer||new O,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options;e={block:U.normal,inline:P.normal};this.options.pedantic?(e.block=U.pedantic,e.inline=P.pedantic):this.options.gfm&&(e.block=U.gfm,this.options.breaks?e.inline=P.breaks:e.inline=P.gfm),this.tokenizer.rules=e}t.lex=function(e,u){return new t(u).lex(e)},t.lexInline=function(e,u){return new t(u).inlineTokens(e)};var e,u,n=t.prototype;return n.lex=function(e){return e=e.replace(/\r\n|\r/g,"\n").replace(/\t/g,"    "),this.blockTokens(e,this.tokens,!0),this.inline(this.tokens),this.tokens},n.blockTokens=function(e,u,t){var n,r,i,s;for(void 0===u&&(u=[]),void 0===t&&(t=!0),this.options.pedantic&&(e=e.replace(/^ +$/gm,""));e;)if(n=this.tokenizer.space(e))e=e.substring(n.raw.length),n.type&&u.push(n);else if(n=this.tokenizer.code(e,u))e=e.substring(n.raw.length),n.type?u.push(n):((s=u[u.length-1]).raw+="\n"+n.raw,s.text+="\n"+n.text);else if(n=this.tokenizer.fences(e))e=e.substring(n.raw.length),u.push(n);else if(n=this.tokenizer.heading(e))e=e.substring(n.raw.length),u.push(n);else if(n=this.tokenizer.nptable(e))e=e.substring(n.raw.length),u.push(n);else if(n=this.tokenizer.hr(e))e=e.substring(n.raw.length),u.push(n);else if(n=this.tokenizer.blockquote(e))e=e.substring(n.raw.length),n.tokens=this.blockTokens(n.text,[],t),u.push(n);else if(n=this.tokenizer.list(e)){for(e=e.substring(n.raw.length),i=n.items.length,r=0;r<i;r++)n.items[r].tokens=this.blockTokens(n.items[r].text,[],!1);u.push(n)}else if(n=this.tokenizer.html(e))e=e.substring(n.raw.length),u.push(n);else if(t&&(n=this.tokenizer.def(e)))e=e.substring(n.raw.length),this.tokens.links[n.tag]||(this.tokens.links[n.tag]={href:n.href,title:n.title});else if(n=this.tokenizer.table(e))e=e.substring(n.raw.length),u.push(n);else if(n=this.tokenizer.lheading(e))e=e.substring(n.raw.length),u.push(n);else if(t&&(n=this.tokenizer.paragraph(e)))e=e.substring(n.raw.length),u.push(n);else if(n=this.tokenizer.text(e,u))e=e.substring(n.raw.length),n.type?u.push(n):((s=u[u.length-1]).raw+="\n"+n.raw,s.text+="\n"+n.text);else if(e){var l="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(l);break}throw new Error(l)}return u},n.inline=function(e){for(var u,t,n,r,i,s=e.length,l=0;l<s;l++)switch((i=e[l]).type){case"paragraph":case"text":case"heading":i.tokens=[],this.inlineTokens(i.text,i.tokens);break;case"table":for(i.tokens={header:[],cells:[]},n=i.header.length,u=0;u<n;u++)i.tokens.header[u]=[],this.inlineTokens(i.header[u],i.tokens.header[u]);for(n=i.cells.length,u=0;u<n;u++)for(r=i.cells[u],i.tokens.cells[u]=[],t=0;t<r.length;t++)i.tokens.cells[u][t]=[],this.inlineTokens(r[t],i.tokens.cells[u][t]);break;case"blockquote":this.inline(i.tokens);break;case"list":for(n=i.items.length,u=0;u<n;u++)this.inline(i.items[u].tokens)}return e},n.inlineTokens=function(e,u,t,n){var r;void 0===u&&(u=[]),void 0===t&&(t=!1),void 0===n&&(n=!1);var i,s,l,a=e;if(this.tokens.links){var D=Object.keys(this.tokens.links);if(0<D.length)for(;null!=(i=this.tokenizer.rules.inline.reflinkSearch.exec(a));)D.includes(i[0].slice(i[0].lastIndexOf("[")+1,-1))&&(a=a.slice(0,i.index)+"["+L("a",i[0].length-2)+"]"+a.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;null!=(i=this.tokenizer.rules.inline.blockSkip.exec(a));)a=a.slice(0,i.index)+"["+L("a",i[0].length-2)+"]"+a.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);for(;null!=(i=this.tokenizer.rules.inline.escapedEmSt.exec(a));)a=a.slice(0,i.index)+"++"+a.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex);for(;e;)if(s||(l=""),s=!1,r=this.tokenizer.escape(e))e=e.substring(r.raw.length),u.push(r);else if(r=this.tokenizer.tag(e,t,n))e=e.substring(r.raw.length),t=r.inLink,n=r.inRawBlock,u.push(r);else if(r=this.tokenizer.link(e))e=e.substring(r.raw.length),"link"===r.type&&(r.tokens=this.inlineTokens(r.text,[],!0,n)),u.push(r);else if(r=this.tokenizer.reflink(e,this.tokens.links))e=e.substring(r.raw.length),"link"===r.type&&(r.tokens=this.inlineTokens(r.text,[],!0,n)),u.push(r);else if(r=this.tokenizer.emStrong(e,a,l))e=e.substring(r.raw.length),r.tokens=this.inlineTokens(r.text,[],t,n),u.push(r);else if(r=this.tokenizer.codespan(e))e=e.substring(r.raw.length),u.push(r);else if(r=this.tokenizer.br(e))e=e.substring(r.raw.length),u.push(r);else if(r=this.tokenizer.del(e))e=e.substring(r.raw.length),r.tokens=this.inlineTokens(r.text,[],t,n),u.push(r);else if(r=this.tokenizer.autolink(e,N))e=e.substring(r.raw.length),u.push(r);else if(t||!(r=this.tokenizer.url(e,N))){if(r=this.tokenizer.inlineText(e,n,M))e=e.substring(r.raw.length),"_"!==r.raw.slice(-1)&&(l=r.raw.slice(-1)),s=!0,u.push(r);else if(e){var o="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(o);break}throw new Error(o)}}else e=e.substring(r.raw.length),u.push(r);return u},e=t,u=[{key:"rules",get:function(){return{block:U,inline:P}}}],(n=null)&&r(e.prototype,n),u&&r(e,u),t}(),G=u.defaults,V=B,H=m,J=function(){function e(e){this.options=e||G}var u=e.prototype;return u.code=function(e,u,t){var n=(u||"").match(/\S*/)[0];return!this.options.highlight||null!=(u=this.options.highlight(e,n))&&u!==e&&(t=!0,e=u),e=e.replace(/\n$/,"")+"\n",n?'<pre><code class="'+this.options.langPrefix+H(n,!0)+'">'+(t?e:H(e,!0))+"</code></pre>\n":"<pre><code>"+(t?e:H(e,!0))+"</code></pre>\n"},u.blockquote=function(e){return"<blockquote>\n"+e+"</blockquote>\n"},u.html=function(e){return e},u.heading=function(e,u,t,n){return this.options.headerIds?"<h"+u+' id="'+this.options.headerPrefix+n.slug(t)+'">'+e+"</h"+u+">\n":"<h"+u+">"+e+"</h"+u+">\n"},u.hr=function(){return this.options.xhtml?"<hr/>\n":"<hr>\n"},u.list=function(e,u,t){var n=u?"ol":"ul";return"<"+n+(u&&1!==t?' start="'+t+'"':"")+">\n"+e+"</"+n+">\n"},u.listitem=function(e){return"<li>"+e+"</li>\n"},u.checkbox=function(e){return"<input "+(e?'checked="" ':"")+'disabled="" type="checkbox"'+(this.options.xhtml?" /":"")+"> "},u.paragraph=function(e){return"<p>"+e+"</p>\n"},u.table=function(e,u){return"<table>\n<thead>\n"+e+"</thead>\n"+(u=u&&"<tbody>"+u+"</tbody>")+"</table>\n"},u.tablerow=function(e){return"<tr>\n"+e+"</tr>\n"},u.tablecell=function(e,u){var t=u.header?"th":"td";return(u.align?"<"+t+' align="'+u.align+'">':"<"+t+">")+e+"</"+t+">\n"},u.strong=function(e){return"<strong>"+e+"</strong>"},u.em=function(e){return"<em>"+e+"</em>"},u.codespan=function(e){return"<code>"+e+"</code>"},u.br=function(){return this.options.xhtml?"<br/>":"<br>"},u.del=function(e){return"<del>"+e+"</del>"},u.link=function(e,u,t){if(null===(e=V(this.options.sanitize,this.options.baseUrl,e)))return t;e='<a href="'+H(e)+'"';return u&&(e+=' title="'+u+'"'),e+=">"+t+"</a>"},u.image=function(e,u,t){if(null===(e=V(this.options.sanitize,this.options.baseUrl,e)))return t;t='<img src="'+e+'" alt="'+t+'"';return u&&(t+=' title="'+u+'"'),t+=this.options.xhtml?"/>":">"},u.text=function(e){return e},e}(),K=function(){function e(){}var u=e.prototype;return u.strong=function(e){return e},u.em=function(e){return e},u.codespan=function(e){return e},u.del=function(e){return e},u.html=function(e){return e},u.text=function(e){return e},u.link=function(e,u,t){return""+t},u.image=function(e,u,t){return""+t},u.br=function(){return""},e}(),Q=function(){function e(){this.seen={}}var u=e.prototype;return u.serialize=function(e){return e.toLowerCase().trim().replace(/<[!\/a-z].*?>/gi,"").replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g,"").replace(/\s/g,"-")},u.getNextSafeSlug=function(e,u){var t=e,n=0;if(this.seen.hasOwnProperty(t))for(n=this.seen[e];t=e+"-"+ ++n,this.seen.hasOwnProperty(t););return u||(this.seen[e]=n,this.seen[t]=0),t},u.slug=function(e,u){void 0===u&&(u={});var t=this.serialize(e);return this.getNextSafeSlug(t,u.dryrun)},e}(),W=u.defaults,Y=b,ee=function(){function t(e){this.options=e||W,this.options.renderer=this.options.renderer||new J,this.renderer=this.options.renderer,this.renderer.options=this.options,this.textRenderer=new K,this.slugger=new Q}t.parse=function(e,u){return new t(u).parse(e)},t.parseInline=function(e,u){return new t(u).parseInline(e)};var e=t.prototype;return e.parse=function(e,u){void 0===u&&(u=!0);for(var t,n,r,i,s,l,a,D,o,c,h,p,g,f,F,A="",C=e.length,d=0;d<C;d++)switch((D=e[d]).type){case"space":continue;case"hr":A+=this.renderer.hr();continue;case"heading":A+=this.renderer.heading(this.parseInline(D.tokens),D.depth,Y(this.parseInline(D.tokens,this.textRenderer)),this.slugger);continue;case"code":A+=this.renderer.code(D.text,D.lang,D.escaped);continue;case"table":for(l=o="",r=D.header.length,t=0;t<r;t++)l+=this.renderer.tablecell(this.parseInline(D.tokens.header[t]),{header:!0,align:D.align[t]});for(o+=this.renderer.tablerow(l),a="",r=D.cells.length,t=0;t<r;t++){for(l="",i=(s=D.tokens.cells[t]).length,n=0;n<i;n++)l+=this.renderer.tablecell(this.parseInline(s[n]),{header:!1,align:D.align[n]});a+=this.renderer.tablerow(l)}A+=this.renderer.table(o,a);continue;case"blockquote":a=this.parse(D.tokens),A+=this.renderer.blockquote(a);continue;case"list":for(o=D.ordered,E=D.start,c=D.loose,r=D.items.length,a="",t=0;t<r;t++)g=(p=D.items[t]).checked,f=p.task,h="",p.task&&(F=this.renderer.checkbox(g),c?0<p.tokens.length&&"text"===p.tokens[0].type?(p.tokens[0].text=F+" "+p.tokens[0].text,p.tokens[0].tokens&&0<p.tokens[0].tokens.length&&"text"===p.tokens[0].tokens[0].type&&(p.tokens[0].tokens[0].text=F+" "+p.tokens[0].tokens[0].text)):p.tokens.unshift({type:"text",text:F}):h+=F),h+=this.parse(p.tokens,c),a+=this.renderer.listitem(h,f,g);A+=this.renderer.list(a,o,E);continue;case"html":A+=this.renderer.html(D.text);continue;case"paragraph":A+=this.renderer.paragraph(this.parseInline(D.tokens));continue;case"text":for(a=D.tokens?this.parseInline(D.tokens):D.text;d+1<C&&"text"===e[d+1].type;)a+="\n"+((D=e[++d]).tokens?this.parseInline(D.tokens):D.text);A+=u?this.renderer.paragraph(a):a;continue;default:var E='Token with "'+D.type+'" type was not found.';if(this.options.silent)return void console.error(E);throw new Error(E)}return A},e.parseInline=function(e,u){u=u||this.renderer;for(var t,n="",r=e.length,i=0;i<r;i++)switch((t=e[i]).type){case"escape":n+=u.text(t.text);break;case"html":n+=u.html(t.text);break;case"link":n+=u.link(t.href,t.title,this.parseInline(t.tokens,u));break;case"image":n+=u.image(t.href,t.title,t.text);break;case"strong":n+=u.strong(this.parseInline(t.tokens,u));break;case"em":n+=u.em(this.parseInline(t.tokens,u));break;case"codespan":n+=u.codespan(t.text);break;case"br":n+=u.br();break;case"del":n+=u.del(this.parseInline(t.tokens,u));break;case"text":n+=u.text(t.text);break;default:var s='Token with "'+t.type+'" type was not found.';if(this.options.silent)return void console.error(s);throw new Error(s)}return n},t}(),ue=v,te=z,ne=m,m=u.getDefaults,re=u.changeDefaults,u=u.defaults;function ie(e,t,n){if(null==e)throw new Error("marked(): input parameter is undefined or null");if("string"!=typeof e)throw new Error("marked(): input parameter is of type "+Object.prototype.toString.call(e)+", string expected");if("function"==typeof t&&(n=t,t=null),t=ue({},ie.defaults,t||{}),te(t),n){var r,i=t.highlight;try{r=X.lex(e,t)}catch(e){return n(e)}var s=function(u){var e;if(!u)try{e=ee.parse(r,t)}catch(e){u=e}return t.highlight=i,u?n(u):n(null,e)};if(!i||i.length<3)return s();if(delete t.highlight,!r.length)return s();var l=0;return ie.walkTokens(r,function(t){"code"===t.type&&(l++,setTimeout(function(){i(t.text,t.lang,function(e,u){return e?s(e):(null!=u&&u!==t.text&&(t.text=u,t.escaped=!0),void(0===--l&&s()))})},0))}),void(0===l&&s())}try{var u=X.lex(e,t);return t.walkTokens&&ie.walkTokens(u,t.walkTokens),ee.parse(u,t)}catch(e){if(e.message+="\nPlease report this to https://github.com/markedjs/marked.",t.silent)return"<p>An error occurred:</p><pre>"+ne(e.message+"",!0)+"</pre>";throw e}}return ie.options=ie.setOptions=function(e){return ue(ie.defaults,e),re(ie.defaults),ie},ie.getDefaults=m,ie.defaults=u,ie.use=function(l){var u,t=ue({},l);l.renderer&&function(){var e,s=ie.defaults.renderer||new J;for(e in l.renderer)!function(r){var i=s[r];s[r]=function(){for(var e=arguments.length,u=new Array(e),t=0;t<e;t++)u[t]=arguments[t];var n=l.renderer[r].apply(s,u);return n=!1===n?i.apply(s,u):n}}(e);t.renderer=s}(),l.tokenizer&&function(){var e,s=ie.defaults.tokenizer||new O;for(e in l.tokenizer)!function(r){var i=s[r];s[r]=function(){for(var e=arguments.length,u=new Array(e),t=0;t<e;t++)u[t]=arguments[t];var n=l.tokenizer[r].apply(s,u);return n=!1===n?i.apply(s,u):n}}(e);t.tokenizer=s}(),l.walkTokens&&(u=ie.defaults.walkTokens,t.walkTokens=function(e){l.walkTokens(e),u&&u(e)}),ie.setOptions(t)},ie.walkTokens=function(e,u){for(var t,n=c(e);!(t=n()).done;){var r=t.value;switch(u(r),r.type){case"table":for(var i=c(r.tokens.header);!(s=i()).done;){var s=s.value;ie.walkTokens(s,u)}for(var l,a=c(r.tokens.cells);!(l=a()).done;)for(var D=c(l.value);!(o=D()).done;){var o=o.value;ie.walkTokens(o,u)}break;case"list":ie.walkTokens(r.items,u);break;default:r.tokens&&ie.walkTokens(r.tokens,u)}}},ie.parseInline=function(e,u){if(null==e)throw new Error("marked.parseInline(): input parameter is undefined or null");if("string"!=typeof e)throw new Error("marked.parseInline(): input parameter is of type "+Object.prototype.toString.call(e)+", string expected");u=ue({},ie.defaults,u||{}),te(u);try{var t=X.lexInline(e,u);return u.walkTokens&&ie.walkTokens(t,u.walkTokens),ee.parseInline(t,u)}catch(e){if(e.message+="\nPlease report this to https://github.com/markedjs/marked.",u.silent)return"<p>An error occurred:</p><pre>"+ne(e.message+"",!0)+"</pre>";throw e}},ie.Parser=ee,ie.parser=ee.parse,ie.Renderer=J,ie.TextRenderer=K,ie.Lexer=X,ie.lexer=X.lex,ie.Tokenizer=O,ie.Slugger=Q,ie.parse=ie});
\ No newline at end of file
diff --git a/src/Lexer.js b/src/Lexer.js
index 111cc96304..6c02ed65e5 100644
--- a/src/Lexer.js
+++ b/src/Lexer.js
@@ -355,11 +355,17 @@ module.exports = class Lexer {
       maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
     }
 
+    // Mask out escaped em & strong delimiters
+    while ((match = this.tokenizer.rules.inline.escapedEmSt.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex);
+    }
+
     while (src) {
       if (!keepPrevChar) {
         prevChar = '';
       }
       keepPrevChar = false;
+
       // escape
       if (token = this.tokenizer.escape(src)) {
         src = src.substring(token.raw.length);
@@ -408,16 +414,8 @@ module.exports = class Lexer {
         continue;
       }
 
-      // strong
-      if (token = this.tokenizer.strong(src, maskedSrc, prevChar)) {
-        src = src.substring(token.raw.length);
-        token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
-        tokens.push(token);
-        continue;
-      }
-
-      // em
-      if (token = this.tokenizer.em(src, maskedSrc, prevChar)) {
+      // em & strong
+      if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
         src = src.substring(token.raw.length);
         token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
         tokens.push(token);
@@ -463,7 +461,9 @@ module.exports = class Lexer {
       // text
       if (token = this.tokenizer.inlineText(src, inRawBlock, smartypants)) {
         src = src.substring(token.raw.length);
-        prevChar = token.raw.slice(-1);
+        if (token.raw.slice(-1) !== '_') { // Track prevChar before string of ____ started
+          prevChar = token.raw.slice(-1);
+        }
         keepPrevChar = true;
         lastToken = tokens[tokens.length - 1];
         if (lastToken && lastToken.type === 'text') {
diff --git a/src/Tokenizer.js b/src/Tokenizer.js
index 4b1eebf96d..13ef702b5d 100644
--- a/src/Tokenizer.js
+++ b/src/Tokenizer.js
@@ -527,46 +527,61 @@ module.exports = class Tokenizer {
     }
   }
 
-  strong(src, maskedSrc, prevChar = '') {
-    let match = this.rules.inline.strong.start.exec(src);
+  emStrong(src, maskedSrc, prevChar = '') {
+    let match = this.rules.inline.emStrong.lDelim.exec(src);
+    if (!match) return;
 
-    if (match && (!match[1] || (match[1] && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))))) {
-      maskedSrc = maskedSrc.slice(-1 * src.length);
-      const endReg = match[0] === '**' ? this.rules.inline.strong.endAst : this.rules.inline.strong.endUnd;
+    if (match[3] && prevChar.match(/[\p{L}\p{N}]/u)) return; // _ can't be between two alphanumerics. \p{L}\p{N} includes non-english alphabet/numbers as well
 
+    const nextChar = match[1] || match[2] || '';
+
+    if (!nextChar || (nextChar && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar)))) {
+      const lLength = match[0].length - 1;
+      let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
+
+      const endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
       endReg.lastIndex = 0;
 
-      let cap;
+      maskedSrc = maskedSrc.slice(-1 * src.length + lLength); // Bump maskedSrc to same section of string as src (move to lexer?)
+
       while ((match = endReg.exec(maskedSrc)) != null) {
-        cap = this.rules.inline.strong.middle.exec(maskedSrc.slice(0, match.index + 3));
-        if (cap) {
-          return {
-            type: 'strong',
-            raw: src.slice(0, cap[0].length),
-            text: src.slice(2, cap[0].length - 2)
-          };
+        rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+
+        if (!rDelim) continue; // matched the first alternative in rules.js (skip the * in __abc*abc__)
+
+        rLength = rDelim.length;
+
+        if (match[3] || match[4]) { // found another Left Delim
+          delimTotal += rLength;
+          continue;
+        } else if (match[5] || match[6]) { // either Left or Right Delim
+          if (lLength % 3 && !((lLength + rLength) % 3)) {
+            midDelimTotal += rLength;
+            continue; // CommonMark Emphasis Rules 9-10
+          }
         }
-      }
-    }
-  }
 
-  em(src, maskedSrc, prevChar = '') {
-    let match = this.rules.inline.em.start.exec(src);
+        delimTotal -= rLength;
 
-    if (match && (!match[1] || (match[1] && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))))) {
-      maskedSrc = maskedSrc.slice(-1 * src.length);
-      const endReg = match[0] === '*' ? this.rules.inline.em.endAst : this.rules.inline.em.endUnd;
+        if (delimTotal > 0) continue; // Haven't found enough closing delimiters
 
-      endReg.lastIndex = 0;
+        // If this is the last rDelimiter, remove extra characters. *a*** -> *a*
+        if (delimTotal + midDelimTotal - rLength <= 0 && !maskedSrc.slice(endReg.lastIndex).match(endReg)) {
+          rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
+        }
 
-      let cap;
-      while ((match = endReg.exec(maskedSrc)) != null) {
-        cap = this.rules.inline.em.middle.exec(maskedSrc.slice(0, match.index + 2));
-        if (cap) {
+        if (Math.min(lLength, rLength) % 2) {
           return {
             type: 'em',
-            raw: src.slice(0, cap[0].length),
-            text: src.slice(1, cap[0].length - 1)
+            raw: src.slice(0, lLength + match.index + rLength + 1),
+            text: src.slice(1, lLength + match.index + rLength)
+          };
+        }
+        if (Math.min(lLength, rLength) % 2 === 0) {
+          return {
+            type: 'strong',
+            raw: src.slice(0, lLength + match.index + rLength + 1),
+            text: src.slice(2, lLength + match.index + rLength - 1)
           };
         }
       }
diff --git a/src/rules.js b/src/rules.js
index b7f245e714..1a39c3fc74 100644
--- a/src/rules.js
+++ b/src/rules.js
@@ -173,74 +173,41 @@ const inline = {
   reflink: /^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,
   nolink: /^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,
   reflinkSearch: 'reflink|nolink(?!\\()',
-  strong: {
-    start: /^(?:(\*\*(?=[*punctuation]))|\*\*)(?![\s])|__/, // (1) returns if starts w/ punctuation
-    middle: /^\*\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*\*$|^__(?![\s])((?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?)__$/,
-    endAst: /[^punctuation\s]\*\*(?!\*)|[punctuation]\*\*(?!\*)(?:(?=[punctuation_\s]|$))/, // last char can't be punct, or final * must also be followed by punct (or endline)
-    endUnd: /[^\s]__(?!_)(?:(?=[punctuation*\s])|$)/ // last char can't be a space, and final _ must preceed punct or \s (or endline)
-  },
-  em: {
-    start: /^(?:(\*(?=[punctuation]))|\*)(?![*\s])|_/, // (1) returns if starts w/ punctuation
-    middle: /^\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*$|^_(?![_\s])(?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?_$/,
-    endAst: /[^punctuation\s]\*(?!\*)|[punctuation]\*(?!\*)(?:(?=[punctuation_\s]|$))/, // last char can't be punct, or final * must also be followed by punct (or endline)
-    endUnd: /[^\s]_(?!_)(?:(?=[punctuation*\s])|$)/ // last char can't be a space, and final _ must preceed punct or \s (or endline)
+  emStrong: {
+    lDelim: /^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/,
+    //        (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
+    //        () Skip other delimiter (1) #***                (2) a***#, a***                   (3) #***a, ***a                 (4) ***#              (5) #***#                 (6) a***a
+    rDelimAst: /\_\_[^_]*?\*[^_]*?\_\_|[punct_](\*+)(?=[\s]|$)|[^punct*_\s](\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|[^punct*_\s](\*+)(?=[^punct*_\s])/,
+    rDelimUnd: /\*\*[^*]*?\_[^*]*?\*\*|[punct*](\_+)(?=[\s]|$)|[^punct*_\s](\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/ // ^- Not allowed for _
   },
   code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
   br: /^( {2,}|\\)\n(?!\s*$)/,
   del: noopTest,
-  text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*]|\b_|$)|[^ ](?= {2,}\n)))/,
-  punctuation: /^([\s*punctuation])/
+  text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,
+  punctuation: /^([\spunctuation])/
 };
 
-// list of punctuation marks from common mark spec
-// without * and _ to workaround cases with double emphasis
+// list of punctuation marks from CommonMark spec
+// without * and _ to handle the different emphasis markers * and _
 inline._punctuation = '!"#$%&\'()+\\-.,/:;<=>?@\\[\\]`^{|}~';
 inline.punctuation = edit(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex();
 
 // sequences em should skip over [title](link), `code`, <html>
-inline._blockSkip = '\\[[^\\]]*?\\]\\([^\\)]*?\\)|`[^`]*?`|<[^>]*?>';
-inline._overlapSkip = '__[^_]*?__|\\*\\*\\[^\\*\\]*?\\*\\*';
+inline.blockSkip = /\[[^\]]*?\]\([^\)]*?\)|`[^`]*?`|<[^>]*?>/g;
+inline.escapedEmSt = /\\\*|\\_/g;
 
 inline._comment = edit(block._comment).replace('(?:-->|$)', '-->').getRegex();
 
-inline.em.start = edit(inline.em.start)
-  .replace(/punctuation/g, inline._punctuation)
-  .getRegex();
-
-inline.em.middle = edit(inline.em.middle)
-  .replace(/punctuation/g, inline._punctuation)
-  .replace(/overlapSkip/g, inline._overlapSkip)
-  .getRegex();
-
-inline.em.endAst = edit(inline.em.endAst, 'g')
-  .replace(/punctuation/g, inline._punctuation)
-  .getRegex();
-
-inline.em.endUnd = edit(inline.em.endUnd, 'g')
-  .replace(/punctuation/g, inline._punctuation)
-  .getRegex();
-
-inline.strong.start = edit(inline.strong.start)
-  .replace(/punctuation/g, inline._punctuation)
-  .getRegex();
-
-inline.strong.middle = edit(inline.strong.middle)
-  .replace(/punctuation/g, inline._punctuation)
-  .replace(/overlapSkip/g, inline._overlapSkip)
-  .getRegex();
-
-inline.strong.endAst = edit(inline.strong.endAst, 'g')
-  .replace(/punctuation/g, inline._punctuation)
-  .getRegex();
-
-inline.strong.endUnd = edit(inline.strong.endUnd, 'g')
-  .replace(/punctuation/g, inline._punctuation)
+inline.emStrong.lDelim = edit(inline.emStrong.lDelim)
+  .replace(/punct/g, inline._punctuation)
   .getRegex();
 
-inline.blockSkip = edit(inline._blockSkip, 'g')
+inline.emStrong.rDelimAst = edit(inline.emStrong.rDelimAst, 'g')
+  .replace(/punct/g, inline._punctuation)
   .getRegex();
 
-inline.overlapSkip = edit(inline._overlapSkip, 'g')
+inline.emStrong.rDelimUnd = edit(inline.emStrong.rDelimUnd, 'g')
+  .replace(/punct/g, inline._punctuation)
   .getRegex();
 
 inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;
@@ -319,7 +286,7 @@ inline.gfm = merge({}, inline.normal, {
   url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
   _backpedal: /(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,
   del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
-  text: /^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/
+  text: /^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/
 });
 
 inline.gfm.url = edit(inline.gfm.url, 'i')
diff --git a/test/specs/bug/adjacent_lists.html b/test/specs/bug/adjacent_lists.html
new file mode 100644
index 0000000000..2d64bd5963
--- /dev/null
+++ b/test/specs/bug/adjacent_lists.html
@@ -0,0 +1 @@
+<p><em>foo <strong>bar *baz bim</strong> bam</em></p>
diff --git a/test/specs/bug/adjacent_lists.md b/test/specs/bug/adjacent_lists.md
new file mode 100644
index 0000000000..fdf80c0adb
--- /dev/null
+++ b/test/specs/bug/adjacent_lists.md
@@ -0,0 +1 @@
+*foo __bar *baz bim__ bam*
diff --git a/test/specs/commonmark/commonmark.0.29.json b/test/specs/commonmark/commonmark.0.29.json
index b40ee785c1..8399c10c35 100644
--- a/test/specs/commonmark/commonmark.0.29.json
+++ b/test/specs/commonmark/commonmark.0.29.json
@@ -2916,8 +2916,7 @@
     "example": 361,
     "start_line": 6390,
     "end_line": 6394,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "aa_\"bb\"_cc\n",
@@ -3125,8 +3124,7 @@
     "example": 387,
     "start_line": 6641,
     "end_line": 6645,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "__foo, __bar__, baz__\n",
@@ -3134,8 +3132,7 @@
     "example": 388,
     "start_line": 6648,
     "end_line": 6652,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "foo-__(bar)__\n",
@@ -3287,8 +3284,7 @@
     "example": 407,
     "start_line": 6831,
     "end_line": 6835,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo *bar**\n",
@@ -3328,8 +3324,7 @@
     "example": 412,
     "start_line": 6888,
     "end_line": 6892,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo **bar***\n",
@@ -3353,8 +3348,7 @@
     "example": 415,
     "start_line": 6913,
     "end_line": 6917,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "foo******bar*********baz\n",
@@ -3362,8 +3356,7 @@
     "example": 416,
     "start_line": 6919,
     "end_line": 6923,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo **bar *baz* bim** bop*\n",
@@ -3427,8 +3420,7 @@
     "example": 424,
     "start_line": 6990,
     "end_line": 6994,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "____foo__ bar__\n",
@@ -3436,8 +3428,7 @@
     "example": 425,
     "start_line": 6997,
     "end_line": 7001,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "**foo **bar****\n",
@@ -3573,8 +3564,7 @@
     "example": 442,
     "start_line": 7129,
     "end_line": 7133,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "***foo**\n",
@@ -3598,8 +3588,7 @@
     "example": 445,
     "start_line": 7150,
     "end_line": 7154,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo****\n",
@@ -3607,8 +3596,7 @@
     "example": 446,
     "start_line": 7157,
     "end_line": 7161,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "foo ___\n",
@@ -3664,8 +3652,7 @@
     "example": 453,
     "start_line": 7209,
     "end_line": 7213,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "_foo__\n",
@@ -3673,8 +3660,7 @@
     "example": 454,
     "start_line": 7220,
     "end_line": 7224,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "___foo__\n",
@@ -3682,8 +3668,7 @@
     "example": 455,
     "start_line": 7227,
     "end_line": 7231,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "____foo_\n",
@@ -3691,8 +3676,7 @@
     "example": 456,
     "start_line": 7234,
     "end_line": 7238,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "__foo___\n",
@@ -3700,8 +3684,7 @@
     "example": 457,
     "start_line": 7241,
     "end_line": 7245,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "_foo____\n",
@@ -3709,8 +3692,7 @@
     "example": 458,
     "start_line": 7248,
     "end_line": 7252,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "**foo**\n",
@@ -3766,8 +3748,7 @@
     "example": 465,
     "start_line": 7307,
     "end_line": 7311,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "***foo***\n",
@@ -3775,8 +3756,7 @@
     "example": 466,
     "start_line": 7316,
     "end_line": 7320,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "_____foo_____\n",
@@ -3784,8 +3764,7 @@
     "example": 467,
     "start_line": 7323,
     "end_line": 7327,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo _bar* baz_\n",
@@ -3809,8 +3788,7 @@
     "example": 470,
     "start_line": 7348,
     "end_line": 7352,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo *bar baz*\n",
diff --git a/test/specs/gfm/commonmark.0.29.json b/test/specs/gfm/commonmark.0.29.json
index 5c4eba25bd..36394f5277 100644
--- a/test/specs/gfm/commonmark.0.29.json
+++ b/test/specs/gfm/commonmark.0.29.json
@@ -2916,8 +2916,7 @@
     "example": 361,
     "start_line": 6390,
     "end_line": 6394,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "aa_\"bb\"_cc\n",
@@ -3125,8 +3124,7 @@
     "example": 387,
     "start_line": 6641,
     "end_line": 6645,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "__foo, __bar__, baz__\n",
@@ -3134,8 +3132,7 @@
     "example": 388,
     "start_line": 6648,
     "end_line": 6652,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "foo-__(bar)__\n",
@@ -3287,8 +3284,7 @@
     "example": 407,
     "start_line": 6831,
     "end_line": 6835,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo *bar**\n",
@@ -3328,8 +3324,7 @@
     "example": 412,
     "start_line": 6888,
     "end_line": 6892,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo **bar***\n",
@@ -3353,8 +3348,7 @@
     "example": 415,
     "start_line": 6913,
     "end_line": 6917,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "foo******bar*********baz\n",
@@ -3362,8 +3356,7 @@
     "example": 416,
     "start_line": 6919,
     "end_line": 6923,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo **bar *baz* bim** bop*\n",
@@ -3427,8 +3420,7 @@
     "example": 424,
     "start_line": 6990,
     "end_line": 6994,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "____foo__ bar__\n",
@@ -3436,8 +3428,7 @@
     "example": 425,
     "start_line": 6997,
     "end_line": 7001,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "**foo **bar****\n",
@@ -3573,8 +3564,7 @@
     "example": 442,
     "start_line": 7129,
     "end_line": 7133,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "***foo**\n",
@@ -3598,8 +3588,7 @@
     "example": 445,
     "start_line": 7150,
     "end_line": 7154,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo****\n",
@@ -3607,8 +3596,7 @@
     "example": 446,
     "start_line": 7157,
     "end_line": 7161,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "foo ___\n",
@@ -3664,8 +3652,7 @@
     "example": 453,
     "start_line": 7209,
     "end_line": 7213,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "_foo__\n",
@@ -3673,8 +3660,7 @@
     "example": 454,
     "start_line": 7220,
     "end_line": 7224,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "___foo__\n",
@@ -3682,8 +3668,7 @@
     "example": 455,
     "start_line": 7227,
     "end_line": 7231,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "____foo_\n",
@@ -3691,8 +3676,7 @@
     "example": 456,
     "start_line": 7234,
     "end_line": 7238,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "__foo___\n",
@@ -3700,8 +3684,7 @@
     "example": 457,
     "start_line": 7241,
     "end_line": 7245,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "_foo____\n",
@@ -3709,8 +3692,7 @@
     "example": 458,
     "start_line": 7248,
     "end_line": 7252,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "**foo**\n",
@@ -3766,8 +3748,7 @@
     "example": 465,
     "start_line": 7307,
     "end_line": 7311,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "***foo***\n",
@@ -3775,8 +3756,7 @@
     "example": 466,
     "start_line": 7316,
     "end_line": 7320,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "_____foo_____\n",
@@ -3784,8 +3764,7 @@
     "example": 467,
     "start_line": 7323,
     "end_line": 7327,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo _bar* baz_\n",
@@ -3809,8 +3788,7 @@
     "example": 470,
     "start_line": 7348,
     "end_line": 7352,
-    "section": "Emphasis and strong emphasis",
-    "shouldFail": true
+    "section": "Emphasis and strong emphasis"
   },
   {
     "markdown": "*foo *bar baz*\n",
diff --git a/test/specs/new/em_list_links.html b/test/specs/new/em_list_links.html
index b52cd2a926..84b18fb7f3 100644
--- a/test/specs/new/em_list_links.html
+++ b/test/specs/new/em_list_links.html
@@ -14,10 +14,10 @@
 </ul>
 </li>
 <li>bold italic<ul>
-<li><a href="https://www.google.com"><strong><em>named link</em></strong></a></li>
-<li><strong><em><a href="https://www.google.com">named link</a></em></strong></li>
-<li><a href="https://www.google.com"><strong><em>named link</em></strong></a></li>
-<li><strong><em><a href="https://www.google.com">named link</a></em></strong></li>
+<li><a href="https://www.google.com"><em><strong>named link</strong></em></a></li>
+<li><em><strong><a href="https://www.google.com">named link</a></strong></em></li>
+<li><a href="https://www.google.com"><em><strong>named link</strong></em></a></li>
+<li><em><strong><a href="https://www.google.com">named link</a></strong></em></li>
 <li><a href="https://www.google.com"><em><strong>named link</strong></em></a></li>
 <li><a href="https://www.google.com"><strong><em>named link</em></strong></a></li>
 <li><strong><em><a href="https://www.google.com">named link</a></em></strong></li>
@@ -42,14 +42,13 @@
 </ul>
 </li>
 <li>code bold italic<ul>
-<li><a href="https://www.google.com"><strong><em><code>named link</code></em></strong></a></li>
-<li><strong><em><a href="https://www.google.com"><code>named link</code></a></em></strong></li>
-<li><a href="https://www.google.com"><strong><em><code>named link</code></em></strong></a></li>
-<li><strong><em><a href="https://www.google.com"><code>named link</code></a></em></strong></li>
+<li><a href="https://www.google.com"><em><strong><code>named link</code></strong></em></a></li>
+<li><em><strong><a href="https://www.google.com"><code>named link</code></a></strong></em></li>
+<li><a href="https://www.google.com"><em><strong><code>named link</code></strong></em></a></li>
+<li><em><strong><a href="https://www.google.com"><code>named link</code></a></strong></em></li>
 <li><a href="https://www.google.com"><em><strong><code>named link</code></strong></em></a></li>
 <li><a href="https://www.google.com"><strong><em><code>named link</code></em></strong></a></li>
 <li><strong><em><a href="https://www.google.com"><code>named link</code></a></em></strong></li>
 </ul>
 </li>
 </ul>
-
diff --git a/test/specs/original/strong_and_em_together.html b/test/specs/original/strong_and_em_together.html
deleted file mode 100644
index 71ec78c709..0000000000
--- a/test/specs/original/strong_and_em_together.html
+++ /dev/null
@@ -1,7 +0,0 @@
-<p><strong><em>This is strong and em.</em></strong></p>
-
-<p>So is <strong><em>this</em></strong> word.</p>
-
-<p><strong><em>This is strong and em.</em></strong></p>
-
-<p>So is <strong><em>this</em></strong> word.</p>
diff --git a/test/specs/original/strong_and_em_together.md b/test/specs/original/strong_and_em_together.md
deleted file mode 100644
index 95ee690dbe..0000000000
--- a/test/specs/original/strong_and_em_together.md
+++ /dev/null
@@ -1,7 +0,0 @@
-***This is strong and em.***
-
-So is ***this*** word.
-
-___This is strong and em.___
-
-So is ___this___ word.
diff --git a/test/specs/redos/quadratic_underscores.js b/test/specs/redos/quadratic_underscores.js
new file mode 100644
index 0000000000..a695488e09
--- /dev/null
+++ b/test/specs/redos/quadratic_underscores.js
@@ -0,0 +1,4 @@
+module.exports = {
+  markdown: `${'_'.repeat(101)} a`,
+  html: `<p>${'_'.repeat(101)} a</p>`
+};",
"url": "https://github.com/markedjs/marked/commit/7293251c438e3ee968970f7609f1a27f9007bccd.patch"
}
] | null |
CVE-2025-54798
|
tmp does not restrict arbitrary temporary file / directory write via symbolic link `dir` parameter
|
tmp is a temporary file and directory creator for node.js. In versions 0.2.3 and below, tmp is vulnerable to an arbitrary temporary file / directory write via symbolic link dir parameter. This is fixed in version 0.2.4.
|
[
{
"commit_message": "[PATCH] Fix GHSA-52f5-9888-hmc6 lib/tmp.js | 326 +++++++++++++++++++++++++++++++---------------------- 1 file changed, 192 insertions(+), 134 deletions(-)",
"patch_text_b64": "From 188b25e529496e37adaf1a1d9dccb40019a08b1b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?KARASZI=20Istv=C3=A1n?= <ikaraszi@gmail.com>
Date: Wed, 16 Apr 2025 01:52:32 +0200
Subject: [PATCH] Fix GHSA-52f5-9888-hmc6

---
 lib/tmp.js | 326 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 192 insertions(+), 134 deletions(-)

diff --git a/lib/tmp.js b/lib/tmp.js
index 84aa1c5..162dca1 100644
--- a/lib/tmp.js
+++ b/lib/tmp.js
@@ -18,34 +18,24 @@ const _c = { fs: fs.constants, os: os.constants };
 /*
  * The working inner variables.
  */
-const
-  // the random characters to choose from
+const // the random characters to choose from
   RANDOM_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
-
   TEMPLATE_PATTERN = /XXXXXX/,
-
   DEFAULT_TRIES = 3,
-
   CREATE_FLAGS = (_c.O_CREAT || _c.fs.O_CREAT) | (_c.O_EXCL || _c.fs.O_EXCL) | (_c.O_RDWR || _c.fs.O_RDWR),
-
   // constants are off on the windows platform and will not match the actual errno codes
   IS_WIN32 = os.platform() === 'win32',
   EBADF = _c.EBADF || _c.os.errno.EBADF,
   ENOENT = _c.ENOENT || _c.os.errno.ENOENT,
-
   DIR_MODE = 0o700 /* 448 */,
   FILE_MODE = 0o600 /* 384 */,
-
   EXIT = 'exit',
-
   // this will hold the objects need to be removed on exit
   _removeObjects = [],
-
   // API change in fs.rmdirSync leads to error when passing in a second parameter, e.g. the callback
   FN_RMDIR_SYNC = fs.rmdirSync.bind(fs);
 
-let
-  _gracefulCleanup = false;
+let _gracefulCleanup = false;
 
 /**
  * Recursively remove a directory and its contents.
@@ -75,38 +65,35 @@ function FN_RIMRAF_SYNC(dirPath) {
  * @param {?tmpNameCallback} callback the callback function
  */
 function tmpName(options, callback) {
-  const
-    args = _parseArguments(options, callback),
+  const args = _parseArguments(options, callback),
     opts = args[0],
     cb = args[1];
 
-  try {
-    _assertAndSanitizeOptions(opts);
-  } catch (err) {
-    return cb(err);
-  }
+  _assertAndSanitizeOptions(opts, function (err, sanitizedOptions) {
+    if (err) return cb(err);
 
-  let tries = opts.tries;
-  (function _getUniqueName() {
-    try {
-      const name = _generateTmpName(opts);
+    let tries = sanitizedOptions.tries;
+    (function _getUniqueName() {
+      try {
+        const name = _generateTmpName(sanitizedOptions);
 
-      // check whether the path exists then retry if needed
-      fs.stat(name, function (err) {
-        /* istanbul ignore else */
-        if (!err) {
+        // check whether the path exists then retry if needed
+        fs.stat(name, function (err) {
           /* istanbul ignore else */
-          if (tries-- > 0) return _getUniqueName();
+          if (!err) {
+            /* istanbul ignore else */
+            if (tries-- > 0) return _getUniqueName();
 
-          return cb(new Error('Could not get a unique tmp filename, max tries reached ' + name));
-        }
+            return cb(new Error('Could not get a unique tmp filename, max tries reached ' + name));
+          }
 
-        cb(null, name);
-      });
-    } catch (err) {
-      cb(err);
-    }
-  }());
+          cb(null, name);
+        });
+      } catch (err) {
+        cb(err);
+      }
+    })();
+  });
 }
 
 /**
@@ -117,15 +104,14 @@ function tmpName(options, callback) {
  * @throws {Error} if the options are invalid or could not generate a filename
  */
 function tmpNameSync(options) {
-  const
-    args = _parseArguments(options),
+  const args = _parseArguments(options),
     opts = args[0];
 
-  _assertAndSanitizeOptions(opts);
+  const sanitizedOptions = _assertAndSanitizeOptionsSync(opts);
 
-  let tries = opts.tries;
+  let tries = sanitizedOptions.tries;
   do {
-    const name = _generateTmpName(opts);
+    const name = _generateTmpName(sanitizedOptions);
     try {
       fs.statSync(name);
     } catch (e) {
@@ -143,8 +129,7 @@ function tmpNameSync(options) {
  * @param {?fileCallback} callback
  */
 function file(options, callback) {
-  const
-    args = _parseArguments(options, callback),
+  const args = _parseArguments(options, callback),
     opts = args[0],
     cb = args[1];
 
@@ -181,13 +166,12 @@ function file(options, callback) {
  * @throws {Error} if cannot create a file
  */
 function fileSync(options) {
-  const
-    args = _parseArguments(options),
+  const args = _parseArguments(options),
     opts = args[0];
 
   const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
   const name = tmpNameSync(opts);
-  var fd = fs.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+  let fd = fs.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
   /* istanbul ignore else */
   if (opts.discardDescriptor) {
     fs.closeSync(fd);
@@ -208,8 +192,7 @@ function fileSync(options) {
  * @param {?dirCallback} callback
  */
 function dir(options, callback) {
-  const
-    args = _parseArguments(options, callback),
+  const args = _parseArguments(options, callback),
     opts = args[0],
     cb = args[1];
 
@@ -236,8 +219,7 @@ function dir(options, callback) {
  * @throws {Error} if it cannot create a directory
  */
 function dirSync(options) {
-  const
-    args = _parseArguments(options),
+  const args = _parseArguments(options),
     opts = args[0];
 
   const name = tmpNameSync(opts);
@@ -288,8 +270,7 @@ function _removeFileSync(fdPath) {
   } finally {
     try {
       fs.unlinkSync(fdPath[1]);
-    }
-    catch (e) {
+    } catch (e) {
       // reraise any unanticipated error
       if (!_isENOENT(e)) rethrownException = e;
     }
@@ -361,7 +342,6 @@ function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCall
 
   // if sync is true, the next parameter will be ignored
   return function _cleanupCallback(next) {
-
     /* istanbul ignore else */
     if (!called) {
       // remove cleanupCallback from cache
@@ -374,7 +354,7 @@ function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCall
       if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
         return removeFunction(fileOrDirName);
       } else {
-        return removeFunction(fileOrDirName, next || function() {});
+        return removeFunction(fileOrDirName, next || function () {});
       }
     }
   };
@@ -409,8 +389,7 @@ function _garbageCollector() {
  * @private
  */
 function _randomChars(howMany) {
-  let
-    value = [],
+  let value = [],
     rnd = null;
 
   // make sure that we do not fail because we ran out of entropy
@@ -420,24 +399,13 @@ function _randomChars(howMany) {
     rnd = crypto.pseudoRandomBytes(howMany);
   }
 
-  for (var i = 0; i < howMany; i++) {
+  for (let i = 0; i < howMany; i++) {
     value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
   }
 
   return value.join('');
 }
 
-/**
- * Helper which determines whether a string s is blank, that is undefined, or empty or null.
- *
- * @private
- * @param {string} s
- * @returns {Boolean} true whether the string s is blank, false otherwise
- */
-function _isBlank(s) {
-  return s === null || _isUndefined(s) || !s.trim();
-}
-
 /**
  * Checks whether the `obj` parameter is defined or not.
  *
@@ -479,6 +447,51 @@ function _parseArguments(options, callback) {
   return [actualOptions, callback];
 }
 
+/**
+ * Resolve the specified path name in respect to tmpDir.
+ *
+ * The specified name might include relative path components, e.g. ../
+ * so we need to resolve in order to be sure that is is located inside tmpDir
+ *
+ * @private
+ */
+function _resolvePath(name, tmpDir, cb) {
+  const pathToResolve = path.isAbsolute(name) ? name : path.join(tmpDir, name);
+
+  fs.stat(pathToResolve, function (err) {
+    if (err) {
+      fs.realpath(path.dirname(pathToResolve), function (err, parentDir) {
+        if (err) return cb(err);
+
+        cb(null, path.join(parentDir, path.basename(pathToResolve)));
+      });
+    } else {
+      fs.realpath(path, cb);
+    }
+  });
+}
+
+/**
+ * Resolve the specified path name in respect to tmpDir.
+ *
+ * The specified name might include relative path components, e.g. ../
+ * so we need to resolve in order to be sure that is is located inside tmpDir
+ *
+ * @private
+ */
+function _resolvePathSync(name, tmpDir) {
+  const pathToResolve = path.isAbsolute(name) ? name : path.join(tmpDir, name);
+
+  try {
+    fs.statSync(pathToResolve);
+    return fs.realpathSync(pathToResolve);
+  } catch (_err) {
+    const parentDir = fs.realpathSync(path.dirname(pathToResolve));
+
+    return path.join(parentDir, path.basename(pathToResolve));
+  }
+}
+
 /**
  * Generates a new temporary name.
  *
@@ -487,16 +500,17 @@ function _parseArguments(options, callback) {
  * @private
  */
 function _generateTmpName(opts) {
-
   const tmpDir = opts.tmpdir;
 
   /* istanbul ignore else */
-  if (!_isUndefined(opts.name))
+  if (!_isUndefined(opts.name)) {
     return path.join(tmpDir, opts.dir, opts.name);
+  }
 
   /* istanbul ignore else */
-  if (!_isUndefined(opts.template))
+  if (!_isUndefined(opts.template)) {
     return path.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
+  }
 
   // prefix and postfix
   const name = [
@@ -512,33 +526,32 @@ function _generateTmpName(opts) {
 }
 
 /**
- * Asserts whether the specified options are valid, also sanitizes options and provides sane defaults for missing
- * options.
+ * Asserts and sanitizes the basic options.
  *
- * @param {Options} options
  * @private
  */
-function _assertAndSanitizeOptions(options) {
+function _assertOptionsBase(options) {
+  if (!_isUndefined(options.name)) {
+    const name = options.name;
 
-  options.tmpdir = _getTmpDir(options);
+    // assert that name is not absolute and does not contain a path
+    if (path.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);
 
-  const tmpDir = options.tmpdir;
+    // must not fail on valid .<name> or ..<name> or similar such constructs
+    const basename = path.basename(name);
+    if (basename === '..' || basename === '.' || basename !== name)
+      throw new Error(`name option must not contain a path, found "${name}".`);
+  }
 
   /* istanbul ignore else */
-  if (!_isUndefined(options.name))
-    _assertIsRelative(options.name, 'name', tmpDir);
-  /* istanbul ignore else */
-  if (!_isUndefined(options.dir))
-    _assertIsRelative(options.dir, 'dir', tmpDir);
-  /* istanbul ignore else */
-  if (!_isUndefined(options.template)) {
-    _assertIsRelative(options.template, 'template', tmpDir);
-    if (!options.template.match(TEMPLATE_PATTERN))
-      throw new Error(`Invalid template, found "${options.template}".`);
+  if (!_isUndefined(options.template) && !options.template.match(TEMPLATE_PATTERN)) {
+    throw new Error(`Invalid template, found "${options.template}".`);
   }
+
   /* istanbul ignore else */
-  if (!_isUndefined(options.tries) && isNaN(options.tries) || options.tries < 0)
+  if ((!_isUndefined(options.tries) && isNaN(options.tries)) || options.tries < 0) {
     throw new Error(`Invalid tries, found "${options.tries}".`);
+  }
 
   // if a name was specified we will try once
   options.tries = _isUndefined(options.name) ? options.tries || DEFAULT_TRIES : 1;
@@ -547,65 +560,103 @@ function _assertAndSanitizeOptions(options) {
   options.discardDescriptor = !!options.discardDescriptor;
   options.unsafeCleanup = !!options.unsafeCleanup;
 
-  // sanitize dir, also keep (multiple) blanks if the user, purportedly sane, requests us to
-  options.dir = _isUndefined(options.dir) ? '' : path.relative(tmpDir, _resolvePath(options.dir, tmpDir));
-  options.template = _isUndefined(options.template) ? undefined : path.relative(tmpDir, _resolvePath(options.template, tmpDir));
-  // sanitize further if template is relative to options.dir
-  options.template = _isBlank(options.template) ? undefined : path.relative(options.dir, options.template);
-
   // for completeness' sake only, also keep (multiple) blanks if the user, purportedly sane, requests us to
-  options.name = _isUndefined(options.name) ? undefined : options.name;
   options.prefix = _isUndefined(options.prefix) ? '' : options.prefix;
   options.postfix = _isUndefined(options.postfix) ? '' : options.postfix;
 }
 
 /**
- * Resolve the specified path name in respect to tmpDir.
+ * Gets the relative directory to tmpDir.
  *
- * The specified name might include relative path components, e.g. ../
- * so we need to resolve in order to be sure that is is located inside tmpDir
+ * @private
+ */
+function _getRelativePath(option, name, tmpDir, cb) {
+  if (_isUndefined(name)) return cb(null);
+
+  _resolvePath(name, tmpDir, function (err, resolvedPath) {
+    if (err) return cb(err);
+
+    const relativePath = path.relative(tmpDir, resolvedPath);
+
+    if (!resolvedPath.startsWith(tmpDir)) {
+      return cb(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`));
+    }
+
+    cb(null, relativePath);
+  });
+}
+
+/**
+ * Gets the relative path to tmpDir.
  *
- * @param name
- * @param tmpDir
- * @returns {string}
  * @private
  */
-function _resolvePath(name, tmpDir) {
-  if (name.startsWith(tmpDir)) {
-    return path.resolve(name);
-  } else {
-    return path.resolve(path.join(tmpDir, name));
+function _getRelativePathSync(option, name, tmpDir) {
+  if (_isUndefined(name)) return;
+
+  const resolvedPath = _resolvePathSync(name, tmpDir);
+  const relativePath = path.relative(tmpDir, resolvedPath);
+
+  if (!resolvedPath.startsWith(tmpDir)) {
+    throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`);
   }
+
+  return relativePath;
 }
 
 /**
- * Asserts whether specified name is relative to the specified tmpDir.
+ * Asserts whether the specified options are valid, also sanitizes options and provides sane defaults for missing
+ * options.
  *
- * @param {string} name
- * @param {string} option
- * @param {string} tmpDir
- * @throws {Error}
  * @private
  */
-function _assertIsRelative(name, option, tmpDir) {
-  if (option === 'name') {
-    // assert that name is not absolute and does not contain a path
-    if (path.isAbsolute(name))
-      throw new Error(`${option} option must not contain an absolute path, found "${name}".`);
-    // must not fail on valid .<name> or ..<name> or similar such constructs
-    let basename = path.basename(name);
-    if (basename === '..' || basename === '.' || basename !== name)
-      throw new Error(`${option} option must not contain a path, found "${name}".`);
-  }
-  else { // if (option === 'dir' || option === 'template') {
-    // assert that dir or template are relative to tmpDir
-    if (path.isAbsolute(name) && !name.startsWith(tmpDir)) {
-      throw new Error(`${option} option must be relative to "${tmpDir}", found "${name}".`);
+function _assertAndSanitizeOptions(options, cb) {
+  _getTmpDir(options, function (err, tmpDir) {
+    if (err) return cb(err);
+
+    options.tmpdir = tmpDir;
+
+    try {
+      _assertOptionsBase(options, tmpDir);
+    } catch (err) {
+      return cb(err);
     }
-    let resolvedPath = _resolvePath(name, tmpDir);
-    if (!resolvedPath.startsWith(tmpDir))
-      throw new Error(`${option} option must be relative to "${tmpDir}", found "${resolvedPath}".`);
-  }
+
+    // sanitize dir, also keep (multiple) blanks if the user, purportedly sane, requests us to
+    _getRelativePath('dir', options.dir, tmpDir, function (err, dir) {
+      if (err) return cb(err);
+
+      options.dir = _isUndefined(dir) ? '' : dir;
+
+      // sanitize further if template is relative to options.dir
+      _getRelativePath('template', options.template, tmpDir, function (err, template) {
+        if (err) return cb(err);
+
+        options.template = template;
+
+        cb(null, options);
+      });
+    });
+  });
+}
+
+/**
+ * Asserts whether the specified options are valid, also sanitizes options and provides sane defaults for missing
+ * options.
+ *
+ * @private
+ */
+function _assertAndSanitizeOptionsSync(options) {
+  const tmpDir = (options.tmpdir = _getTmpDirSync(options));
+
+  _assertOptionsBase(options, tmpDir);
+
+  const dir = _getRelativePathSync('dir', options.dir, tmpDir);
+  options.dir = _isUndefined(dir) ? '' : dir;
+
+  options.template = _getRelativePathSync('template', options.template, tmpDir);
+
+  return options;
 }
 
 /**
@@ -663,11 +714,18 @@ function setGracefulCleanup() {
  * Returns the currently configured tmp dir from os.tmpdir().
  *
  * @private
- * @param {?Options} options
- * @returns {string} the currently configured tmp dir
  */
-function _getTmpDir(options) {
-  return path.resolve(options && options.tmpdir || os.tmpdir());
+function _getTmpDir(options, cb) {
+  return fs.realpath((options && options.tmpdir) || os.tmpdir(), cb);
+}
+
+/**
+ * Returns the currently configured tmp dir from os.tmpdir().
+ *
+ * @private
+ */
+function _getTmpDirSync(options) {
+  return fs.realpathSync((options && options.tmpdir) || os.tmpdir());
 }
 
 // Install process exit listener
@@ -768,7 +826,7 @@ Object.defineProperty(module.exports, 'tmpdir', {
   enumerable: true,
   configurable: false,
   get: function () {
-    return _getTmpDir();
+    return _getTmpDirSync();
   }
 });",
"url": "https://github.com/raszi/node-tmp/commit/188b25e529496e37adaf1a1d9dccb40019a08b1b.patch"
}
] |
CWE-59: Improper Link Resolution Before File Access ('Link Following')
|
CVE-2011-2929
|
The template selection functionality in actionpack/lib/action_view/template/resolver.rb in Ruby on Rails 3.0.x before 3.0.10 and 3.1.x before 3.1.0.rc6 does not properly handle glob characters, which allows remote attackers to render arbitrary views via a crafted URL, related to a "filter skipping vulnerability."
|
[
{
"commit_message": "[PATCH] Properly escape glob characters. actionpack/lib/action_view/template/resolver.rb | 15 ++++++++++++--- actionpack/test/controller/render_test.rb | 14 ++++++++++++++ actionpack/test/fixtures/test/hello_w*rld.erb | 1 + 3 files changed, 27 insertions(+), 3 deletions(-) create mode 100644 actionpack/test/fixtures/test/hello_w*rld.erb",
"patch_text_b64": "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",
"url": "https://github.com/rails/rails/commit/5f94b93279f6d0682fafb237c301302c107a9552.patch"
}
] |
n/a
|
|
CVE-2021-32607
|
An issue was discovered in Smartstore (aka SmartStoreNET) through 4.1.1. Views/PrivateMessages/View.cshtml does not call HtmlUtils.SanitizeHtml on a private message.
|
[
{
"commit_message": "[PATCH] Fixed text issue in private messages of forum .../SmartStore.Web/Views/PrivateMessages/View.cshtml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA1YjRlNjBhZTcxMjRkZjA4OTg5NzVjYjhmOTk0ZjlmMjNkYjFmYWUzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJjdXMgIEdlc2luZyA8Z2VzaW5nQHNtYXJ0c3RvcmUuY29tPgpEYXRlOiBNb24sIDEwIE1heSAyMDIxIDE5OjE0OjAyICswMjAwClN1YmplY3Q6IFtQQVRDSF0gRml4ZWQgdGV4dCBpc3N1ZSBpbiBwcml2YXRlIG1lc3NhZ2VzIG9mIGZvcnVtCgotLS0KIC4uLi9TbWFydFN0b3JlLldlYi9WaWV3cy9Qcml2YXRlTWVzc2FnZXMvVmlldy5jc2h0bWwgICAgICAgICAgIHwgMyArKy0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9zcmMvUHJlc2VudGF0aW9uL1NtYXJ0U3RvcmUuV2ViL1ZpZXdzL1ByaXZhdGVNZXNzYWdlcy9WaWV3LmNzaHRtbCBiL3NyYy9QcmVzZW50YXRpb24vU21hcnRTdG9yZS5XZWIvVmlld3MvUHJpdmF0ZU1lc3NhZ2VzL1ZpZXcuY3NodG1sCmluZGV4IGQ4N2RkOTNhZTUuLjI0MjUxOTk5MzcgMTAwNjQ0Ci0tLSBhL3NyYy9QcmVzZW50YXRpb24vU21hcnRTdG9yZS5XZWIvVmlld3MvUHJpdmF0ZU1lc3NhZ2VzL1ZpZXcuY3NodG1sCisrKyBiL3NyYy9QcmVzZW50YXRpb24vU21hcnRTdG9yZS5XZWIvVmlld3MvUHJpdmF0ZU1lc3NhZ2VzL1ZpZXcuY3NodG1sCkBAIC0xLDUgKzEsNiBAQAog77u/QG1vZGVsIFByaXZhdGVNZXNzYWdlTW9kZWwKIEB1c2luZyBTbWFydFN0b3JlLldlYi5Nb2RlbHMuUHJpdmF0ZU1lc3NhZ2VzOworQHVzaW5nIFNtYXJ0U3RvcmUuQ29yZS5IdG1sOwogQHsKICAgICBMYXlvdXQgPSAiX0xheW91dCI7CiAgICAgSHRtbC5BZGRUaXRsZVBhcnRzKFQoIlBhZ2VUaXRsZS5WaWV3UE0iKS5UZXh0KTsKQEAgLTI4LDcgKzI5LDcgQEAKICAgICAgICAgICAgIDxkaXYgY2xhc3M9ImNvbC1zbS05Ij4KICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSJjYXJkIj4KICAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0iY2FyZC1ib2R5IiBkaXI9ImF1dG8iPgotICAgICAgICAgICAgICAgICAgICAgICAgQEh0bWwuUmF3KE1vZGVsLk1lc3NhZ2UpCisgICAgICAgICAgICAgICAgICAgICAgICBASHRtbC5SYXcoSHRtbFV0aWxzLlNhbml0aXplSHRtbChNb2RlbC5NZXNzYWdlLCB0cnVlKSkKICAgICAgICAgICAgICAgICAgICAgPC9kaXY+CiAgICAgICAgICAgICAgICAgPC9kaXY+CiAgICAgICAgICAgICA8L2Rpdj4=",
"url": "https://github.com/smartstore/SmartStoreNET/commit/5b4e60ae7124df0898975cb8f994f9f23db1fae3.patch"
}
] |
n/a
|
|
GHSA-rgmp-4873-r683
|
Pterodactyl TOTPs can be reused during validity window
| null |
[
{
"commit_message": "[PATCH] Ensure that TOTP tokens cannot be reused (#5481) .../Auth/LoginCheckpointController.php | 19 +- app/Services/Users/ToggleTwoFactorService.php | 2 +- database/Factories/UserFactory.php | 11 +- .../Auth/LoginCheckpointControllerTest.php | 207 ++++++++++++++++++ tests/TestCase.php | 6 +- 5 files changed, 231 insertions(+), 14 deletions(-) create mode 100644 tests/Integration/Http/Controllers/Auth/LoginCheckpointControllerTest.php",
"patch_text_b64": "From 032bf076d92bb2f929fa69c1bac1b89f26b8badf Mon Sep 17 00:00:00 2001
From: Dane Everitt <dane@daneeveritt.com>
Date: Tue, 30 Dec 2025 15:27:11 -0500
Subject: [PATCH] Ensure that TOTP tokens cannot be reused (#5481)

---
 .../Auth/LoginCheckpointController.php        |  19 +-
 app/Services/Users/ToggleTwoFactorService.php |   2 +-
 database/Factories/UserFactory.php            |  11 +-
 .../Auth/LoginCheckpointControllerTest.php    | 207 ++++++++++++++++++
 tests/TestCase.php                            |   6 +-
 5 files changed, 231 insertions(+), 14 deletions(-)
 create mode 100644 tests/Integration/Http/Controllers/Auth/LoginCheckpointControllerTest.php

diff --git a/app/Http/Controllers/Auth/LoginCheckpointController.php b/app/Http/Controllers/Auth/LoginCheckpointController.php
index c6873c9b88..ed212e4556 100644
--- a/app/Http/Controllers/Auth/LoginCheckpointController.php
+++ b/app/Http/Controllers/Auth/LoginCheckpointController.php
@@ -2,6 +2,7 @@
 
 namespace Pterodactyl\Http\Controllers\Auth;
 
+use Carbon\Carbon;
 use Carbon\CarbonImmutable;
 use Carbon\CarbonInterface;
 use Pterodactyl\Models\User;
@@ -70,8 +71,20 @@ public function __invoke(LoginCheckpointRequest $request): JsonResponse
             }
         } else {
             $decrypted = $this->encrypter->decrypt($user->totp_secret);
+            $oldTimestamp = $user->totp_authenticated_at
+                ? (int) floor($user->totp_authenticated_at->unix() / $this->google2FA->getKeyRegeneration())
+                : null;
+
+            $verified = $this->google2FA->verifyKeyNewer(
+                $decrypted,
+                $request->input('authentication_code') ?? '',
+                $oldTimestamp,
+                config('pterodactyl.auth.2fa.window') ?? 1,
+            );
+
+            if ($verified !== false) {
+                $user->update(['totp_authenticated_at' => Carbon::now()]);
 
-            if ($this->google2FA->verifyKey($decrypted, (string) ($request->input('authentication_code') ?? ''), config('pterodactyl.auth.2fa.window'))) {
                 Event::dispatch(new ProvidedAuthenticationToken($user));
 
                 return $this->sendLoginResponse($user, $request);
@@ -105,9 +118,9 @@ protected function isValidRecoveryToken(User $user, string $value): bool
      * will return false if the data is invalid, or if more time has passed than
      * was configured when the session was written.
      */
-    protected function hasValidSessionData(array $data): bool
+    protected function hasValidSessionData(?array $data): bool
     {
-        $validator = $this->validation->make($data, [
+        $validator = $this->validation->make($data ?? [], [
             'user_id' => 'required|integer|min:1',
             'token_value' => 'required|string',
             'expires_at' => 'required',
diff --git a/app/Services/Users/ToggleTwoFactorService.php b/app/Services/Users/ToggleTwoFactorService.php
index 6790b1e3fa..8ed71eb1fc 100644
--- a/app/Services/Users/ToggleTwoFactorService.php
+++ b/app/Services/Users/ToggleTwoFactorService.php
@@ -79,7 +79,7 @@ public function handle(User $user, string $token, ?bool $toggleState = null): ar
             }
 
             $this->repository->withoutFreshModel()->update($user->id, [
-                'totp_authenticated_at' => Carbon::now(),
+                'totp_authenticated_at' => null,
                 'use_totp' => (is_null($toggleState) ? !$user->use_totp : $toggleState),
             ]);
 
diff --git a/database/Factories/UserFactory.php b/database/Factories/UserFactory.php
index 977b032849..8a47746761 100644
--- a/database/Factories/UserFactory.php
+++ b/database/Factories/UserFactory.php
@@ -5,18 +5,13 @@
 use Carbon\Carbon;
 use Ramsey\Uuid\Uuid;
 use Illuminate\Support\Str;
-use Pterodactyl\Models\User;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
+/**
+ * @extends \Illuminate\Database\Eloquent\Factories\Factory<\Pterodactyl\Models\User>
+ */
 class UserFactory extends Factory
 {
-    /**
-     * The name of the factory's corresponding model.
-     *
-     * @var string
-     */
-    protected $model = User::class;
-
     /**
      * Define the model's default state.
      */
diff --git a/tests/Integration/Http/Controllers/Auth/LoginCheckpointControllerTest.php b/tests/Integration/Http/Controllers/Auth/LoginCheckpointControllerTest.php
new file mode 100644
index 0000000000..a5aafcd4e1
--- /dev/null
+++ b/tests/Integration/Http/Controllers/Auth/LoginCheckpointControllerTest.php
@@ -0,0 +1,207 @@
+<?php
+
+namespace Pterodactyl\Tests\Integration\Http\Controllers\Auth;
+
+use Carbon\Carbon;
+use Pterodactyl\Models\User;
+use PragmaRX\Google2FA\Google2FA;
+use Illuminate\Auth\Events\Failed;
+use Illuminate\Support\Facades\Event;
+use Illuminate\Support\Facades\Session;
+use Pterodactyl\Events\Auth\DirectLogin;
+use PHPUnit\Framework\Attributes\TestWith;
+use Pterodactyl\Tests\Integration\Http\HttpTestCase;
+use Pterodactyl\Events\Auth\ProvidedAuthenticationToken;
+
+class LoginCheckpointControllerTest extends HttpTestCase
+{
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        Event::fake([Failed::class, DirectLogin::class, ProvidedAuthenticationToken::class]);
+    }
+
+    /**
+     * Basic test that a user can be signed in using their TOTP token and that
+     * the `totp_authenticated_at` field in the database is updated to the login
+     * verification time.
+     */
+    #[TestWith([null])]
+    #[TestWith([-31])]
+    #[TestWith([-60])]
+    public function testUserCanSignInUsingTotpToken(?int $ts): void
+    {
+        $user = User::factory()->create([
+            'use_totp' => true,
+            'totp_secret' => encrypt(str_repeat('a', 16)),
+            'totp_authenticated_at' => is_null($ts) ? null : Carbon::now()->addSeconds($ts),
+        ]);
+
+        Session::put('auth_confirmation_token', [
+            'user_id' => $user->id,
+            'token_value' => 'token',
+            'expires_at' => now()->addMinutes(5),
+        ]);
+
+        $totp = $this->app->make(Google2FA::class)->getCurrentOtp(str_repeat('a', 16));
+
+        $this->withoutExceptionHandling()->postJson(route('auth.login-checkpoint', [
+            'confirmation_token' => 'token',
+            'authentication_code' => $totp,
+        ]))
+            ->assertOk()
+            ->assertSessionMissing('auth_confirmation_token')
+            ->assertJsonPath('data.complete', true)
+            ->assertJsonPath('data.intended', '/')
+            ->assertJsonPath('data.user.uuid', $user->uuid);
+
+        $this->assertEquals(now(), $user->refresh()->totp_authenticated_at);
+
+        $this->assertAuthenticatedAs($user);
+
+        Event::assertDispatched(fn (DirectLogin $event) => $event->user->is($user) && $event->remember);
+        Event::assertDispatched(fn (ProvidedAuthenticationToken $event) => $event->user->is($user));
+    }
+
+    /**
+     * Test that a TOTP token cannot be reused by verifying that the OTP verification
+     * logic fails if the token's timestamp is before the `totp_authenticated_at`
+     * column value.
+     *
+     * @see https://github.com/pterodactyl/panel/security/advisories/GHSA-rgmp-4873-r683
+     */
+    #[TestWith([1])]
+    #[TestWith([30])]
+    #[TestWith([80])]
+    public function testTotpTokenCannotBeReused(int $seconds): void
+    {
+        $user = User::factory()->create([
+            'use_totp' => true,
+            'totp_secret' => encrypt(str_repeat('a', 16)),
+            'totp_authenticated_at' => now()->addSeconds($seconds),
+        ]);
+
+        Session::put('auth_confirmation_token', [
+            'user_id' => $user->id,
+            'token_value' => 'token',
+            'expires_at' => now()->addMinutes(5),
+        ]);
+
+        $totp = $this->app->make(Google2FA::class)->getCurrentOtp(str_repeat('a', 16));
+
+        $this->postJson(route('auth.login-checkpoint', [
+            'confirmation_token' => 'token',
+            'authentication_code' => $totp,
+        ]))
+            ->assertBadRequest()
+            ->assertJsonPath('errors.0.detail', 'The two-factor authentication token was invalid.');
+
+        $this->assertGuest();
+        $this->assertEquals(now()->addSeconds($seconds), $user->refresh()->totp_authenticated_at);
+
+        Event::assertDispatched(fn (Failed $event) => $event->guard === 'auth' && $event->user->is($user));
+    }
+
+    public function testEndpointReturnsErrorIfSessionMissing(): void
+    {
+        $this->postJson(route('auth.login-checkpoint'))
+            ->assertUnprocessable()
+            ->assertJsonPath('errors.0.meta.source_field', 'confirmation_token')
+            ->assertJsonPath('errors.1.meta.source_field', 'authentication_code')
+            ->assertJsonPath('errors.2.meta.source_field', 'recovery_token');
+
+        $this->postJson(route('auth.login-checkpoint', [
+            'confirmation_token' => 'token',
+            'authentication_code' => '123456',
+        ]))
+            ->assertBadRequest()
+            ->assertJsonPath('errors.0.detail', 'The authentication token provided has expired, please refresh the page and try again.');
+
+        $this->assertGuest();
+
+        Event::assertDispatched(fn (Failed $event) => $event->guard === 'auth');
+    }
+
+    public function testEndpointAppliesThrottling(): void
+    {
+        for ($i = 0; $i < 5; ++$i) {
+            $this->postJson(route('auth.login-checkpoint', ['confirmation_token' => 'token', 'authentication_code' => '123456']))
+                ->assertBadRequest();
+        }
+
+        $this->postJson(route('auth.login-checkpoint', ['confirmation_token' => 'token', 'authentication_code' => '123456']))
+            ->assertTooManyRequests();
+    }
+
+    public function testEndpointBlocksSessionDataMismatch(): void
+    {
+        $user = User::factory()->create([
+            'use_totp' => true,
+            'totp_secret' => str_repeat('a', 16),
+        ]);
+
+        Session::put('auth_confirmation_token', [
+            'user_id' => $user->id,
+            'token_value' => 'token',
+            'expires_at' => now()->addMinutes(5),
+        ]);
+
+        $this->postJson(route('auth.login-checkpoint', [
+            'confirmation_token' => 'wrong-token',
+            'authentication_code' => $this->app->make(Google2FA::class)->getCurrentOtp(str_repeat('a', 16)),
+        ]))
+            ->assertBadRequest();
+
+        $this->assertGuest();
+
+        Event::assertDispatched(Failed::class);
+    }
+
+    public function testEndpointReturnsErrorIfUserDoesNotExist(): void
+    {
+        Session::put('auth_confirmation_token', [
+            'user_id' => 0,
+            'token_value' => 'token',
+            'expires_at' => now()->addMinutes(5),
+        ]);
+
+        $this->postJson(route('auth.login-checkpoint', [
+            'confirmation_token' => 'token',
+            'authentication_code' => '123456',
+        ]))
+            ->assertBadRequest()
+            ->assertJsonPath('errors.0.detail', 'The authentication token provided has expired, please refresh the page and try again.');
+    }
+
+    public function testEndpointAllowsRecoveryToken(): void
+    {
+        $user = User::factory()->create();
+        $token = $user->recoveryTokens()->forceCreate(['token' => password_hash('recovery', PASSWORD_DEFAULT)]);
+
+        Session::put('auth_confirmation_token', [
+            'user_id' => $user->id,
+            'token_value' => 'token',
+            'expires_at' => now()->addMinutes(5),
+        ]);
+
+        $this->postJson(route('auth.login-checkpoint', [
+            'confirmation_token' => 'token',
+            'recovery_token' => 'invalid',
+        ]))
+            ->assertBadRequest()
+            ->assertJsonPath('errors.0.detail', 'The recovery token provided is not valid.');
+
+        $this->assertGuest();
+
+        $this->postJson(route('auth.login-checkpoint', [
+            'confirmation_token' => 'token',
+            'recovery_token' => 'recovery',
+        ]))
+            ->assertOk()
+            ->assertSessionMissing('auth_confirmation_token');
+
+        Event::assertDispatched(ProvidedAuthenticationToken::class);
+        Event::assertDispatched(DirectLogin::class);
+    }
+}
diff --git a/tests/TestCase.php b/tests/TestCase.php
index 955f9dfaf7..9d4597e0f2 100644
--- a/tests/TestCase.php
+++ b/tests/TestCase.php
@@ -15,8 +15,10 @@ public function setUp(): void
     {
         parent::setUp();
 
-        Carbon::setTestNow(Carbon::now());
-        CarbonImmutable::setTestNow(Carbon::now());
+        $now = Carbon::now()->startOfSecond();
+
+        Carbon::setTestNow($now);
+        CarbonImmutable::setTestNow($now);
 
         // Why, you ask? If we don't force this to false it is possible for certain exceptions
         // to show their error message properly in the integration test output, but not actually",
"url": "https://github.com/pterodactyl/panel/commit/032bf076d92bb2f929fa69c1bac1b89f26b8badf.patch"
}
] | null |
CVE-2020-9432
|
openssl_x509_check_host in lua-openssl 0.7.7-1 mishandles X.509 certificate validation because it uses lua_pushboolean for certain non-boolean return values.
|
[
{
"commit_message": "[PATCH] fix security: GSL-2020-026 src/x509.c | 120 +++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 88 insertions(+), 32 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/zhaozg/lua-openssl/commit/a6dc186dd4b6b9e329a93cca3e7e3cfccfdf3cca.patch"
}
] |
n/a
|
|
GHSA-4gmg-gwjh-3mmr
|
phpMyAdmin Cryptographic Vulnerability
| null |
[
{
"commit_message": "[PATCH] Use full alphabet to generate random passwords MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Michal Čihař <michal@cihar.com> js/functions.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSAyMzY5ZGFhN2Y1ZjU1MDc5N2Y1NjBlNmI0NmEwMjFlNDU1OGMyZDcyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/TWljaGFsPTIwPUM0PThDaWhhPUM1PTk5Pz0gPG1pY2hhbEBjaWhhci5jb20+CkRhdGU6IE1vbiwgMjUgSmFuIDIwMTYgMTI6NDQ6MTYgKzAxMDAKU3ViamVjdDogW1BBVENIXSBVc2UgZnVsbCBhbHBoYWJldCB0byBnZW5lcmF0ZSByYW5kb20gcGFzc3dvcmRzCk1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CgpTaWduZWQtb2ZmLWJ5OiBNaWNoYWwgxIxpaGHFmSA8bWljaGFsQGNpaGFyLmNvbT4KLS0tCiBqcy9mdW5jdGlvbnMuanMgfCAyICstCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9qcy9mdW5jdGlvbnMuanMgYi9qcy9mdW5jdGlvbnMuanMKaW5kZXggMGUyZjE0ZDM0ZmNkLi45ZWVjMGMwZTNhNjMgMTAwNjQ0Ci0tLSBhL2pzL2Z1bmN0aW9ucy5qcworKysgYi9qcy9mdW5jdGlvbnMuanMKQEAgLTc3LDcgKzc3LDcgQEAgZnVuY3Rpb24gc3VnZ2VzdFBhc3N3b3JkKHBhc3N3ZF9mb3JtKQogICAgIC8vIHJlc3RyaWN0IHRoZSBwYXNzd29yZCB0byBqdXN0IGxldHRlcnMgYW5kIG51bWJlcnMgdG8gYXZvaWQgcHJvYmxlbXM6CiAgICAgLy8gImVkaXRvcnMgYW5kIHZpZXdlcnMgcmVnYXJkIHRoZSBwYXNzd29yZCBhcyBtdWx0aXBsZSB3b3JkcyBhbmQKICAgICAvLyB0aGluZ3MgbGlrZSBkb3VibGUgY2xpY2sgbm8gbG9uZ2VyIHdvcmsiCi0gICAgdmFyIHB3Y2hhcnMgPSAiYWJjZGVmaGptbnBxcnN0dXZ3eHl6MjM0NTY3ODlBQkNERUZHSEpLTE1OUFFSU1RVVldZWFoiOworICAgIHZhciBwd2NoYXJzID0gImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OUFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWVhaIjsKICAgICB2YXIgcGFzc3dvcmRsZW5ndGggPSAxNjsgICAgLy8gZG8gd2Ugd2FudCB0aGF0IHRvIGJlIGR5bmFtaWM/ICBubywga2VlcCBpdCBzaW1wbGUgOikKICAgICB2YXIgcGFzc3dkID0gcGFzc3dkX2Zvcm0uZ2VuZXJhdGVkX3B3OwogICAgIHZhciByYW5kb21Xb3JkcyA9IG5ldyBJbnQzMkFycmF5KHBhc3N3b3JkbGVuZ3RoKTs=",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/2369daa7f5f550797f560e6b46a021e4558c2d72.patch"
},
{
"commit_message": "[PATCH] Use full alphabet to generate random passwords MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Michal Čihař <michal@cihar.com> js/functions.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA1NTMwYTcyZTE2MmZhYjQ0MjIxODQ4NmE5MGZmMzM2NWM5NmZkZTk4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/TWljaGFsPTIwPUM0PThDaWhhPUM1PTk5Pz0gPG1pY2hhbEBjaWhhci5jb20+CkRhdGU6IE1vbiwgMjUgSmFuIDIwMTYgMTI6NDQ6MTYgKzAxMDAKU3ViamVjdDogW1BBVENIXSBVc2UgZnVsbCBhbHBoYWJldCB0byBnZW5lcmF0ZSByYW5kb20gcGFzc3dvcmRzCk1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CgpTaWduZWQtb2ZmLWJ5OiBNaWNoYWwgxIxpaGHFmSA8bWljaGFsQGNpaGFyLmNvbT4KLS0tCiBqcy9mdW5jdGlvbnMuanMgfCAyICstCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9qcy9mdW5jdGlvbnMuanMgYi9qcy9mdW5jdGlvbnMuanMKaW5kZXggMTIxZDYxZjg1NmY1Li5kYjZmOTgyNTI3OGUgMTAwNjQ0Ci0tLSBhL2pzL2Z1bmN0aW9ucy5qcworKysgYi9qcy9mdW5jdGlvbnMuanMKQEAgLTIxNSw3ICsyMTUsNyBAQCBmdW5jdGlvbiBzdWdnZXN0UGFzc3dvcmQocGFzc3dkX2Zvcm0pCiAgICAgLy8gcmVzdHJpY3QgdGhlIHBhc3N3b3JkIHRvIGp1c3QgbGV0dGVycyBhbmQgbnVtYmVycyB0byBhdm9pZCBwcm9ibGVtczoKICAgICAvLyAiZWRpdG9ycyBhbmQgdmlld2VycyByZWdhcmQgdGhlIHBhc3N3b3JkIGFzIG11bHRpcGxlIHdvcmRzIGFuZAogICAgIC8vIHRoaW5ncyBsaWtlIGRvdWJsZSBjbGljayBubyBsb25nZXIgd29yayIKLSAgICB2YXIgcHdjaGFycyA9ICJhYmNkZWZoam1ucHFyc3R1dnd4eXoyMzQ1Njc4OUFCQ0RFRkdISktMTU5QUVJTVFVWV1lYWiI7CisgICAgdmFyIHB3Y2hhcnMgPSAiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5QUJDREVGR0hJSktMTU5PUFFSU1RVVldZWFoiOwogICAgIHZhciBwYXNzd29yZGxlbmd0aCA9IDE2OyAgICAvLyBkbyB3ZSB3YW50IHRoYXQgdG8gYmUgZHluYW1pYz8gIG5vLCBrZWVwIGl0IHNpbXBsZSA6KQogICAgIHZhciBwYXNzd2QgPSBwYXNzd2RfZm9ybS5nZW5lcmF0ZWRfcHc7CiAgICAgdmFyIHJhbmRvbVdvcmRzID0gbmV3IEludDMyQXJyYXkocGFzc3dvcmRsZW5ndGgpOw==",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/5530a72e162fab442218486a90ff3365c96fde98.patch"
},
{
"commit_message": "[PATCH] Use secure RNG if available MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Recent browsers come with better RNG, so let's use it for generating password instead of Math.random if available. Signed-off-by: Michal Čihař <michal@cihar.com> js/functions.js | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/6a96e67487f2faecb4de4204fee9b96b94020720.patch"
},
{
"commit_message": "[PATCH] Use secure RNG if available MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Recent browsers come with better RNG, so let's use it for generating password instead of Math.random if available. Signed-off-by: Michal Čihař <michal@cihar.com> js/functions.js | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/8b6737735be5787d0b98c6cdfe2c7e3131b1bc95.patch"
},
{
"commit_message": "[PATCH] Use secure RNG if available MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Recent browsers come with better RNG, so let's use it for generating password instead of Math.random if available. Signed-off-by: Michal Čihař <michal@cihar.com> js/functions.js | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/8dedcc1a175eb07debd4fe116407c43694c60b22.patch"
},
{
"commit_message": "[PATCH] Use full alphabet to generate random passwords MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Michal Čihař <michal@cihar.com> js/functions.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA5MTI4NTZiNDMyZDc5NDIwMTg4NGMzNmU1ZjM5MGQ0NDYzMzliNmU0IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/TWljaGFsPTIwPUM0PThDaWhhPUM1PTk5Pz0gPG1pY2hhbEBjaWhhci5jb20+CkRhdGU6IE1vbiwgMjUgSmFuIDIwMTYgMTI6NDQ6MTYgKzAxMDAKU3ViamVjdDogW1BBVENIXSBVc2UgZnVsbCBhbHBoYWJldCB0byBnZW5lcmF0ZSByYW5kb20gcGFzc3dvcmRzCk1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CgpTaWduZWQtb2ZmLWJ5OiBNaWNoYWwgxIxpaGHFmSA8bWljaGFsQGNpaGFyLmNvbT4KLS0tCiBqcy9mdW5jdGlvbnMuanMgfCAyICstCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9qcy9mdW5jdGlvbnMuanMgYi9qcy9mdW5jdGlvbnMuanMKaW5kZXggZDQ3YjAxNDU1OGMyLi4xY2Y1MjgzMWFiYjAgMTAwNjQ0Ci0tLSBhL2pzL2Z1bmN0aW9ucy5qcworKysgYi9qcy9mdW5jdGlvbnMuanMKQEAgLTMxOSw3ICszMTksNyBAQCBmdW5jdGlvbiBzdWdnZXN0UGFzc3dvcmQocGFzc3dkX2Zvcm0pCiAgICAgLy8gcmVzdHJpY3QgdGhlIHBhc3N3b3JkIHRvIGp1c3QgbGV0dGVycyBhbmQgbnVtYmVycyB0byBhdm9pZCBwcm9ibGVtczoKICAgICAvLyAiZWRpdG9ycyBhbmQgdmlld2VycyByZWdhcmQgdGhlIHBhc3N3b3JkIGFzIG11bHRpcGxlIHdvcmRzIGFuZAogICAgIC8vIHRoaW5ncyBsaWtlIGRvdWJsZSBjbGljayBubyBsb25nZXIgd29yayIKLSAgICB2YXIgcHdjaGFycyA9ICJhYmNkZWZoam1ucHFyc3R1dnd4eXoyMzQ1Njc4OUFCQ0RFRkdISktMTU5QUVJTVFVWV1lYWiI7CisgICAgdmFyIHB3Y2hhcnMgPSAiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5QUJDREVGR0hJSktMTU5PUFFSU1RVVldZWFoiOwogICAgIHZhciBwYXNzd29yZGxlbmd0aCA9IDE2OyAgICAvLyBkbyB3ZSB3YW50IHRoYXQgdG8gYmUgZHluYW1pYz8gIG5vLCBrZWVwIGl0IHNpbXBsZSA6KQogICAgIHZhciBwYXNzd2QgPSBwYXNzd2RfZm9ybS5nZW5lcmF0ZWRfcHc7CiAgICAgdmFyIHJhbmRvbVdvcmRzID0gbmV3IEludDMyQXJyYXkocGFzc3dvcmRsZW5ndGgpOw==",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/912856b432d794201884c36e5f390d446339b6e4.patch"
}
] | null |
GHSA-2c2h-2855-mf97
|
Apache Camel: Camel Message Header Injection via Improper Filtering
| null |
[
{
"commit_message": "[PATCH] CAMEL-21828: Fix DefaultHeaderFilterStrategy when filtering in lower-case mode. (#17351) .../http/PlatformHttpCamelHeadersTest.java | 60 +++++++++++++++++++ .../impl/DefaultHeaderFilterStrategyTest.java | 22 +++++++ .../support/DefaultHeaderFilterStrategy.java | 32 +++++++--- 3 files changed, 107 insertions(+), 7 deletions(-) create mode 100644 components/camel-platform-http/src/test/java/org/apache/camel/component/platform/http/PlatformHttpCamelHeadersTest.java",
"patch_text_b64": "From 23a833eec6131a3cdce6e4b1b40b3ac2035b6adf Mon Sep 17 00:00:00 2001
From: Claus Ibsen <claus.ibsen@gmail.com>
Date: Tue, 4 Mar 2025 12:16:58 +0000
Subject: [PATCH] CAMEL-21828: Fix DefaultHeaderFilterStrategy when filtering
 in lower-case mode. (#17351)

---
 .../http/PlatformHttpCamelHeadersTest.java    | 60 +++++++++++++++++++
 .../impl/DefaultHeaderFilterStrategyTest.java | 22 +++++++
 .../support/DefaultHeaderFilterStrategy.java  | 32 +++++++---
 3 files changed, 107 insertions(+), 7 deletions(-)
 create mode 100644 components/camel-platform-http/src/test/java/org/apache/camel/component/platform/http/PlatformHttpCamelHeadersTest.java

diff --git a/components/camel-platform-http/src/test/java/org/apache/camel/component/platform/http/PlatformHttpCamelHeadersTest.java b/components/camel-platform-http/src/test/java/org/apache/camel/component/platform/http/PlatformHttpCamelHeadersTest.java
new file mode 100644
index 0000000000000..15d8ee7b68a4c
--- /dev/null
+++ b/components/camel-platform-http/src/test/java/org/apache/camel/component/platform/http/PlatformHttpCamelHeadersTest.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.platform.http;
+
+import org.apache.camel.Exchange;
+import org.apache.camel.builder.RouteBuilder;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+
+public class PlatformHttpCamelHeadersTest extends AbstractPlatformHttpTest {
+
+    @Test
+    void testFilterCamelHeaders() {
+        given()
+                .header("Accept", "application/json")
+                .header("User-Agent", "User-Agent-Camel")
+                .header("caMElHttpResponseCode", "503")
+                .port(port)
+                .expect()
+                .statusCode(200)
+                .header("Accept", (String) null)
+                .header("User-Agent", (String) null)
+                .header("CamelHttpResponseCode", (String) null)
+                .when()
+                .get("/get");
+    }
+
+    @Override
+    protected RouteBuilder routes() {
+        return new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("platform-http:/get")
+                        .process(e -> {
+                            Assertions.assertEquals("application/json", e.getMessage().getHeader("Accept"));
+                            Assertions.assertEquals("User-Agent-Camel", e.getMessage().getHeader("User-Agent"));
+                            Assertions.assertNull(e.getMessage().getHeader(Exchange.HTTP_RESPONSE_CODE));
+                        })
+                        .setBody().constant("");
+            }
+        };
+    }
+
+}
diff --git a/core/camel-core/src/test/java/org/apache/camel/impl/DefaultHeaderFilterStrategyTest.java b/core/camel-core/src/test/java/org/apache/camel/impl/DefaultHeaderFilterStrategyTest.java
index 6ff641362c243..cb00968b24d9e 100644
--- a/core/camel-core/src/test/java/org/apache/camel/impl/DefaultHeaderFilterStrategyTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/impl/DefaultHeaderFilterStrategyTest.java
@@ -175,4 +175,26 @@ public void testInStartsWith() {
         assertTrue(comp.applyFilterToExternalHeaders("org.apache.camel.component.jetty.session", "true", exchange));
     }
 
+    @Test
+    public void testInStartsWithLowerCase() {
+        DefaultHeaderFilterStrategy comp = new DefaultHeaderFilterStrategy();
+        comp.setLowerCase(true);
+
+        comp.setInFilterStartsWith(CAMEL_FILTER_STARTS_WITH);
+
+        Exchange exchange = new DefaultExchange(context);
+        exchange.getIn().setHeader("bar", 123);
+        exchange.getIn().setHeader("foo", "cheese");
+        exchange.getIn().setHeader("caMElVersion", "3.7");
+        exchange.getIn().setHeader("org.apache.CAMEL.component.jetty.session", "true");
+
+        assertTrue(comp.applyFilterToExternalHeaders("caMElVersion", 123, exchange));
+        assertTrue(comp.applyFilterToExternalHeaders("cAmelResponseCode", 503, exchange));
+
+        assertFalse(comp.applyFilterToExternalHeaders("bar", 123, exchange));
+        assertFalse(comp.applyFilterToExternalHeaders("foo", "cheese", exchange));
+        assertTrue(comp.applyFilterToExternalHeaders("CamelVersion", "3.7", exchange));
+        assertTrue(comp.applyFilterToExternalHeaders("org.apache.camel.component.jetty.session", "true", exchange));
+    }
+
 }
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/DefaultHeaderFilterStrategy.java b/core/camel-support/src/main/java/org/apache/camel/support/DefaultHeaderFilterStrategy.java
index ae4b11b979174..28ef62125e58b 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/DefaultHeaderFilterStrategy.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/DefaultHeaderFilterStrategy.java
@@ -17,7 +17,6 @@
 package org.apache.camel.support;
 
 import java.util.HashSet;
-import java.util.Locale;
 import java.util.Set;
 import java.util.regex.Pattern;
 
@@ -344,20 +343,28 @@ private boolean doFiltering(Direction direction, String headerName, Object heade
             startsWith = inFilterStartsWith;
         }
 
+        String lower = null;
+
         if (startsWith != null) {
             if (tryHeaderMatch(headerName, startsWith)) {
                 return filterOnMatch;
             }
+            if (lowerCase) {
+                lower = headerName.toLowerCase();
+                if (tryHeaderMatch(lower, startsWith)) {
+                    return filterOnMatch;
+                }
+            }
         }
 
         if (pattern != null) {
-            if (tryPattern(headerName, pattern)) {
+            if (tryPattern(headerName, lower, pattern)) {
                 return filterOnMatch;
             }
         }
 
         if (filter != null) {
-            if (evalFilterMatch(headerName, filter)) {
+            if (evalFilterMatch(headerName, lower, filter)) {
                 return filterOnMatch;
             }
         }
@@ -365,7 +372,7 @@ private boolean doFiltering(Direction direction, String headerName, Object heade
         return extendedFilter(direction, headerName, headerValue, exchange);
     }
 
-    private boolean tryPattern(String headerName, Pattern pattern) {
+    private boolean tryPattern(String headerName, String lower, Pattern pattern) {
         // optimize if its the default pattern as we know the pattern is to check for keys starting with Camel
         if (pattern == CAMEL_FILTER_PATTERN) {
             boolean match = headerName.startsWith("Camel") || headerName.startsWith("camel")
@@ -373,6 +380,15 @@ private boolean tryPattern(String headerName, Pattern pattern) {
             if (match) {
                 return true;
             }
+            if (lowerCase) {
+                if (lower == null) {
+                    lower = headerName.toLowerCase();
+                }
+                match = lower.startsWith("camel") || lower.startsWith("org.apache.camel.");
+                if (match) {
+                    return true;
+                }
+            }
         } else if (pattern.matcher(headerName).matches()) {
             return true;
         }
@@ -389,15 +405,17 @@ private boolean tryHeaderMatch(String headerName, String[] startsWith) {
         return false;
     }
 
-    private boolean evalFilterMatch(String headerName, Set<String> filter) {
+    private boolean evalFilterMatch(String headerName, String lower, Set<String> filter) {
         if (isCaseInsensitive()) {
             for (String filterString : filter) {
                 if (filterString.equalsIgnoreCase(headerName)) {
                     return true;
                 }
             }
-        } else if (isLowerCase()) {
-            String lower = headerName.toLowerCase(Locale.ENGLISH);
+        } else if (lowerCase) {
+            if (lower == null) {
+                lower = headerName.toLowerCase();
+            }
             if (filter.contains(lower)) {
                 return true;
             }",
"url": "https://github.com/apache/camel/commit/23a833eec6131a3cdce6e4b1b40b3ac2035b6adf.patch"
},
{
"commit_message": "[PATCH] CAMEL-21828: Fix DefaultHeaderFilterStrategy when filtering in lower-case mode (#17362) .../http/PlatformHttpCamelHeadersTest.java | 60 +++++++++++++++++++ .../impl/DefaultHeaderFilterStrategyTest.java | 23 +++++++ .../support/DefaultHeaderFilterStrategy.java | 14 +++++ 3 files changed, 97 insertions(+) create mode 100644 components/camel-platform-http/src/test/java/org/apache/camel/component/platform/http/PlatformHttpCamelHeadersTest.java",
"patch_text_b64": "From 45a6b74f7f8af8fd58f197566938a9534392a624 Mon Sep 17 00:00:00 2001
From: Claus Ibsen <claus.ibsen@gmail.com>
Date: Wed, 5 Mar 2025 14:14:48 +0000
Subject: [PATCH] CAMEL-21828: Fix DefaultHeaderFilterStrategy when filtering
 in lower-case mode (#17362)

---
 .../http/PlatformHttpCamelHeadersTest.java    | 60 +++++++++++++++++++
 .../impl/DefaultHeaderFilterStrategyTest.java | 23 +++++++
 .../support/DefaultHeaderFilterStrategy.java  | 14 +++++
 3 files changed, 97 insertions(+)
 create mode 100644 components/camel-platform-http/src/test/java/org/apache/camel/component/platform/http/PlatformHttpCamelHeadersTest.java

diff --git a/components/camel-platform-http/src/test/java/org/apache/camel/component/platform/http/PlatformHttpCamelHeadersTest.java b/components/camel-platform-http/src/test/java/org/apache/camel/component/platform/http/PlatformHttpCamelHeadersTest.java
new file mode 100644
index 0000000000000..15d8ee7b68a4c
--- /dev/null
+++ b/components/camel-platform-http/src/test/java/org/apache/camel/component/platform/http/PlatformHttpCamelHeadersTest.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.platform.http;
+
+import org.apache.camel.Exchange;
+import org.apache.camel.builder.RouteBuilder;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+
+public class PlatformHttpCamelHeadersTest extends AbstractPlatformHttpTest {
+
+    @Test
+    void testFilterCamelHeaders() {
+        given()
+                .header("Accept", "application/json")
+                .header("User-Agent", "User-Agent-Camel")
+                .header("caMElHttpResponseCode", "503")
+                .port(port)
+                .expect()
+                .statusCode(200)
+                .header("Accept", (String) null)
+                .header("User-Agent", (String) null)
+                .header("CamelHttpResponseCode", (String) null)
+                .when()
+                .get("/get");
+    }
+
+    @Override
+    protected RouteBuilder routes() {
+        return new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("platform-http:/get")
+                        .process(e -> {
+                            Assertions.assertEquals("application/json", e.getMessage().getHeader("Accept"));
+                            Assertions.assertEquals("User-Agent-Camel", e.getMessage().getHeader("User-Agent"));
+                            Assertions.assertNull(e.getMessage().getHeader(Exchange.HTTP_RESPONSE_CODE));
+                        })
+                        .setBody().constant("");
+            }
+        };
+    }
+
+}
diff --git a/core/camel-core/src/test/java/org/apache/camel/impl/DefaultHeaderFilterStrategyTest.java b/core/camel-core/src/test/java/org/apache/camel/impl/DefaultHeaderFilterStrategyTest.java
index bcf714451df62..1556cd965e42f 100644
--- a/core/camel-core/src/test/java/org/apache/camel/impl/DefaultHeaderFilterStrategyTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/impl/DefaultHeaderFilterStrategyTest.java
@@ -25,6 +25,7 @@
 import org.apache.camel.support.DefaultHeaderFilterStrategy;
 import org.junit.jupiter.api.Test;
 
+import static org.apache.camel.support.DefaultHeaderFilterStrategy.CAMEL_FILTER_PATTERN;
 import static org.apache.camel.support.DefaultHeaderFilterStrategy.CAMEL_FILTER_STARTS_WITH;
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -175,4 +176,26 @@ public void testInStartsWith() {
         assertTrue(comp.applyFilterToExternalHeaders("org.apache.camel.component.jetty.session", "true", exchange));
     }
 
+    @Test
+    public void testInStartsWithLowerCase() {
+        DefaultHeaderFilterStrategy comp = new DefaultHeaderFilterStrategy();
+        comp.setLowerCase(true);
+
+        comp.setInFilterStartsWith(CAMEL_FILTER_STARTS_WITH);
+
+        Exchange exchange = new DefaultExchange(context);
+        exchange.getIn().setHeader("bar", 123);
+        exchange.getIn().setHeader("foo", "cheese");
+        exchange.getIn().setHeader("caMElVersion", "3.7");
+        exchange.getIn().setHeader("org.apache.CAMEL.component.jetty.session", "true");
+
+        assertTrue(comp.applyFilterToExternalHeaders("caMElVersion", 123, exchange));
+        assertTrue(comp.applyFilterToExternalHeaders("cAmelResponseCode", 503, exchange));
+
+        assertFalse(comp.applyFilterToExternalHeaders("bar", 123, exchange));
+        assertFalse(comp.applyFilterToExternalHeaders("foo", "cheese", exchange));
+        assertTrue(comp.applyFilterToExternalHeaders("CamelVersion", "3.7", exchange));
+        assertTrue(comp.applyFilterToExternalHeaders("org.apache.camel.component.jetty.session", "true", exchange));
+    }
+
 }
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/DefaultHeaderFilterStrategy.java b/core/camel-support/src/main/java/org/apache/camel/support/DefaultHeaderFilterStrategy.java
index eb091d31ad28c..f20392630afbc 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/DefaultHeaderFilterStrategy.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/DefaultHeaderFilterStrategy.java
@@ -314,6 +314,13 @@ private boolean doFiltering(Direction direction, String headerName, Object heade
                 if (match) {
                     return filterOnMatch;
                 }
+                if (isLowerCase()) {
+                    String lower = headerName.toLowerCase(Locale.ENGLISH);
+                    match = lower.startsWith(s);
+                    if (match) {
+                        return filterOnMatch;
+                    }
+                }
             }
         }
 
@@ -325,6 +332,13 @@ private boolean doFiltering(Direction direction, String headerName, Object heade
                 if (match) {
                     return filterOnMatch;
                 }
+                if (isLowerCase()) {
+                    String lower = headerName.toLowerCase(Locale.ENGLISH);
+                    match = lower.startsWith("camel") || lower.startsWith("org.apache.camel.");
+                    if (match) {
+                        return true;
+                    }
+                }
             } else if (pattern.matcher(headerName).matches()) {
                 return filterOnMatch;
             }",
"url": "https://github.com/apache/camel/commit/45a6b74f7f8af8fd58f197566938a9534392a624.patch"
}
] | null |
GHSA-wpvx-26f7-65q3
|
Mayan EDMS multiple cross-site scripting (XSS) vulnerabilities
| null |
[
{
"commit_message": "[PATCH] Remove the striptags functionality, fixes some instances of XSS, issue #3 .../templates/calculate_form_title.html | 12 +++---- apps/common/templates/generic_detail.html | 28 +++++++-------- apps/common/templates/generic_form.html | 8 ++--- apps/common/templates/generic_list.html | 2 +- .../templates/generic_list_horizontal.html | 2 +- .../templates/generic_list_subtemplate.html | 36 +++++++++---------- 6 files changed, 42 insertions(+), 46 deletions(-)",
"patch_text_b64": "From 398c480c10416d76e7c1dcb607e726e8fc988e72 Mon Sep 17 00:00:00 2001
From: Roberto Rosario <roberto.rosario.gonzalez@gmail.com>
Date: Thu, 22 May 2014 17:27:06 -0400
Subject: [PATCH] Remove the striptags functionality, fixes some instances of
 XSS, issue #3

---
 .../templates/calculate_form_title.html       | 12 +++----
 apps/common/templates/generic_detail.html     | 28 +++++++--------
 apps/common/templates/generic_form.html       |  8 ++---
 apps/common/templates/generic_list.html       |  2 +-
 .../templates/generic_list_horizontal.html    |  2 +-
 .../templates/generic_list_subtemplate.html   | 36 +++++++++----------
 6 files changed, 42 insertions(+), 46 deletions(-)

diff --git a/apps/common/templates/calculate_form_title.html b/apps/common/templates/calculate_form_title.html
index 2994f1d3387..adaec981d30 100644
--- a/apps/common/templates/calculate_form_title.html
+++ b/apps/common/templates/calculate_form_title.html
@@ -1,10 +1,6 @@
 {% load i18n %}
 {% if title %}
-    {% if striptags %}
-        {{ title|capfirst|striptags }}
-    {% else %}
-        {{ title|capfirst|safe }}
-    {% endif %}
+    {{ title|capfirst }}
 {% else %}
     {% if read_only %}
         {% if object_name %}
@@ -15,9 +11,9 @@
     {% else %}
         {% if object %}
             {% if object_name %}
-                {% blocktrans %}Edit {{ object_name }}:{% endblocktrans %} {% if not striptags %}<a href="{{ object.get_absolute_url }}">{% endif %}{{ object|capfirst }}{% if not striptags %}</a>{% endif %}
+                {% blocktrans with object as object and object_name as object_name %}Edit {{ object_name }}: {{ object }}{% endblocktrans %}
             {% else %}
-                {% trans "Edit" %}: {% if not striptags %}<a href="{{ object.get_absolute_url }}">{% endif %}{{ object|capfirst }}{% if not striptags %}</a>{% endif %}
+                {% blocktrans with object as object %}Edit: {{ object }}{% endblocktrans %}
             {% endif %}
         {% else %}
             {% if object_name %}
@@ -25,6 +21,6 @@
             {% else %}
                 {% trans "Create" %}
             {% endif %}
-        {% endif %}                
+        {% endif %}
     {% endif %}
 {% endif %}
diff --git a/apps/common/templates/generic_detail.html b/apps/common/templates/generic_detail.html
index c5cc9789e89..e7f0dac78a8 100644
--- a/apps/common/templates/generic_detail.html
+++ b/apps/common/templates/generic_detail.html
@@ -2,15 +2,15 @@
 {% load i18n %}
 {% load subtemplates_tags %}
 
-{% block title %} :: {% with "true" as read_only %}{% with "true" as striptags %}{% include "calculate_form_title.html" %}{% endwith %}{% endwith %}{% endblock %}
+{% block title %} :: {% with "true" as read_only %}{% include "calculate_form_title.html" %}{% endwith %}{% endblock %}
 
 {% block sidebar %}
     {% for subtemplate in sidebar_subtemplates %}
         <div class="generic_subform">
             {% include subtemplate %}
-        </div>        
+        </div>
     {% endfor %}
-  
+
     {% for subtemplate in sidebar_subtemplates_list %}
         {% with "true" as side_bar %}
             {% if subtemplate.form %}
@@ -26,18 +26,18 @@
             {% endif %}
                 </div>
                 {% if subtemplate.grid_clear or not subtemplate.grid %}
-                    <div class=""></div> 
+                    <div class=""></div>
             {% endif %}
         {% endwith %}
-    {% endfor %}     
+    {% endfor %}
 {% endblock %}
 
 {% block stylesheets %}
     <style type="text/css">
-        #subform form  textarea, 
+        #subform form  textarea,
         #subform form  select option,
-        #subform form  input, 
-        #subform form  select, 
+        #subform form  input,
+        #subform form  select,
         #subform form  input { background: none; color: black; border: none; }
     </style>
 {% endblock %}
@@ -51,14 +51,14 @@
                 </div>
             </div>
             {% if grid_clear or not grid %}
-                <div class=""></div> 
+                <div class=""></div>
             {% endif %}
         {% endwith %}
     {% endif %}
-    
+
     <div class="container_12">
         {% for subtemplate in subtemplates_list %}
-            <div class="grid_{{ subtemplate.grid|default:12 }}">       
+            <div class="grid_{{ subtemplate.grid|default:12 }}">
                 {% with "true" as read_only %}
                     {% render_subtemplate subtemplate.name subtemplate.context as rendered_subtemplate %}
                     <div class="generic_subform">
@@ -67,10 +67,10 @@
                 {% endwith %}
             </div>
             {% if subtemplate.grid_clear or not subtemplate.grid %}
-                <div class="clear"></div> 
+                <div class="clear"></div>
             {% endif %}
          {% endfor %}
-    </div>    
-    
+    </div>
+
 {% endblock %}
 
diff --git a/apps/common/templates/generic_form.html b/apps/common/templates/generic_form.html
index f78216e9870..5fedec55279 100644
--- a/apps/common/templates/generic_form.html
+++ b/apps/common/templates/generic_form.html
@@ -1,7 +1,7 @@
 {% extends "base.html" %}
 {% load subtemplates_tags %}
 
-{% block title %} :: {% with "true" as striptags %}{% include "calculate_form_title.html" %}{% endwith %}{% endblock %}
+{% block title %} :: {% include "calculate_form_title.html" %}{% endblock %}
 
 {% block sidebar %}
     {% for subtemplate in sidebar_subtemplates_list %}
@@ -25,10 +25,10 @@
             {% include "generic_form_subtemplate.html" %}
         </div>
     {% endif %}
-                             
+
 <div class="container_12">
     {% for subtemplate in subtemplates_list %}
-        <div class="grid_{{ subtemplate.grid|default:12 }}">       
+        <div class="grid_{{ subtemplate.grid|default:12 }}">
             {% if subtemplate.form %}
                 {% render_subtemplate subtemplate.name subtemplate.context as rendered_subtemplate %}
                     <div class="generic_subform">
@@ -40,7 +40,7 @@
             {% endif %}
         </div>
         {% if subtemplate.grid_clear or not subtemplate.grid %}
-            <div class="clear"></div> 
+            <div class="clear"></div>
         {% endif %}
      {% endfor %}
 </div>
diff --git a/apps/common/templates/generic_list.html b/apps/common/templates/generic_list.html
index 19e7a34b51f..d1fb13ac250 100644
--- a/apps/common/templates/generic_list.html
+++ b/apps/common/templates/generic_list.html
@@ -3,7 +3,7 @@
 {% load navigation_tags %}
 {% load subtemplates_tags %}
 
-{% block title %} :: {% blocktrans with title|striptags as stripped_title %}List of {{ stripped_title }}{% endblocktrans %}{% endblock %}
+{% block title %} :: {% blocktrans with title as title %}List of {{ title }}{% endblocktrans %}{% endblock %}
 {#{% block secondary_links %}{{ secondary_links|safe }}{% endblock %}#}
 
 {% block sidebar %}
diff --git a/apps/common/templates/generic_list_horizontal.html b/apps/common/templates/generic_list_horizontal.html
index c70d5299ec5..39915c8ef50 100644
--- a/apps/common/templates/generic_list_horizontal.html
+++ b/apps/common/templates/generic_list_horizontal.html
@@ -3,7 +3,7 @@
 {% load navigation_tags %}
 {% load subtemplates_tags %}
 
-{% block title %} :: {% blocktrans with title|striptags as stripped_title %}List of {{ stripped_title }}{% endblocktrans %}{% endblock %}
+{% block title %} :: {% blocktrans with title as title %}List of {{ title }}{% endblocktrans %}{% endblock %}
 {#{% block secondary_links %}{{ secondary_links|safe }}{% endblock %}#}
 
 {% block sidebar %}
diff --git a/apps/common/templates/generic_list_subtemplate.html b/apps/common/templates/generic_list_subtemplate.html
index 81dfa73983c..6d826f3f078 100644
--- a/apps/common/templates/generic_list_subtemplate.html
+++ b/apps/common/templates/generic_list_subtemplate.html
@@ -16,8 +16,8 @@ <h3>
     </h3>
     <div class="content">
         <p>
-{% else %}    
-    {% autopaginate object_list %} 
+{% else %}
+    {% autopaginate object_list %}
     <div class="content">
     <h2 class="title">
         {% ifnotequal page_obj.paginator.num_pages 1 %}
@@ -53,9 +53,9 @@ <h2 class="title">
                             </button>
                         </div>
                     {% endif %}
-                {% endif %}          
-            {% endif %}          
-        
+                {% endif %}
+            {% endif %}
+
             {% if scrollable_content %}
                 <div style="border: 1px solid; height: {{ scrollable_content_height }}; overflow: auto;">
             {% endif %}
@@ -78,11 +78,11 @@ <h2 class="title">
 
                             {% for column in object_list.0|get_model_list_columns %}
                                 <th>{{ column.name|capfirst }}</th>
-                            {% endfor %}            
+                            {% endfor %}
 
                             {% for column in extra_columns %}
                                 <th>{{ column.name|capfirst }}</th>
-                            {% endfor %}        
+                            {% endfor %}
 
                             {% if not hide_links %}
                                 <th class="">&nbsp;</th>
@@ -91,7 +91,7 @@ <h2 class="title">
                     {% endif %}
                     {% for object in object_list %}
                         <tr class="{% cycle 'odd' 'even2' %}">
-                        {% if multi_select or multi_select_as_buttons %}    
+                        {% if multi_select or multi_select_as_buttons %}
                             <td>
                             {% if multi_select_item_properties %}
                                 <input type="checkbox" class="checkbox" name="properties_{{ object|get_encoded_parameter:multi_select_item_properties }}" value="" />
@@ -117,7 +117,7 @@ <h2 class="title">
                             {% else %}
                                 <td>{{ object|object_property:column.attribute }}</td>
                             {% endif %}
-                        {% endfor %}                        
+                        {% endfor %}
                         {% if not hide_columns %}
                             {% for column in object|get_model_list_columns %}
                                 <td>{{ object|object_property:column.attribute }}</td>
@@ -149,15 +149,15 @@ <h2 class="title">
                             {% endif %}
                         </tr>
                     {% empty %}
-                        <tr><td colspan=99 class="tc">{% blocktrans with title|striptags as stripped_title %}There are no {{ stripped_title }}{% endblocktrans %}</td></tr>
+                        <tr><td colspan=99 class="tc">{% blocktrans with title as title %}There are no {{ title }}{% endblocktrans %}</td></tr>
                     {% endfor %}
                 </tbody>
             </table>
-            
+
             {% if scrollable_content %}
-                </div>            
-            {% endif %}            
-            
+                </div>
+            {% endif %}
+
             {% if object_list %}
                 {% if multi_select or multi_select_as_buttons %}
                     {% if multi_select_as_buttons %}
@@ -179,13 +179,13 @@ <h2 class="title">
                             </button>
                         </div>
                     {% endif %}
-                {% endif %}  
-            {% endif %}  
+                {% endif %}
+            {% endif %}
         </form>
         {% paginate %}
-        
+
         {% if side_bar %}
             </p>
-        {% endif %} 
+        {% endif %}
     </div>
 </div>",
"url": "https://github.com/mayan-edms/mayan-edms/commit/398c480c10416d76e7c1dcb607e726e8fc988e72.patch"
}
] | null |
GHSA-wxr5-93ph-8wr9
|
Apache Commons Improper Access Control vulnerability
| null |
[
{
"commit_message": "[PATCH] Add org.apache.commons.beanutils.SuppressPropertiesBeanIntrospector.SUPPRESS_DECLARING_CLASS src/changes/changes.xml | 16 +++ .../commons/beanutils2/PropertyUtilsBean.java | 1 + .../SuppressPropertiesBeanIntrospector.java | 14 ++- .../apache/commons/beanutils2/TestEnum.java | 33 ++++++ .../commons/beanutils2/package-info.java | 8 +- .../bugs/EnumDeclaringClassTest.java | 108 ++++++++++++++++++ 6 files changed, 178 insertions(+), 2 deletions(-) create mode 100644 src/main/java/org/apache/commons/beanutils2/TestEnum.java create mode 100644 src/test/java/org/apache/commons/beanutils2/bugs/EnumDeclaringClassTest.java",
"patch_text_b64": "From bd20740da25b69552ddef8523beec0837297eaf9 Mon Sep 17 00:00:00 2001
From: Gary Gregory <garydgregory@gmail.com>
Date: Sun, 25 May 2025 09:07:45 -0400
Subject: [PATCH] Add
 org.apache.commons.beanutils.SuppressPropertiesBeanIntrospector.SUPPRESS_DECLARING_CLASS

---
 src/changes/changes.xml                       |  16 +++
 .../commons/beanutils2/PropertyUtilsBean.java |   1 +
 .../SuppressPropertiesBeanIntrospector.java   |  14 ++-
 .../apache/commons/beanutils2/TestEnum.java   |  33 ++++++
 .../commons/beanutils2/package-info.java      |   8 +-
 .../bugs/EnumDeclaringClassTest.java          | 108 ++++++++++++++++++
 6 files changed, 178 insertions(+), 2 deletions(-)
 create mode 100644 src/main/java/org/apache/commons/beanutils2/TestEnum.java
 create mode 100644 src/test/java/org/apache/commons/beanutils2/bugs/EnumDeclaringClassTest.java

diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 4f82d3ccf..e0ee838b9 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -54,6 +54,7 @@
       <action type="fix" dev="ggregory" due-to="Gary Gregory">ResultSetIterator.set(String, Object) now throws IllegalArgumentException instead of RuntimeException to wrap cases of SQLException.</action>
       <action type="fix" dev="ggregory" due-to="Gary Gregory">ResultSetIterator.set(String, String, Object) now throws IllegalArgumentException instead of RuntimeException to wrap cases of SQLException.</action>
       <!-- ADD -->
+      <action type="add" dev="ggregory" due-to="Gary Gregory">Add org.apache.commons.beanutils.SuppressPropertiesBeanIntrospector.SUPPRESS_DECLARING_CLASS.</action>
       <!-- UPDATE -->
       <action type="update" dev="ggregory" due-to="Gary Gregory, Dependabot">Bump org.apache.commons:commons-parent from 78 to 84 #348.</action>
       <action type="update" dev="ggregory" due-to="Gary Gregory">Bump commons-logging:commons-logging from 1.3.4 to 1.3.5.</action>
@@ -258,6 +259,21 @@
         Do not implement Serializable.
       </action>
     </release>
+    <release version="1.11.0" date="YYYY-MM-DD" description="This is a maintenance release and requires Java 8.">
+      <!-- FIX -->
+      <action type="fix" dev="ggregory" due-to="Gary Gregory">BeanComparator.compare(T, T) now throws IllegalArgumentException instead of RuntimeException to wrap all cases of ReflectiveOperationException.</action>
+      <action type="fix" dev="ggregory" due-to="Gary Gregory">MappedMethodReference.get() now throws IllegalStateException instead of RuntimeException to wrap cases of NoSuchMethodException.</action>
+      <action type="fix" dev="ggregory" due-to="Gary Gregory">ResultSetIterator.get(String) now throws IllegalArgumentException instead of RuntimeException to wrap cases of SQLException.</action>
+      <action type="fix" dev="ggregory" due-to="Gary Gregory">ResultSetIterator.hasNext() now throws IllegalStateException instead of RuntimeException to wrap cases of SQLException.</action>
+      <action type="fix" dev="ggregory" due-to="Gary Gregory">ResultSetIterator.next() now throws IllegalStateException instead of RuntimeException to wrap cases of SQLException.</action>
+      <action type="fix" dev="ggregory" due-to="Gary Gregory">ResultSetIterator.set(String, Object) now throws IllegalArgumentException instead of RuntimeException to wrap cases of SQLException.</action>
+      <action type="fix" dev="ggregory" due-to="Gary Gregory">ResultSetIterator.set(String, String, Object) now throws IllegalArgumentException instead of RuntimeException to wrap cases of SQLException.</action>
+      <!-- ADD -->
+      <action type="add" dev="ggregory" due-to="Gary Gregory">Add org.apache.commons.beanutils.SuppressPropertiesBeanIntrospector.SUPPRESS_DECLARING_CLASS.</action>
+      <!-- UPDATE -->
+      <action dev="ggregory" type="update" due-to="Gary Gregory">Bump org.apache.commons:commons-parent from 81 to 84.</action>
+      <action dev="ggregory" type="update" due-to="Gary Gregory">Bump commons-logging:commons-logging from 1.3.4 to 1.3.5.</action>
+    </release>
     <release version="1.10.1" date="2025-01-31" description="This is a maintenance release and requires Java 8.">
       <!-- FIX -->
       <action type="fix" issue="BEANUTILS-541" dev="ggregory" due-to="Sergey Chernov">FluentPropertyBeanIntrospector concurrency issue (backport to 1.X) #325.</action>
diff --git a/src/main/java/org/apache/commons/beanutils2/PropertyUtilsBean.java b/src/main/java/org/apache/commons/beanutils2/PropertyUtilsBean.java
index d1fe015ba..f16f06e33 100644
--- a/src/main/java/org/apache/commons/beanutils2/PropertyUtilsBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/PropertyUtilsBean.java
@@ -1201,6 +1201,7 @@ public final void resetBeanIntrospectors() {
         introspectors.clear();
         introspectors.add(DefaultBeanIntrospector.INSTANCE);
         introspectors.add(SuppressPropertiesBeanIntrospector.SUPPRESS_CLASS);
+        introspectors.add(SuppressPropertiesBeanIntrospector.SUPPRESS_DECLARING_CLASS);
     }
 
     /**
diff --git a/src/main/java/org/apache/commons/beanutils2/SuppressPropertiesBeanIntrospector.java b/src/main/java/org/apache/commons/beanutils2/SuppressPropertiesBeanIntrospector.java
index bb297ffd1..8d9b35622 100644
--- a/src/main/java/org/apache/commons/beanutils2/SuppressPropertiesBeanIntrospector.java
+++ b/src/main/java/org/apache/commons/beanutils2/SuppressPropertiesBeanIntrospector.java
@@ -35,6 +35,7 @@
  * @since 1.9.2
  */
 public class SuppressPropertiesBeanIntrospector implements BeanIntrospector {
+
     /**
      * A specialized instance which is configured to suppress the special {@code class} properties of Java beans. Unintended access to the property
      * {@code class} (which is common to all Java objects) can be a security risk because it also allows access to the class loader. Adding this instance as
@@ -42,7 +43,18 @@ public class SuppressPropertiesBeanIntrospector implements BeanIntrospector {
      */
     public static final SuppressPropertiesBeanIntrospector SUPPRESS_CLASS = new SuppressPropertiesBeanIntrospector(Collections.singleton("class"));
 
-    /** A set with the names of the properties to be suppressed. */
+    /**
+     * A specialized instance which is configured to suppress the special {@code class} properties of Java beans. Unintended access to the call for
+     * {@code declaringClass} (which is common to all Java {@code enum}) can be a security risk because it also allows access to the class loader. Adding this
+     * instance as {@code BeanIntrospector} to an instance of {@code PropertyUtilsBean} suppresses the {@code class} property; it can then no longer be
+     * accessed.
+     *
+     * @since 2.0.0-M2
+     */
+    public static final SuppressPropertiesBeanIntrospector SUPPRESS_DECLARING_CLASS = new SuppressPropertiesBeanIntrospector(
+            Collections.singleton("declaringClass"));
+
+/** A set with the names of the properties to be suppressed. */
     private final Set<String> propertyNames;
 
     /**
diff --git a/src/main/java/org/apache/commons/beanutils2/TestEnum.java b/src/main/java/org/apache/commons/beanutils2/TestEnum.java
new file mode 100644
index 000000000..a64142a07
--- /dev/null
+++ b/src/main/java/org/apache/commons/beanutils2/TestEnum.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.beanutils2;
+
+/**
+ * An {@code enum} test fixture.
+ */
+public enum TestEnum {
+
+    /** Test fixture. */
+    A,
+
+    /** Test fixture. */
+    B,
+
+    /** Test fixture. */
+    C
+}
diff --git a/src/main/java/org/apache/commons/beanutils2/package-info.java b/src/main/java/org/apache/commons/beanutils2/package-info.java
index a2bd66f27..50b8a996c 100644
--- a/src/main/java/org/apache/commons/beanutils2/package-info.java
+++ b/src/main/java/org/apache/commons/beanutils2/package-info.java
@@ -424,7 +424,7 @@
  *
  * <p>A good use case for suppressing properties is the special {@code class}
  * property which is per default available for all beans; it is generated from the
- * {@code getClass()</code> method inherited from <code>Object} which follows the
+ * {@code getClass()} method inherited from {@code Object} which follows the
  * naming conventions for property get methods. Exposing this property in an
  * uncontrolled way can lead to a security vulnerability as it allows access to
  * the class loader. More information can be found at
@@ -437,6 +437,12 @@
  * {@code SUPPRESS_CLASS} constant of
  * {@code SuppressPropertiesBeanIntrospector}.</p>
  *
+ * <p>Another problematic property is the {@code enum} "declaredClass" property,
+ * through which you can also access that class' class loader. The {@code SuppressPropertiesBeanIntrospector}
+ * provides {@code SUPPRESS_DECLARING_CLASS} to workaround this issue.</p>
+ *
+ * <p>Both {@code SUPPRESS_CLASS} and {@code SUPPRESS_DECLARING_CLASS} are enabled by default.</p>
+ *
  * <a id="dynamic"></a>
  * <h2>3. Dynamic Beans (DynaBeans)</h2>
  *
diff --git a/src/test/java/org/apache/commons/beanutils2/bugs/EnumDeclaringClassTest.java b/src/test/java/org/apache/commons/beanutils2/bugs/EnumDeclaringClassTest.java
new file mode 100644
index 000000000..e0d1c2294
--- /dev/null
+++ b/src/test/java/org/apache/commons/beanutils2/bugs/EnumDeclaringClassTest.java
@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.beanutils2.bugs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.apache.commons.beanutils2.BeanUtilsBean;
+import org.apache.commons.beanutils2.PropertyUtilsBean;
+import org.apache.commons.beanutils2.SuppressPropertiesBeanIntrospector;
+import org.apache.commons.beanutils2.TestEnum;
+import org.junit.jupiter.api.Test;
+
+public class EnumDeclaringClassTest {
+
+    public static class Fixture {
+
+        String name = "default";
+        TestEnum testEnum = TestEnum.A;
+
+        public String getName() {
+            return name;
+        }
+
+        public TestEnum getTestEnum() {
+            return testEnum;
+        }
+
+        public void setName(final String name) {
+            this.name = name;
+        }
+
+        public void setTestEnum(final TestEnum day) {
+            this.testEnum = day;
+        }
+    }
+
+    /**
+     * Allow opt-out to make your app less secure but allow access to "declaringClass".
+     */
+    @Test
+    public void testAllowAccessToClassPropertyFromBeanUtilsBean() throws ReflectiveOperationException {
+        final BeanUtilsBean bub = new BeanUtilsBean();
+        final PropertyUtilsBean propertyUtilsBean = bub.getPropertyUtils();
+        propertyUtilsBean.removeBeanIntrospector(SuppressPropertiesBeanIntrospector.SUPPRESS_DECLARING_CLASS);
+        final Fixture fixture = new Fixture();
+        final String string = bub.getProperty(fixture, "testEnum.declaringClass");
+        assertEquals(TestEnum.class.getName(), string);
+        final Class<TestEnum> teClass = assertInstanceOf(Class.class, propertyUtilsBean.getNestedProperty(fixture, "testEnum.declaringClass"));
+        final ClassLoader classLoader = teClass.getClassLoader();
+        assertNotNull(classLoader);
+        assertNotNull(bub.getProperty(fixture, "testEnum.declaringClass.classLoader"));
+        assertInstanceOf(ClassLoader.class, propertyUtilsBean.getNestedProperty(fixture, "testEnum.declaringClass.classLoader"));
+    }
+
+    /**
+     * Allow opt-out to make your app less secure but allow access to "declaringClass".
+     */
+    @Test
+    public void testAllowAccessToClassPropertyFromPropertyUtilsBean() throws ReflectiveOperationException {
+        final PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
+        propertyUtilsBean.removeBeanIntrospector(SuppressPropertiesBeanIntrospector.SUPPRESS_DECLARING_CLASS);
+        final Fixture fixture = new Fixture();
+        final Object cls = propertyUtilsBean.getNestedProperty(fixture, "testEnum.declaringClass");
+        final Class<TestEnum> teClass = assertInstanceOf(Class.class, cls);
+        final ClassLoader classLoader = teClass.getClassLoader();
+        assertNotNull(classLoader);
+        assertInstanceOf(ClassLoader.class, propertyUtilsBean.getNestedProperty(fixture, "testEnum.declaringClass.classLoader"));
+    }
+
+    /**
+     * By default opt-in to security that does not allow access to "declaringClass".
+     */
+    @Test
+    public void testSuppressClassPropertyByDefaultFromBeanUtilsBean() throws ReflectiveOperationException {
+        final Fixture fixture = new Fixture();
+        final BeanUtilsBean bub = new BeanUtilsBean();
+        assertThrows(NoSuchMethodException.class, () -> bub.getProperty(fixture, "testEnum.declaringClass.classLoader"));
+        assertThrows(NoSuchMethodException.class, () -> bub.getPropertyUtils().getNestedProperty(fixture, "testEnum.declaringClass.classLoader"));
+    }
+
+    /**
+     * By default opt-in to security that does not allow access to "declaringClass".
+     */
+    @Test
+    public void testSuppressClassPropertyByDefaultFromPropertyUtilsBean() throws ReflectiveOperationException {
+        final Fixture fixture = new Fixture();
+        final PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
+        assertThrows(NoSuchMethodException.class, () -> propertyUtilsBean.getNestedProperty(fixture, "testEnum.declaringClass.classLoader"));
+    }
+}",
"url": "https://github.com/apache/commons-beanutils/commit/bd20740da25b69552ddef8523beec0837297eaf9.patch"
}
] | null |
CVE-2022-2849
|
Heap-based Buffer Overflow in vim/vim
|
Heap-based Buffer Overflow in GitHub repository vim/vim prior to 9.0.0220.
|
[
{
"commit_message": "[PATCH] patch 9.0.0220: invalid memory access with for loop over NULL string Problem: Invalid memory access with for loop over NULL string. Solution: Make sure mb_ptr2len() consistently returns zero for NUL. src/globals.h | 3 ++- src/mbyte.c | 21 +++++++++++++-------- src/testdir/test_eval_stuff.vim | 12 ++++++++++++ src/version.c | 2 ++ 4 files changed, 29 insertions(+), 9 deletions(-)",
"patch_text_b64": "RnJvbSBmNmQzOWMzMWQyMTc3NTQ5YTk4NmQxNzBlMTkyZDgzNTFiZDU3MWUyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCcmFtIE1vb2xlbmFhciA8QnJhbUB2aW0ub3JnPgpEYXRlOiBUdWUsIDE2IEF1ZyAyMDIyIDE3OjUwOjM4ICswMTAwClN1YmplY3Q6IFtQQVRDSF0gcGF0Y2ggOS4wLjAyMjA6IGludmFsaWQgbWVtb3J5IGFjY2VzcyB3aXRoIGZvciBsb29wIG92ZXIgTlVMTAogc3RyaW5nCgpQcm9ibGVtOiAgICBJbnZhbGlkIG1lbW9yeSBhY2Nlc3Mgd2l0aCBmb3IgbG9vcCBvdmVyIE5VTEwgc3RyaW5nLgpTb2x1dGlvbjogICBNYWtlIHN1cmUgbWJfcHRyMmxlbigpIGNvbnNpc3RlbnRseSByZXR1cm5zIHplcm8gZm9yIE5VTC4KLS0tCiBzcmMvZ2xvYmFscy5oICAgICAgICAgICAgICAgICAgIHwgIDMgKystCiBzcmMvbWJ5dGUuYyAgICAgICAgICAgICAgICAgICAgIHwgMjEgKysrKysrKysrKysrKy0tLS0tLS0tCiBzcmMvdGVzdGRpci90ZXN0X2V2YWxfc3R1ZmYudmltIHwgMTIgKysrKysrKysrKysrCiBzcmMvdmVyc2lvbi5jICAgICAgICAgICAgICAgICAgIHwgIDIgKysKIDQgZmlsZXMgY2hhbmdlZCwgMjkgaW5zZXJ0aW9ucygrKSwgOSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvZ2xvYmFscy5oIGIvc3JjL2dsb2JhbHMuaAppbmRleCAxZmFkYzc0NGY1ZmI1ZC4uMjFmYWJkYmI1MTdjOGMgMTAwNjQ0Ci0tLSBhL3NyYy9nbG9iYWxzLmgKKysrIGIvc3JjL2dsb2JhbHMuaApAQCAtMTAzNSw3ICsxMDM1LDggQEAgRVhURVJOIHZpbWNvbnZfVCBvdXRwdXRfY29udjsJCQkvLyB0eXBlIG9mIG91dHB1dCBjb252ZXJzaW9uCiAgKiAoREJDUykuCiAgKiBUaGUgdmFsdWUgaXMgc2V0IGluIG1iX2luaXQoKTsKICAqLwotLy8gbGVuZ3RoIG9mIGNoYXIgaW4gYnl0ZXMsIGluY2x1ZGluZyBmb2xsb3dpbmcgY29tcG9zaW5nIGNoYXJzCisvLyBMZW5ndGggb2YgY2hhciBpbiBieXRlcywgaW5jbHVkaW5nIGFueSBmb2xsb3dpbmcgY29tcG9zaW5nIGNoYXJzLgorLy8gTlVMIGhhcyBsZW5ndGggemVyby4KIEVYVEVSTiBpbnQgKCptYl9wdHIybGVuKShjaGFyX3UgKnApIElOSVQoPSBsYXRpbl9wdHIybGVuKTsKIAogLy8gaWRlbSwgd2l0aCBsaW1pdCBvbiBzdHJpbmcgbGVuZ3RoCmRpZmYgLS1naXQgYS9zcmMvbWJ5dGUuYyBiL3NyYy9tYnl0ZS5jCmluZGV4IDk0MTQxMWI0YTk0MGZkLi43MzA2NWM3Mzk0NTliNSAxMDA2NDQKLS0tIGEvc3JjL21ieXRlLmMKKysrIGIvc3JjL21ieXRlLmMKQEAgLTEwNzcsMjQgKzEwNzcsMjggQEAgZGJjc19jaGFyMmJ5dGVzKGludCBjLCBjaGFyX3UgKmJ1ZikKIH0KIAogLyoKLSAqIG1iX3B0cjJsZW4oKSBmdW5jdGlvbiBwb2ludGVyLgotICogR2V0IGJ5dGUgbGVuZ3RoIG9mIGNoYXJhY3RlciBhdCAiKnAiIGJ1dCBzdG9wIGF0IGEgTlVMLgotICogRm9yIFVURi04IHRoaXMgaW5jbHVkZXMgZm9sbG93aW5nIGNvbXBvc2luZyBjaGFyYWN0ZXJzLgotICogUmV0dXJucyAwIHdoZW4gKnAgaXMgTlVMLgorICogR2V0IGJ5dGUgbGVuZ3RoIG9mIGNoYXJhY3RlciBhdCAiKnAiLiAgUmV0dXJucyB6ZXJvIHdoZW4gIipwIiBpcyBOVUwuCisgKiBVc2VkIGZvciBtYl9wdHIybGVuKCkgd2hlbiAnZW5jb2RpbmcnIGxhdGluLgogICovCiAgICAgaW50CiBsYXRpbl9wdHIybGVuKGNoYXJfdSAqcCkKIHsKLSByZXR1cm4gTUJfQllURTJMRU4oKnApOworICAgIHJldHVybiAqcCA9PSBOVUwgPyAwIDogMTsKIH0KIAorLyoKKyAqIEdldCBieXRlIGxlbmd0aCBvZiBjaGFyYWN0ZXIgYXQgIipwIi4gIFJldHVybnMgemVybyB3aGVuICIqcCIgaXMgTlVMLgorICogVXNlZCBmb3IgbWJfcHRyMmxlbigpIHdoZW4gJ2VuY29kaW5nJyBEQkNTLgorICovCiAgICAgc3RhdGljIGludAotZGJjc19wdHIybGVuKAotICAgIGNoYXJfdQkqcCkKK2RiY3NfcHRyMmxlbihjaGFyX3UgKnApCiB7CiAgICAgaW50CQlsZW47CiAKLSAgICAvLyBDaGVjayBpZiBzZWNvbmQgYnl0ZSBpcyBub3QgbWlzc2luZy4KKyAgICBpZiAoKnAgPT0gTlVMKQorCXJldHVybiAwOworCisgICAgLy8gaWYgdGhlIHNlY29uZCBieXRlIGlzIG1pc3NpbmcgdGhlIGxlbmd0aCBpcyAxCiAgICAgbGVuID0gTUJfQllURTJMRU4oKnApOwogICAgIGlmIChsZW4gPT0gMiAmJiBwWzFdID09IE5VTCkKIAlsZW4gPSAxOwpAQCAtMjEwNSw2ICsyMTA5LDcgQEAgdXRmX3B0cjJsZW5fbGVuKGNoYXJfdSAqcCwgaW50IHNpemUpCiAvKgogICogUmV0dXJuIHRoZSBudW1iZXIgb2YgYnl0ZXMgdGhlIFVURi04IGVuY29kaW5nIG9mIHRoZSBjaGFyYWN0ZXIgYXQgInAiIHRha2VzLgogICogVGhpcyBpbmNsdWRlcyBmb2xsb3dpbmcgY29tcG9zaW5nIGNoYXJhY3RlcnMuCisgKiBSZXR1cm5zIHplcm8gZm9yIE5VTC4KICAqLwogICAgIGludAogdXRmY19wdHIybGVuKGNoYXJfdSAqcCkKZGlmZiAtLWdpdCBhL3NyYy90ZXN0ZGlyL3Rlc3RfZXZhbF9zdHVmZi52aW0gYi9zcmMvdGVzdGRpci90ZXN0X2V2YWxfc3R1ZmYudmltCmluZGV4IGM2MzA4MmU4ZThiNmRjLi4zMTNkNzkxODUwYzAwMyAxMDA2NDQKLS0tIGEvc3JjL3Rlc3RkaXIvdGVzdF9ldmFsX3N0dWZmLnZpbQorKysgYi9zcmMvdGVzdGRpci90ZXN0X2V2YWxfc3R1ZmYudmltCkBAIC03NSw2ICs3NSwxOCBAQCBmdW5jIFRlc3RfZm9yX2ludmFsaWQoKQogICByZWRyYXcKIGVuZGZ1bmMKIAorZnVuYyBUZXN0X2Zvcl9vdmVyX251bGxfc3RyaW5nKCkKKyAgbGV0IHNhdmVfZW5jID0gJmVuYworICBzZXQgZW5jPWlzbzg4NTkKKyAgbGV0IGNudCA9IDAKKyAgZm9yIGMgaW4gdGVzdF9udWxsX3N0cmluZygpCisgICAgbGV0IGNudCArPSAxCisgIGVuZGZvcgorICBjYWxsIGFzc2VydF9lcXVhbCgwLCBjbnQpCisKKyAgbGV0ICZlbmMgPSBzYXZlX2VuYworZW5kZnVuYworCiBmdW5jIFRlc3RfcmVhZGZpbGVfYmluYXJ5KCkKICAgbmV3CiAgIGNhbGwgc2V0bGluZSgxLCBbJ29uZScsICd0d28nLCAndGhyZWUnXSkKZGlmZiAtLWdpdCBhL3NyYy92ZXJzaW9uLmMgYi9zcmMvdmVyc2lvbi5jCmluZGV4IDNhZmYwNTJhNzViZWI0Li5hNjI5M2UwY2ZhMTYyMCAxMDA2NDQKLS0tIGEvc3JjL3ZlcnNpb24uYworKysgYi9zcmMvdmVyc2lvbi5jCkBAIC03MzUsNiArNzM1LDggQEAgc3RhdGljIGNoYXIgKihmZWF0dXJlc1tdKSA9CiAKIHN0YXRpYyBpbnQgaW5jbHVkZWRfcGF0Y2hlc1tdID0KIHsgICAvKiBBZGQgbmV3IHBhdGNoIG51bWJlciBiZWxvdyB0aGlzIGxpbmUgKi8KKy8qKi8KKyAgICAyMjAsCiAvKiovCiAgICAgMjE5LAogLyoqLw==",
"url": "https://github.com/vim/vim/commit/f6d39c31d2177549a986d170e192d8351bd571e2.patch"
}
] |
CWE-122 Heap-based Buffer Overflow
|
CVE-2018-7480
|
The blkcg_init_queue function in block/blk-cgroup.c in the Linux kernel before 4.11 allows local users to cause a denial of service (double free) or possibly have unspecified other impact by triggering a creation failure.
|
[
{
"commit_message": "[PATCH] blkcg: fix double free of new_blkg in blkcg_init_queue If blkg_create fails, new_blkg passed as an argument will be freed by blkg_create, so there is no need to free it again. Signed-off-by: Hou Tao <houtao1@huawei.com> Signed-off-by: Jens Axboe <axboe@fb.com> block/blk-cgroup.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)",
"patch_text_b64": "RnJvbSA5YjU0ZDgxNmUwMDQyNWMzYTUxNzUxNGUwZDY3N2JiM2NlYzQ5MjU4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBIb3UgVGFvIDxob3V0YW8xQGh1YXdlaS5jb20+CkRhdGU6IEZyaSwgMyBGZWIgMjAxNyAxNzoxOTowNyArMDgwMApTdWJqZWN0OiBbUEFUQ0hdIGJsa2NnOiBmaXggZG91YmxlIGZyZWUgb2YgbmV3X2Jsa2cgaW4gYmxrY2dfaW5pdF9xdWV1ZQoKSWYgYmxrZ19jcmVhdGUgZmFpbHMsIG5ld19ibGtnIHBhc3NlZCBhcyBhbiBhcmd1bWVudCB3aWxsCmJlIGZyZWVkIGJ5IGJsa2dfY3JlYXRlLCBzbyB0aGVyZSBpcyBubyBuZWVkIHRvIGZyZWUgaXQgYWdhaW4uCgpTaWduZWQtb2ZmLWJ5OiBIb3UgVGFvIDxob3V0YW8xQGh1YXdlaS5jb20+ClNpZ25lZC1vZmYtYnk6IEplbnMgQXhib2UgPGF4Ym9lQGZiLmNvbT4KLS0tCiBibG9jay9ibGstY2dyb3VwLmMgfCA0ICstLS0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9ibG9jay9ibGstY2dyb3VwLmMgYi9ibG9jay9ibGstY2dyb3VwLmMKaW5kZXggMzdmZTU5NWNmZDcwMGMuLjI5NWU5OGMyYzhjY2RmIDEwMDY0NAotLS0gYS9ibG9jay9ibGstY2dyb3VwLmMKKysrIGIvYmxvY2svYmxrLWNncm91cC5jCkBAIC0xMDc5LDEwICsxMDc5LDggQEAgaW50IGJsa2NnX2luaXRfcXVldWUoc3RydWN0IHJlcXVlc3RfcXVldWUgKnEpCiAJaWYgKHByZWxvYWRlZCkKIAkJcmFkaXhfdHJlZV9wcmVsb2FkX2VuZCgpOwogCi0JaWYgKElTX0VSUihibGtnKSkgewotCQlibGtnX2ZyZWUobmV3X2Jsa2cpOworCWlmIChJU19FUlIoYmxrZykpCiAJCXJldHVybiBQVFJfRVJSKGJsa2cpOwotCX0KIAogCXEtPnJvb3RfYmxrZyA9IGJsa2c7CiAJcS0+cm9vdF9ybC5ibGtnID0gYmxrZzs=",
"url": "https://github.com/torvalds/linux/commit/9b54d816e00425c3a517514e0d677bb3cec49258.patch"
}
] |
n/a
|
|
GHSA-273c-54fq-2595
| null |
[
{
"commit_message": "[PATCH] update return type for settigns server/controllers/settingsController.js | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSAzNmQ3OGE5YWE0ZWQ2MDdjYTFiZDJiNWZkYWNhNWEzOTI3YjJkMjg3IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbGV4IEhvbGxpZGF5IDxhamhvbGxpZEBnbWFpbC5jb20+CkRhdGU6IEZyaSwgOSBNYXkgMjAyNSAxNDo1MzozNiAtMDcwMApTdWJqZWN0OiBbUEFUQ0hdIHVwZGF0ZSByZXR1cm4gdHlwZSBmb3Igc2V0dGlnbnMKCi0tLQogc2VydmVyL2NvbnRyb2xsZXJzL3NldHRpbmdzQ29udHJvbGxlci5qcyB8IDE3ICsrKysrKysrKysrKysrKy0tCiAxIGZpbGUgY2hhbmdlZCwgMTUgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zZXJ2ZXIvY29udHJvbGxlcnMvc2V0dGluZ3NDb250cm9sbGVyLmpzIGIvc2VydmVyL2NvbnRyb2xsZXJzL3NldHRpbmdzQ29udHJvbGxlci5qcwppbmRleCA0ZDU2MTIxNmUuLmI1NTdlOGRkNiAxMDA3NTUKLS0tIGEvc2VydmVyL2NvbnRyb2xsZXJzL3NldHRpbmdzQ29udHJvbGxlci5qcworKysgYi9zZXJ2ZXIvY29udHJvbGxlcnMvc2V0dGluZ3NDb250cm9sbGVyLmpzCkBAIC0xMywxMiArMTMsMjUgQEAgY2xhc3MgU2V0dGluZ3NDb250cm9sbGVyIHsKIAlnZXRBcHBTZXR0aW5ncyA9IGFzeW5jIChyZXEsIHJlcywgbmV4dCkgPT4gewogCQljb25zdCBkYlNldHRpbmdzID0gYXdhaXQgdGhpcy5zZXR0aW5nc1NlcnZpY2UuZ2V0REJTZXR0aW5ncygpOwogCQljb25zdCBzYW5pdGl6ZWRTZXR0aW5ncyA9IHsgLi4uZGJTZXR0aW5ncyB9OworCisJCWNvbnN0IHJldHVyblNldHRpbmdzID0geworCQkJcGFnZXNwZWVkS2V5U2V0OiBmYWxzZSwKKwkJCWVtYWlsUGFzc3dvcmRTZXQ6IGZhbHNlLAorCQl9OworCiAJCWlmICh0eXBlb2Ygc2FuaXRpemVkU2V0dGluZ3MucGFnZXNwZWVkQXBpS2V5ICE9PSAidW5kZWZpbmVkIikgewotCQkJc2FuaXRpemVkU2V0dGluZ3MucGFnZXNwZWVkQXBpS2V5ID0gIioqKioqKioqIjsKKwkJCXJldHVyblNldHRpbmdzLnBhZ2VzcGVlZEtleVNldCA9IHRydWU7CisJCQlkZWxldGUgc2FuaXRpemVkU2V0dGluZ3MucGFnZXNwZWVkQXBpS2V5OwogCQl9CisJCWlmICh0eXBlb2Ygc2FuaXRpemVkU2V0dGluZ3Muc3lzdGVtRW1haWxQYXNzd29yZCAhPT0gInVuZGVmaW5lZCIpIHsKKwkJCXJldHVyblNldHRpbmdzLmVtYWlsUGFzc3dvcmRTZXQgPSB0cnVlOworCQkJZGVsZXRlIHNhbml0aXplZFNldHRpbmdzLnN5c3RlbUVtYWlsUGFzc3dvcmQ7CisJCX0KKworCQlyZXR1cm5TZXR0aW5ncy5zZXR0aW5ncyA9IHNhbml0aXplZFNldHRpbmdzOwogCQlyZXR1cm4gcmVzLnN1Y2Nlc3MoewogCQkJbXNnOiB0aGlzLnN0cmluZ1NlcnZpY2UuZ2V0QXBwU2V0dGluZ3MsCi0JCQlkYXRhOiBzYW5pdGl6ZWRTZXR0aW5ncywKKwkJCWRhdGE6IHJldHVyblNldHRpbmdzLAogCQl9KTsKIAl9Ow==",
"url": "https://github.com/bluewave-labs/Checkmate/commit/36d78a9aa4ed607ca1bd2b5fdaca5a3927b2d287.patch"
},
{
"commit_message": "[PATCH] return db settings only to client, sanitize keys server/controllers/settingsController.js | 18 ++++++++---------- server/service/settingsService.js | 5 +++++ 2 files changed, 13 insertions(+), 10 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/bluewave-labs/Checkmate/commit/7a855ef47adf2265121c236097059c7c6555fd7c.patch"
},
{
"commit_message": "[PATCH] Remove DB settings from settings service server/controllers/settingsController.js | 1 + server/db/models/AppSettings.js | 45 ++--------------------- server/db/mongo/MongoDB.js | 6 +-- server/db/mongo/modules/settingsModule.js | 3 +- server/index.js | 14 ++++--- server/service/settingsService.js | 39 +++----------------- 6 files changed, 23 insertions(+), 85 deletions(-)",
"patch_text_b64": "From 91c2f7f0d5106bdfd4a0ff2c14b7e44acc3baee6 Mon Sep 17 00:00:00 2001
From: Alex Holliday <ajhollid@gmail.com>
Date: Thu, 8 May 2025 13:11:51 -0700
Subject: [PATCH] Remove DB settings from settings service

---
 server/controllers/settingsController.js  |  1 +
 server/db/models/AppSettings.js           | 45 ++---------------------
 server/db/mongo/MongoDB.js                |  6 +--
 server/db/mongo/modules/settingsModule.js |  3 +-
 server/index.js                           | 14 ++++---
 server/service/settingsService.js         | 39 +++-----------------
 6 files changed, 23 insertions(+), 85 deletions(-)

diff --git a/server/controllers/settingsController.js b/server/controllers/settingsController.js
index 54643dfbb..561ea8266 100755
--- a/server/controllers/settingsController.js
+++ b/server/controllers/settingsController.js
@@ -32,6 +32,7 @@ class SettingsController {
 		}
 
 		try {
+			console.log(req.body);
 			await this.db.updateAppSettings(req.body);
 			const updatedSettings = { ...(await this.settingsService.reloadSettings()) };
 			delete updatedSettings.jwtSecret;
diff --git a/server/db/models/AppSettings.js b/server/db/models/AppSettings.js
index 6415b229d..3942305e8 100755
--- a/server/db/models/AppSettings.js
+++ b/server/db/models/AppSettings.js
@@ -2,44 +2,9 @@ import mongoose from "mongoose";
 
 const AppSettingsSchema = mongoose.Schema(
 	{
-		apiBaseUrl: {
+		language: {
 			type: String,
-			required: true,
-			default: "http://localhost:5000/api/v1",
-		},
-		logLevel: {
-			type: String,
-			default: "debug",
-			enum: ["debug", "none", "error", "warn"],
-		},
-		clientHost: {
-			type: String,
-			required: true,
-			default: "http://localhost:5173",
-		},
-		jwtSecret: {
-			type: String,
-			required: true,
-			default: "my_secret",
-		},
-		dbType: {
-			type: String,
-			required: true,
-			default: "MongoDB",
-		},
-		dbConnectionString: {
-			type: String,
-			required: true,
-			default: "mongodb://localhost:27017/uptime_db",
-		},
-		redisUrl: {
-			type: String,
-			default: "redis://127.0.0.1:6379",
-		},
-		jwtTTL: {
-			type: String,
-			required: true,
-			default: "2h",
+			default: "gb",
 		},
 		pagespeedApiKey: {
 			type: String,
@@ -47,19 +12,15 @@ const AppSettingsSchema = mongoose.Schema(
 		},
 		systemEmailHost: {
 			type: String,
-			default: "smtp.gmail.com",
 		},
 		systemEmailPort: {
 			type: Number,
-			default: 465,
 		},
 		systemEmailAddress: {
 			type: String,
-			default: "",
 		},
 		systemEmailPassword: {
 			type: String,
-			default: "",
 		},
 		singleton: {
 			type: Boolean,
@@ -73,4 +34,4 @@ const AppSettingsSchema = mongoose.Schema(
 	}
 );
 
-export default mongoose.model("AppSettings", AppSettingsSchema);
\ No newline at end of file
+export default mongoose.model("AppSettings", AppSettingsSchema);
diff --git a/server/db/mongo/MongoDB.js b/server/db/mongo/MongoDB.js
index dd9826de5..b657caec4 100755
--- a/server/db/mongo/MongoDB.js
+++ b/server/db/mongo/MongoDB.js
@@ -76,7 +76,8 @@ import * as diagnosticModule from "./modules/diagnosticModule.js";
 class MongoDB {
 	static SERVICE_NAME = "MongoDB";
 
-	constructor() {
+	constructor({ appSettings }) {
+		this.appSettings = appSettings;
 		Object.assign(this, userModule);
 		Object.assign(this, inviteModule);
 		Object.assign(this, recoveryModule);
@@ -95,8 +96,7 @@ class MongoDB {
 	connect = async () => {
 		try {
 			const connectionString =
-				process.env.DB_CONNECTION_STRING || "mongodb://localhost:27017/uptime_db";
-			console.log("Connecting to MongoDB with connection string:", connectionString);
+				this.appSettings.dbConnectionString || "mongodb://localhost:27017/uptime_db";
 			await mongoose.connect(connectionString);
 			// If there are no AppSettings, create one
 			await AppSettings.findOneAndUpdate(
diff --git a/server/db/mongo/modules/settingsModule.js b/server/db/mongo/modules/settingsModule.js
index 3b5f68e19..b817d2a32 100755
--- a/server/db/mongo/modules/settingsModule.js
+++ b/server/db/mongo/modules/settingsModule.js
@@ -14,10 +14,11 @@ const getAppSettings = async () => {
 
 const updateAppSettings = async (newSettings) => {
 	try {
+		console.log(newSettings);
 		const settings = await AppSettings.findOneAndUpdate(
 			{},
 			{ $set: newSettings },
-			{ new: true }
+			{ new: true, upsert: true }
 		);
 		return settings;
 	} catch (error) {
diff --git a/server/index.js b/server/index.js
index 5fa10bcab..f7cab5dbe 100755
--- a/server/index.js
+++ b/server/index.js
@@ -139,19 +139,21 @@ const shutdown = async () => {
 // Need to wrap server setup in a function to handle async nature of JobQueue
 const startApp = async () => {
 	const app = express();
-	const allowedOrigin = process.env.CLIENT_HOST;
 	// Create and Register Primary services
 	const translationService = new TranslationService(logger);
 	const stringService = new StringService(translationService);
 	ServiceRegistry.register(StringService.SERVICE_NAME, stringService);
 
+	// Create services
+	const settingsService = new SettingsService(AppSettings);
+	const appSettings = settingsService.loadSettings();
+
 	// Create DB
-	const db = new MongoDB();
+	const db = new MongoDB({ appSettings });
 	await db.connect();
 
-	// Create services
-	const settingsService = new SettingsService(AppSettings);
-	await settingsService.loadSettings();
+	// Set allowed origin
+	const allowedOrigin = appSettings.clientHost;
 
 	const networkService = new NetworkService(
 		axios,
@@ -237,7 +239,7 @@ const startApp = async () => {
 		ServiceRegistry.get(SettingsService.SERVICE_NAME),
 		ServiceRegistry.get(JobQueue.SERVICE_NAME),
 		ServiceRegistry.get(StringService.SERVICE_NAME),
-		ServiceRegistry.get(EmailService.SERVICE_NAME),
+		ServiceRegistry.get(EmailService.SERVICE_NAME)
 	);
 
 	const settingsController = new SettingsController(
diff --git a/server/service/settingsService.js b/server/service/settingsService.js
index 6c7beb456..7c522de96 100755
--- a/server/service/settingsService.js
+++ b/server/service/settingsService.js
@@ -1,6 +1,4 @@
 const SERVICE_NAME = "SettingsService";
-import dotenv from "dotenv";
-dotenv.config();
 const envConfig = {
 	logLevel: process.env.LOG_LEVEL,
 	clientHost: process.env.CLIENT_HOST,
@@ -20,8 +18,6 @@ const envConfig = {
  * SettingsService
  *
  * This service is responsible for loading and managing the application settings.
- * It gives priority to environment variables and will only load settings
- * from the database if they are not set in the environment.
  */
 class SettingsService {
 	static SERVICE_NAME = SERVICE_NAME;
@@ -34,40 +30,17 @@ class SettingsService {
 		this.settings = { ...envConfig };
 	}
 	/**
-	 * Load settings from the database and merge with environment settings.
-	 * If there are any settings that weren't set by environment variables, use user settings from the database.
-	 * @returns {Promise<Object>} The merged settings.
-	 * @throws Will throw an error if settings are not found in the database or if settings have not been loaded.
-	 */ async loadSettings() {
-		try {
-			const dbSettings = await this.appSettings.findOne();
-			if (!this.settings) {
-				throw new Error("Settings not found");
-			}
-
-			// If there are any settings that weren't set by environment variables, use user settings from DB
-			for (const key in envConfig) {
-				if (
-					typeof envConfig?.[key] === "undefined" &&
-					typeof dbSettings?.[key] !== "undefined"
-				) {
-					this.settings[key] = dbSettings[key];
-				}
-			}
-
-			await this.appSettings.updateOne({}, { $set: this.settings }, { upsert: true });
-			return this.settings;
-		} catch (error) {
-			error.service === undefined ? (error.service = SERVICE_NAME) : null;
-			error.method === undefined ? (error.method = "loadSettings") : null;
-			throw error;
-		}
+	 * Load settings from env settings
+	 * @returns {Object>} The settings.
+	 */
+	loadSettings() {
+		return this.settings;
 	}
 	/**
 	 * Reload settings by calling loadSettings.
 	 * @returns {Promise<Object>} The reloaded settings.
 	 */
-	async reloadSettings() {
+	reloadSettings() {
 		return this.loadSettings();
 	}
 	/**",
"url": "https://github.com/bluewave-labs/Checkmate/commit/91c2f7f0d5106bdfd4a0ff2c14b7e44acc3baee6.patch"
}
] | null |
|
CVE-2019-11487
|
The Linux kernel before 5.1-rc5 allows page->_refcount reference count overflow, with resultant use-after-free issues, if about 140 GiB of RAM exists. This is related to fs/fuse/dev.c, fs/pipe.c, fs/splice.c, include/linux/mm.h, include/linux/pipe_fs_i.h, kernel/trace/trace.c, mm/gup.c, and mm/hugetlb.c. It can occur with FUSE requests.
|
[
{
"commit_message": "[PATCH 1/4] mm: make page ref count overflow check tighter and more explicit We have a VM_BUG_ON() to check that the page reference count doesn't underflow (or get close to overflow) by checking the sign of the count. That's all fine, but we actually want to allow people to use a \"get page ref unless it's already very high\" helper function, and we want that one to use the sign of the page ref (without triggering this VM_BUG_ON). Change the VM_BUG_ON to only check for small underflows (or _very_ close to overflowing), and ignore overflows which have strayed into negative territory. Acked-by: Matthew Wilcox <willy@infradead.org> Cc: Jann Horn <jannh@google.com> Cc: stable@kernel.org Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> include/linux/mm.h | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)",
"patch_text_b64": "From f958d7b528b1b40c44cfda5eabe2d82760d868c3 Mon Sep 17 00:00:00 2001
From: Linus Torvalds <torvalds@linux-foundation.org>
Date: Thu, 11 Apr 2019 10:06:20 -0700
Subject: [PATCH 1/4] mm: make page ref count overflow check tighter and more
 explicit

We have a VM_BUG_ON() to check that the page reference count doesn't
underflow (or get close to overflow) by checking the sign of the count.

That's all fine, but we actually want to allow people to use a "get page
ref unless it's already very high" helper function, and we want that one
to use the sign of the page ref (without triggering this VM_BUG_ON).

Change the VM_BUG_ON to only check for small underflows (or _very_ close
to overflowing), and ignore overflows which have strayed into negative
territory.

Acked-by: Matthew Wilcox <willy@infradead.org>
Cc: Jann Horn <jannh@google.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
---
 include/linux/mm.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 80bb6408fe73a8..541d99b86aea9e 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -965,6 +965,10 @@ static inline bool is_pci_p2pdma_page(const struct page *page)
 }
 #endif /* CONFIG_DEV_PAGEMAP_OPS */
 
+/* 127: arbitrary random number, small enough to assemble well */
+#define page_ref_zero_or_close_to_overflow(page) \
+	((unsigned int) page_ref_count(page) + 127u <= 127u)
+
 static inline void get_page(struct page *page)
 {
 	page = compound_head(page);
@@ -972,7 +976,7 @@ static inline void get_page(struct page *page)
 	 * Getting a normal page or the head of a compound page
 	 * requires to already have an elevated page->_refcount.
 	 */
-	VM_BUG_ON_PAGE(page_ref_count(page) <= 0, page);
+	VM_BUG_ON_PAGE(page_ref_zero_or_close_to_overflow(page), page);
 	page_ref_inc(page);
 }
 

From 88b1a17dfc3ed7728316478fae0f5ad508f50397 Mon Sep 17 00:00:00 2001
From: Linus Torvalds <torvalds@linux-foundation.org>
Date: Thu, 11 Apr 2019 10:14:59 -0700
Subject: [PATCH 2/4] mm: add 'try_get_page()' helper function

This is the same as the traditional 'get_page()' function, but instead
of unconditionally incrementing the reference count of the page, it only
does so if the count was "safe".  It returns whether the reference count
was incremented (and is marked __must_check, since the caller obviously
has to be aware of it).

Also like 'get_page()', you can't use this function unless you already
had a reference to the page.  The intent is that you can use this
exactly like get_page(), but in situations where you want to limit the
maximum reference count.

The code currently does an unconditional WARN_ON_ONCE() if we ever hit
the reference count issues (either zero or negative), as a notification
that the conditional non-increment actually happened.

NOTE! The count access for the "safety" check is inherently racy, but
that doesn't matter since the buffer we use is basically half the range
of the reference count (ie we look at the sign of the count).

Acked-by: Matthew Wilcox <willy@infradead.org>
Cc: Jann Horn <jannh@google.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
---
 include/linux/mm.h | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 541d99b86aea9e..7000ddd807e012 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -980,6 +980,15 @@ static inline void get_page(struct page *page)
 	page_ref_inc(page);
 }
 
+static inline __must_check bool try_get_page(struct page *page)
+{
+	page = compound_head(page);
+	if (WARN_ON_ONCE(page_ref_count(page) <= 0))
+		return false;
+	page_ref_inc(page);
+	return true;
+}
+
 static inline void put_page(struct page *page)
 {
 	page = compound_head(page);

From 8fde12ca79aff9b5ba951fce1a2641901b8d8e64 Mon Sep 17 00:00:00 2001
From: Linus Torvalds <torvalds@linux-foundation.org>
Date: Thu, 11 Apr 2019 10:49:19 -0700
Subject: [PATCH 3/4] mm: prevent get_user_pages() from overflowing page
 refcount

If the page refcount wraps around past zero, it will be freed while
there are still four billion references to it.  One of the possible
avenues for an attacker to try to make this happen is by doing direct IO
on a page multiple times.  This patch makes get_user_pages() refuse to
take a new page reference if there are already more than two billion
references to the page.

Reported-by: Jann Horn <jannh@google.com>
Acked-by: Matthew Wilcox <willy@infradead.org>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
---
 mm/gup.c     | 48 ++++++++++++++++++++++++++++++++++++------------
 mm/hugetlb.c | 13 +++++++++++++
 2 files changed, 49 insertions(+), 12 deletions(-)

diff --git a/mm/gup.c b/mm/gup.c
index 75029649baca4a..81e0bdefa2ccb9 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -157,8 +157,12 @@ static struct page *follow_page_pte(struct vm_area_struct *vma,
 		goto retry;
 	}
 
-	if (flags & FOLL_GET)
-		get_page(page);
+	if (flags & FOLL_GET) {
+		if (unlikely(!try_get_page(page))) {
+			page = ERR_PTR(-ENOMEM);
+			goto out;
+		}
+	}
 	if (flags & FOLL_TOUCH) {
 		if ((flags & FOLL_WRITE) &&
 		    !pte_dirty(pte) && !PageDirty(page))
@@ -295,7 +299,10 @@ static struct page *follow_pmd_mask(struct vm_area_struct *vma,
 			if (pmd_trans_unstable(pmd))
 				ret = -EBUSY;
 		} else {
-			get_page(page);
+			if (unlikely(!try_get_page(page))) {
+				spin_unlock(ptl);
+				return ERR_PTR(-ENOMEM);
+			}
 			spin_unlock(ptl);
 			lock_page(page);
 			ret = split_huge_page(page);
@@ -497,7 +504,10 @@ static int get_gate_page(struct mm_struct *mm, unsigned long address,
 		if (is_device_public_page(*page))
 			goto unmap;
 	}
-	get_page(*page);
+	if (unlikely(!try_get_page(*page))) {
+		ret = -ENOMEM;
+		goto unmap;
+	}
 out:
 	ret = 0;
 unmap:
@@ -1393,6 +1403,20 @@ static void undo_dev_pagemap(int *nr, int nr_start, struct page **pages)
 	}
 }
 
+/*
+ * Return the compund head page with ref appropriately incremented,
+ * or NULL if that failed.
+ */
+static inline struct page *try_get_compound_head(struct page *page, int refs)
+{
+	struct page *head = compound_head(page);
+	if (WARN_ON_ONCE(page_ref_count(head) < 0))
+		return NULL;
+	if (unlikely(!page_cache_add_speculative(head, refs)))
+		return NULL;
+	return head;
+}
+
 #ifdef CONFIG_ARCH_HAS_PTE_SPECIAL
 static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
 			 int write, struct page **pages, int *nr)
@@ -1427,9 +1451,9 @@ static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
 
 		VM_BUG_ON(!pfn_valid(pte_pfn(pte)));
 		page = pte_page(pte);
-		head = compound_head(page);
 
-		if (!page_cache_get_speculative(head))
+		head = try_get_compound_head(page, 1);
+		if (!head)
 			goto pte_unmap;
 
 		if (unlikely(pte_val(pte) != pte_val(*ptep))) {
@@ -1568,8 +1592,8 @@ static int gup_huge_pmd(pmd_t orig, pmd_t *pmdp, unsigned long addr,
 		refs++;
 	} while (addr += PAGE_SIZE, addr != end);
 
-	head = compound_head(pmd_page(orig));
-	if (!page_cache_add_speculative(head, refs)) {
+	head = try_get_compound_head(pmd_page(orig), refs);
+	if (!head) {
 		*nr -= refs;
 		return 0;
 	}
@@ -1606,8 +1630,8 @@ static int gup_huge_pud(pud_t orig, pud_t *pudp, unsigned long addr,
 		refs++;
 	} while (addr += PAGE_SIZE, addr != end);
 
-	head = compound_head(pud_page(orig));
-	if (!page_cache_add_speculative(head, refs)) {
+	head = try_get_compound_head(pud_page(orig), refs);
+	if (!head) {
 		*nr -= refs;
 		return 0;
 	}
@@ -1643,8 +1667,8 @@ static int gup_huge_pgd(pgd_t orig, pgd_t *pgdp, unsigned long addr,
 		refs++;
 	} while (addr += PAGE_SIZE, addr != end);
 
-	head = compound_head(pgd_page(orig));
-	if (!page_cache_add_speculative(head, refs)) {
+	head = try_get_compound_head(pgd_page(orig), refs);
+	if (!head) {
 		*nr -= refs;
 		return 0;
 	}
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 8dfdffc34a99bc..c220315dc5331f 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -4298,6 +4298,19 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma,
 
 		pfn_offset = (vaddr & ~huge_page_mask(h)) >> PAGE_SHIFT;
 		page = pte_page(huge_ptep_get(pte));
+
+		/*
+		 * Instead of doing 'try_get_page()' below in the same_page
+		 * loop, just check the count once here.
+		 */
+		if (unlikely(page_count(page) <= 0)) {
+			if (pages) {
+				spin_unlock(ptl);
+				remainder = 0;
+				err = -ENOMEM;
+				break;
+			}
+		}
 same_page:
 		if (pages) {
 			pages[i] = mem_map_offset(page, pfn_offset);

From 15fab63e1e57be9fdb5eec1bbc5916e9825e9acb Mon Sep 17 00:00:00 2001
From: Matthew Wilcox <willy@infradead.org>
Date: Fri, 5 Apr 2019 14:02:10 -0700
Subject: [PATCH 4/4] fs: prevent page refcount overflow in pipe_buf_get

Change pipe_buf_get() to return a bool indicating whether it succeeded
in raising the refcount of the page (if the thing in the pipe is a page).
This removes another mechanism for overflowing the page refcount.  All
callers converted to handle a failure.

Reported-by: Jann Horn <jannh@google.com>
Signed-off-by: Matthew Wilcox <willy@infradead.org>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
---
 fs/fuse/dev.c             | 12 ++++++------
 fs/pipe.c                 |  4 ++--
 fs/splice.c               | 12 ++++++++++--
 include/linux/pipe_fs_i.h | 10 ++++++----
 kernel/trace/trace.c      |  6 +++++-
 5 files changed, 29 insertions(+), 15 deletions(-)

diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index 809c0f2f9942e3..64f4de9834687a 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -2034,10 +2034,8 @@ static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe,
 		rem += pipe->bufs[(pipe->curbuf + idx) & (pipe->buffers - 1)].len;
 
 	ret = -EINVAL;
-	if (rem < len) {
-		pipe_unlock(pipe);
-		goto out;
-	}
+	if (rem < len)
+		goto out_free;
 
 	rem = len;
 	while (rem) {
@@ -2055,7 +2053,9 @@ static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe,
 			pipe->curbuf = (pipe->curbuf + 1) & (pipe->buffers - 1);
 			pipe->nrbufs--;
 		} else {
-			pipe_buf_get(pipe, ibuf);
+			if (!pipe_buf_get(pipe, ibuf))
+				goto out_free;
+
 			*obuf = *ibuf;
 			obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
 			obuf->len = rem;
@@ -2078,11 +2078,11 @@ static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe,
 	ret = fuse_dev_do_write(fud, &cs, len);
 
 	pipe_lock(pipe);
+out_free:
 	for (idx = 0; idx < nbuf; idx++)
 		pipe_buf_release(pipe, &bufs[idx]);
 	pipe_unlock(pipe);
 
-out:
 	kvfree(bufs);
 	return ret;
 }
diff --git a/fs/pipe.c b/fs/pipe.c
index bdc5d3c0977d09..b1543b85c14a44 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -189,9 +189,9 @@ EXPORT_SYMBOL(generic_pipe_buf_steal);
  *	in the tee() system call, when we duplicate the buffers in one
  *	pipe into another.
  */
-void generic_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *buf)
+bool generic_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *buf)
 {
-	get_page(buf->page);
+	return try_get_page(buf->page);
 }
 EXPORT_SYMBOL(generic_pipe_buf_get);
 
diff --git a/fs/splice.c b/fs/splice.c
index de2ede048473ce..f30af82b850dd3 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -1588,7 +1588,11 @@ static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe,
 			 * Get a reference to this pipe buffer,
 			 * so we can copy the contents over.
 			 */
-			pipe_buf_get(ipipe, ibuf);
+			if (!pipe_buf_get(ipipe, ibuf)) {
+				if (ret == 0)
+					ret = -EFAULT;
+				break;
+			}
 			*obuf = *ibuf;
 
 			/*
@@ -1660,7 +1664,11 @@ static int link_pipe(struct pipe_inode_info *ipipe,
 		 * Get a reference to this pipe buffer,
 		 * so we can copy the contents over.
 		 */
-		pipe_buf_get(ipipe, ibuf);
+		if (!pipe_buf_get(ipipe, ibuf)) {
+			if (ret == 0)
+				ret = -EFAULT;
+			break;
+		}
 
 		obuf = opipe->bufs + nbuf;
 		*obuf = *ibuf;
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index 5a3bb3b7c9ad3f..3f2a42c11e206e 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -108,18 +108,20 @@ struct pipe_buf_operations {
 	/*
 	 * Get a reference to the pipe buffer.
 	 */
-	void (*get)(struct pipe_inode_info *, struct pipe_buffer *);
+	bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
 };
 
 /**
  * pipe_buf_get - get a reference to a pipe_buffer
  * @pipe:	the pipe that the buffer belongs to
  * @buf:	the buffer to get a reference to
+ *
+ * Return: %true if the reference was successfully obtained.
  */
-static inline void pipe_buf_get(struct pipe_inode_info *pipe,
+static inline __must_check bool pipe_buf_get(struct pipe_inode_info *pipe,
 				struct pipe_buffer *buf)
 {
-	buf->ops->get(pipe, buf);
+	return buf->ops->get(pipe, buf);
 }
 
 /**
@@ -178,7 +180,7 @@ struct pipe_inode_info *alloc_pipe_info(void);
 void free_pipe_info(struct pipe_inode_info *);
 
 /* Generic pipe buffer ops functions */
-void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
+bool generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
 void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index c4238b44162441..0f300d488c9ff7 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -6835,12 +6835,16 @@ static void buffer_pipe_buf_release(struct pipe_inode_info *pipe,
 	buf->private = 0;
 }
 
-static void buffer_pipe_buf_get(struct pipe_inode_info *pipe,
+static bool buffer_pipe_buf_get(struct pipe_inode_info *pipe,
 				struct pipe_buffer *buf)
 {
 	struct buffer_ref *ref = (struct buffer_ref *)buf->private;
 
+	if (ref->ref > INT_MAX/2)
+		return false;
+
 	ref->ref++;
+	return true;
 }
 
 /* Pipe buffer operations for a buffer. */",
"url": "https://github.com/torvalds/linux/commit/6b3a707736301c2128ca85ce85fb13f60b5e350a.patch"
},
{
"commit_message": "[PATCH] fs: prevent page refcount overflow in pipe_buf_get Change pipe_buf_get() to return a bool indicating whether it succeeded in raising the refcount of the page (if the thing in the pipe is a page). This removes another mechanism for overflowing the page refcount. All callers converted to handle a failure. Reported-by: Jann Horn <jannh@google.com> Signed-off-by: Matthew Wilcox <willy@infradead.org> Cc: stable@kernel.org Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> fs/fuse/dev.c | 12 ++++++------ fs/pipe.c | 4 ++-- fs/splice.c | 12 ++++++++++-- include/linux/pipe_fs_i.h | 10 ++++++---- kernel/trace/trace.c | 6 +++++- 5 files changed, 29 insertions(+), 15 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/torvalds/linux/commit/15fab63e1e57be9fdb5eec1bbc5916e9825e9acb.patch"
},
{
"commit_message": "[PATCH] mm: prevent get_user_pages() from overflowing page refcount If the page refcount wraps around past zero, it will be freed while there are still four billion references to it. One of the possible avenues for an attacker to try to make this happen is by doing direct IO on a page multiple times. This patch makes get_user_pages() refuse to take a new page reference if there are already more than two billion references to the page. Reported-by: Jann Horn <jannh@google.com> Acked-by: Matthew Wilcox <willy@infradead.org> Cc: stable@kernel.org Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> mm/gup.c | 48 ++++++++++++++++++++++++++++++++++++------------ mm/hugetlb.c | 13 +++++++++++++ 2 files changed, 49 insertions(+), 12 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/torvalds/linux/commit/8fde12ca79aff9b5ba951fce1a2641901b8d8e64.patch"
},
{
"commit_message": "[PATCH] mm: add 'try_get_page()' helper function This is the same as the traditional 'get_page()' function, but instead of unconditionally incrementing the reference count of the page, it only does so if the count was \"safe\". It returns whether the reference count was incremented (and is marked __must_check, since the caller obviously has to be aware of it). Also like 'get_page()', you can't use this function unless you already had a reference to the page. The intent is that you can use this exactly like get_page(), but in situations where you want to limit the maximum reference count. The code currently does an unconditional WARN_ON_ONCE() if we ever hit the reference count issues (either zero or negative), as a notification that the conditional non-increment actually happened. NOTE! The count access for the \"safety\" check is inherently racy, but that doesn't matter since the buffer we use is basically half the range of the reference count (ie we look at the sign of the count). Acked-by: Matthew Wilcox <willy@infradead.org> Cc: Jann Horn <jannh@google.com> Cc: stable@kernel.org Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> include/linux/mm.h | 9 +++++++++ 1 file changed, 9 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/torvalds/linux/commit/88b1a17dfc3ed7728316478fae0f5ad508f50397.patch"
},
{
"commit_message": "[PATCH] mm: make page ref count overflow check tighter and more explicit We have a VM_BUG_ON() to check that the page reference count doesn't underflow (or get close to overflow) by checking the sign of the count. That's all fine, but we actually want to allow people to use a \"get page ref unless it's already very high\" helper function, and we want that one to use the sign of the page ref (without triggering this VM_BUG_ON). Change the VM_BUG_ON to only check for small underflows (or _very_ close to overflowing), and ignore overflows which have strayed into negative territory. Acked-by: Matthew Wilcox <willy@infradead.org> Cc: Jann Horn <jannh@google.com> Cc: stable@kernel.org Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> include/linux/mm.h | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/torvalds/linux/commit/f958d7b528b1b40c44cfda5eabe2d82760d868c3.patch"
}
] |
n/a
|
|
CVE-2025-46570
|
vLLM’s Chunk-Based Prefix Caching Vulnerable to Potential Timing Side-Channel
|
vLLM is an inference and serving engine for large language models (LLMs). Prior to version 0.9.0, when a new prompt is processed, if the PageAttention mechanism finds a matching prefix chunk, the prefill process speeds up, which is reflected in the TTFT (Time to First Token). These timing differences caused by matching chunks are significant enough to be recognized and exploited. This issue has been patched in version 0.9.0.
|
[
{
"commit_message": "[PATCH] [Core] Prevent side-channel attacks via cache salting (#17045) Signed-off-by: Marko Rosenmueller <5467316+dr75@users.noreply.github.com> docs/source/design/v1/prefix_caching.md | 20 +- tests/entrypoints/openai/test_serving_chat.py | 40 ++++ tests/tokenization/test_detokenize.py | 12 +- tests/v1/core/test_kv_cache_utils.py | 43 ++++- tests/v1/core/test_prefix_caching.py | 64 ++++++- tests/v1/engine/test_engine_core.py | 1 + tests/v1/engine/test_engine_core_client.py | 1 + tests/v1/engine/test_output_processor.py | 7 +- vllm/entrypoints/openai/protocol.py | 32 +++- vllm/entrypoints/openai/serving_engine.py | 3 + vllm/inputs/data.py | 20 +- vllm/inputs/preprocess.py | 178 +++++++----------- vllm/multimodal/inputs.py | 5 + vllm/multimodal/processing.py | 2 +- vllm/v1/core/kv_cache_utils.py | 13 +- vllm/v1/engine/__init__.py | 1 + vllm/v1/engine/processor.py | 1 + vllm/v1/request.py | 3 + 18 files changed, 324 insertions(+), 122 deletions(-)",
"patch_text_b64": "From 77073c77bc2006eb80ea6d5128f076f5e6c6f54f Mon Sep 17 00:00:00 2001
From: Marko Rosenmueller <5467316+dr75@users.noreply.github.com>
Date: Wed, 30 Apr 2025 14:27:21 +0200
Subject: [PATCH] [Core] Prevent side-channel attacks via cache salting
 (#17045)

Signed-off-by: Marko Rosenmueller <5467316+dr75@users.noreply.github.com>
---
 docs/source/design/v1/prefix_caching.md       |  20 +-
 tests/entrypoints/openai/test_serving_chat.py |  40 ++++
 tests/tokenization/test_detokenize.py         |  12 +-
 tests/v1/core/test_kv_cache_utils.py          |  43 ++++-
 tests/v1/core/test_prefix_caching.py          |  64 ++++++-
 tests/v1/engine/test_engine_core.py           |   1 +
 tests/v1/engine/test_engine_core_client.py    |   1 +
 tests/v1/engine/test_output_processor.py      |   7 +-
 vllm/entrypoints/openai/protocol.py           |  32 +++-
 vllm/entrypoints/openai/serving_engine.py     |   3 +
 vllm/inputs/data.py                           |  20 +-
 vllm/inputs/preprocess.py                     | 178 +++++++-----------
 vllm/multimodal/inputs.py                     |   5 +
 vllm/multimodal/processing.py                 |   2 +-
 vllm/v1/core/kv_cache_utils.py                |  13 +-
 vllm/v1/engine/__init__.py                    |   1 +
 vllm/v1/engine/processor.py                   |   1 +
 vllm/v1/request.py                            |   3 +
 18 files changed, 324 insertions(+), 122 deletions(-)

diff --git a/docs/source/design/v1/prefix_caching.md b/docs/source/design/v1/prefix_caching.md
index ec1f3cb8d64a..ec661d8ec641 100644
--- a/docs/source/design/v1/prefix_caching.md
+++ b/docs/source/design/v1/prefix_caching.md
@@ -16,7 +16,7 @@ In the example above, the KV cache in the first block can be uniquely identified
 
 * Parent hash value: The hash value of the parent hash block.
 * Block tokens: A tuple of tokens in this block. The reason to include the exact tokens is to reduce potential hash value collision.
-* Extra hashes: Other values required to make this block unique, such as LoRA IDs and multi-modality input hashes (see the example below).
+* Extra hashes: Other values required to make this block unique, such as LoRA IDs, multi-modality input hashes (see the example below), and cache salts to isolate caches in multi-tenant environments.
 
 > **Note 1:** We only cache full blocks.
 
@@ -76,6 +76,24 @@ Block 3
 
 In the rest of this document, we first introduce the data structure used for prefix caching in vLLM v1, followed by the prefix caching workflow of major KV cache operators (e.g., allocate, append, free, eviction). Finally, we use an example to illustrate the end to end prefix caching workflow.
 
+**Cache Isolation for Security**
+To improve privacy in shared environments, vLLM supports isolating prefix cache reuse through optional per-request salting. By including a `cache_salt` in the request, this value is injected into the hash of the first block, ensuring that only requests with the same salt can reuse cached KV blocks. This prevents timing-based attacks where an adversary could infer cached content by observing latency differences. This offers protection without compromising performance.
+
+```json
+{
+  "messages": [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": "Here is a document with details about the world series: ..."},
+    {"role": "user", "content": "Who won the world series in 2020?"}
+  ],
+  "cache_salt": "Z3V2bmV3aGxza3ZubGFoZ3Zud3V3ZWZ2bmd0b3V2bnZmc2xpZ3RoZ2x2aQ=="
+}
+```
+
+With this setup, cache sharing is limited to users or requests that explicitly agree on a common salt, enabling cache reuse within a trust group while isolating others.
+
+> **Note:** Cache isolation is not supported in engine V0.
+
 ## Data Structure
 
 The prefix caching in vLLM v1 is implemented in the KV cache manager. The basic building block is the “Block” data class (simplified):
diff --git a/tests/entrypoints/openai/test_serving_chat.py b/tests/entrypoints/openai/test_serving_chat.py
index 19d16713b209..5e11af8cf892 100644
--- a/tests/entrypoints/openai/test_serving_chat.py
+++ b/tests/entrypoints/openai/test_serving_chat.py
@@ -272,3 +272,43 @@ def test_serving_chat_could_load_correct_generation_config():
 
     assert mock_engine.generate.call_args.args[1].temperature == 0.0
     assert mock_engine.generate.call_args.args[1].repetition_penalty == 1.05
+
+
+def test_serving_chat_did_set_correct_cache_salt():
+    mock_model_config = MockModelConfig()
+
+    mock_engine = MagicMock(spec=MQLLMEngineClient)
+    mock_engine.get_tokenizer.return_value = get_tokenizer(MODEL_NAME)
+    mock_engine.errored = False
+
+    # Initialize the serving chat
+    models = OpenAIServingModels(engine_client=mock_engine,
+                                 base_model_paths=BASE_MODEL_PATHS,
+                                 model_config=mock_model_config)
+    serving_chat = OpenAIServingChat(mock_engine,
+                                     mock_model_config,
+                                     models,
+                                     response_role="assistant",
+                                     chat_template=CHAT_TEMPLATE,
+                                     chat_template_content_format="auto",
+                                     request_logger=None)
+
+    # Test cache_salt
+    req = ChatCompletionRequest(
+        model=MODEL_NAME,
+        messages=[{
+            "role": "user",
+            "content": "what is 1+1?"
+        }],
+    )
+
+    # By default cache_salt in the engine prompt is not set
+    with suppress(Exception):
+        asyncio.run(serving_chat.create_chat_completion(req))
+    assert "cache_salt" not in mock_engine.generate.call_args.args[0]
+
+    # Test with certain cache_salt
+    req.cache_salt = "test_salt"
+    with suppress(Exception):
+        asyncio.run(serving_chat.create_chat_completion(req))
+    assert mock_engine.generate.call_args.args[0]["cache_salt"] == "test_salt"
diff --git a/tests/tokenization/test_detokenize.py b/tests/tokenization/test_detokenize.py
index f8e213b9ca48..079100e78b5f 100644
--- a/tests/tokenization/test_detokenize.py
+++ b/tests/tokenization/test_detokenize.py
@@ -60,8 +60,16 @@ def _run_incremental_decode(tokenizer,
         skip_special_tokens=skip_special_tokens,
         spaces_between_special_tokens=spaces_between_special_tokens,
     )
-    request = EngineCoreRequest("", prompt_token_ids, None, None, None, params,
-                                None, 0.0, None)
+    request = EngineCoreRequest("",
+                                prompt_token_ids,
+                                None,
+                                None,
+                                None,
+                                params,
+                                None,
+                                0.0,
+                                None,
+                                cache_salt=None)
 
     if fast is None:
         detokenizer = IncrementalDetokenizer.from_new_request(
diff --git a/tests/v1/core/test_kv_cache_utils.py b/tests/v1/core/test_kv_cache_utils.py
index e73e08e74b0d..e8069b8c6d7f 100644
--- a/tests/v1/core/test_kv_cache_utils.py
+++ b/tests/v1/core/test_kv_cache_utils.py
@@ -29,7 +29,8 @@
 def make_request(request_id,
                  prompt_token_ids,
                  mm_positions=None,
-                 mm_hashes=None):
+                 mm_hashes=None,
+                 cache_salt=None):
     if mm_positions is None:
         multi_modal_inputs = None
     else:
@@ -45,6 +46,7 @@ def make_request(request_id,
         eos_token_id=100,
         arrival_time=0,
         lora_request=None,
+        cache_salt=cache_salt,
     )
 
 
@@ -213,6 +215,45 @@ def test_generate_block_hash_extra_keys_no_mm_inputs():
     assert next_mm_idx == 0
 
 
+def test_generate_block_hash_extra_keys_cache_salt():
+    request = make_request(
+        request_id=0,
+        prompt_token_ids=[_ for _ in range(6)],
+        mm_positions=None,
+        mm_hashes=None,
+        cache_salt="salt",
+    )
+
+    # salt is added for the first token
+    extra_keys, _ = generate_block_hash_extra_keys(request, 0, 1, 0)
+    assert extra_keys == ('salt', )
+    extra_keys, _ = generate_block_hash_extra_keys(request, 0, 10, 0)
+    assert extra_keys == ('salt', )
+
+    # no salt added for other tokens
+    extra_keys, _ = generate_block_hash_extra_keys(request, 1, 2, 0)
+    assert extra_keys is None
+    extra_keys, _ = generate_block_hash_extra_keys(request, 6, 10, 0)
+    assert extra_keys is None
+
+    # works together with other extra keys
+    request_mm = make_request(
+        request_id=0,
+        prompt_token_ids=[_ for _ in range(20)],
+        mm_positions=[
+            PlaceholderRange(offset=0, length=5),
+        ],
+        mm_hashes=["hash1"],
+        cache_salt="salt",
+    )
+
+    # Test with no extra keys
+    extra_keys, next_mm_idx = generate_block_hash_extra_keys(
+        request_mm, 0, 5, 0)
+    assert extra_keys == ("hash1", "salt")
+    assert next_mm_idx == 1
+
+
 @pytest.mark.parametrize("hash_fn", [sha256, hash])
 def test_hash_block_tokens(hash_fn):
     parent_block_hash = 123
diff --git a/tests/v1/core/test_prefix_caching.py b/tests/v1/core/test_prefix_caching.py
index b2e8ff61450c..ae4bd95d22aa 100644
--- a/tests/v1/core/test_prefix_caching.py
+++ b/tests/v1/core/test_prefix_caching.py
@@ -21,7 +21,8 @@ def make_request(request_id,
                  prompt_token_ids,
                  mm_positions=None,
                  mm_hashes=None,
-                 prompt_logprobs: Optional[int] = None):
+                 prompt_logprobs: Optional[int] = None,
+                 cache_salt: Optional[str] = None):
     if mm_positions is None:
         multi_modal_inputs = None
     else:
@@ -38,6 +39,7 @@ def make_request(request_id,
         eos_token_id=100,
         arrival_time=0,
         lora_request=None,
+        cache_salt=cache_salt,
     )
 
 
@@ -603,6 +605,66 @@ def test_mm_prefix_caching():
     assert num_computed_tokens == 3 * 16
 
 
+def test_cache_key_salting():
+    """
+    This tests that cache salts are applied during hashing and the cache
+    is separated cache as expected.
+    """
+    block_size = 16
+    manager = KVCacheManager(
+        make_kv_cache_config(block_size, 11),
+        max_model_len=8192,
+        enable_caching=True,
+    )
+
+    # 3 complete blocks and an incomplete block with 11 tokens.
+    common_token_ids = [i for i in range(3) for _ in range(block_size)]
+    token_ids = common_token_ids + [3] * 11
+    req0 = make_request("0", token_ids, cache_salt="salt1")
+    computed_blocks, num_computed_tokens = manager.get_computed_blocks(req0)
+
+    # Completed block should have hashes with extra keys.
+    assert not computed_blocks
+    assert num_computed_tokens == 0
+    block_hashes = manager.req_to_block_hashes[req0.request_id]
+    assert len(block_hashes) == 3
+    assert block_hashes[0].extra_keys == ("salt1", )
+    assert block_hashes[1].extra_keys is None
+    assert block_hashes[2].extra_keys is None
+
+    blocks = manager.allocate_slots(req0, 59, computed_blocks)
+    assert [b.block_id for b in blocks] == [1, 2, 3, 4]
+    req0.num_computed_tokens = 59
+
+    # Append slots without allocating a new block.
+    for _ in range(5):
+        req0.append_output_token_ids(8)
+    new_blocks = manager.allocate_slots(req0, 5)
+    assert new_blocks is not None and len(new_blocks) == 0
+
+    # Now one more block that should not have extra keys.
+    assert len(block_hashes) == 4
+    assert block_hashes[3].extra_keys is None
+
+    # Test cache hit with a new request that has the same salt.
+    token_ids = common_token_ids + [4] * 11
+    req1 = make_request("1", token_ids, cache_salt="salt1")
+    computed_blocks, num_computed_tokens = manager.get_computed_blocks(req1)
+    # Should match only a prefix of 3 blocks.
+    assert len(computed_blocks) == 3
+    assert num_computed_tokens == 3 * block_size
+
+    # Test cache miss with same content but different salt.
+    token_ids = common_token_ids + [4] * 11
+    req2 = make_request("2", token_ids, cache_salt="salt2")
+    computed_blocks, num_computed_tokens = manager.get_computed_blocks(req2)
+    assert len(computed_blocks) == 0
+    assert num_computed_tokens == 0
+    block_hashes = manager.req_to_block_hashes[req2.request_id]
+    assert len(block_hashes) == 3
+    assert block_hashes[0].extra_keys == ("salt2", )
+
+
 def test_prefill_not_enough_free_blocks_with_computed_blocks():
     """
     This is a unit test that tests the correctness of the allocate_slots
diff --git a/tests/v1/engine/test_engine_core.py b/tests/v1/engine/test_engine_core.py
index 30fa9e371ad1..dcf494825b0d 100644
--- a/tests/v1/engine/test_engine_core.py
+++ b/tests/v1/engine/test_engine_core.py
@@ -40,6 +40,7 @@ def make_request() -> EngineCoreRequest:
         eos_token_id=None,
         arrival_time=time.time(),
         lora_request=None,
+        cache_salt=None,
     )
 
 
diff --git a/tests/v1/engine/test_engine_core_client.py b/tests/v1/engine/test_engine_core_client.py
index 8cc36fa163f7..5514a328497f 100644
--- a/tests/v1/engine/test_engine_core_client.py
+++ b/tests/v1/engine/test_engine_core_client.py
@@ -43,6 +43,7 @@ def make_request(params: SamplingParams) -> EngineCoreRequest:
         eos_token_id=None,
         arrival_time=time.time(),
         lora_request=None,
+        cache_salt=None,
     )
 
 
diff --git a/tests/v1/engine/test_output_processor.py b/tests/v1/engine/test_output_processor.py
index d2bb7d88fef2..fac701c4ca35 100644
--- a/tests/v1/engine/test_output_processor.py
+++ b/tests/v1/engine/test_output_processor.py
@@ -57,6 +57,7 @@ def test_incremental_detokenization(request_output_kind: RequestOutputKind,
                           mm_placeholders=None,
                           eos_token_id=None,
                           lora_request=None,
+                          cache_salt=None,
                           sampling_params=SamplingParams(
                               skip_special_tokens=False,
                               spaces_between_special_tokens=False,
@@ -403,6 +404,7 @@ def test_logprobs_processor(request_output_kind: RequestOutputKind,
                           mm_placeholders=None,
                           eos_token_id=None,
                           lora_request=None,
+                          cache_salt=None,
                           sampling_params=SamplingParams(
                               skip_special_tokens=False,
                               spaces_between_special_tokens=False,
@@ -503,7 +505,7 @@ def test_stop_token(include_stop_str_in_output: bool,
       reason should be "stop" (i.e. first control token causes stop
       and is represented in output text)
 
-    * else, the detokenized string should be 
+    * else, the detokenized string should be
       <token><token>...<token> and the finish reason should be "stop"
       (i.e. first control token causes stop but is not represented
       in output text.)
@@ -565,6 +567,7 @@ def test_stop_token(include_stop_str_in_output: bool,
         mm_placeholders=None,
         eos_token_id=eos_token_id,
         lora_request=None,
+        cache_salt=None,
         sampling_params=SamplingParams(
             skip_special_tokens=False,
             spaces_between_special_tokens=False,
@@ -661,6 +664,7 @@ def test_stop_string(include_stop_str_in_output: bool,
             mm_placeholders=None,
             eos_token_id=None,
             lora_request=None,
+            cache_salt=None,
             sampling_params=SamplingParams(
                 skip_special_tokens=False,
                 spaces_between_special_tokens=False,
@@ -774,6 +778,7 @@ def test_iteration_stats(dummy_test_vectors):
             mm_placeholders=None,
             eos_token_id=None,
             lora_request=None,
+            cache_salt=None,
             sampling_params=SamplingParams(),
         ) for idx, prompt_tokens in enumerate(dummy_test_vectors.prompt_tokens)
     ]
diff --git a/vllm/entrypoints/openai/protocol.py b/vllm/entrypoints/openai/protocol.py
index d444442a9762..389557dfb7c3 100644
--- a/vllm/entrypoints/openai/protocol.py
+++ b/vllm/entrypoints/openai/protocol.py
@@ -14,6 +14,7 @@
                       ValidationInfo, field_validator, model_validator)
 from typing_extensions import TypeAlias
 
+from vllm import envs
 from vllm.entrypoints.chat_utils import ChatCompletionMessageParam
 from vllm.logger import init_logger
 from vllm.pooling_params import PoolingParams
@@ -408,6 +409,15 @@ class ChatCompletionRequest(OpenAIBaseModel):
             "If specified with 'logprobs', tokens are represented "
             " as strings of the form 'token_id:{token_id}' so that tokens "
             "that are not JSON-encodable can be identified."))
+    cache_salt: Optional[str] = Field(
+        default=None,
+        description=(
+            "If specified, the prefix cache will be salted with the provided "
+            "string to prevent an attacker to guess prompts in multi-user "
+            "environments. The salt should be random, protected from "
+            "access by 3rd parties, and long enough to be "
+            "unpredictable (e.g., 43 characters base64-encoded, corresponding "
+            "to 256 bit). Not supported by vLLM engine V0."))
 
     # doc: end-chat-completion-extra-params
 
@@ -726,6 +736,20 @@ def check_generation_prompt(cls, data):
                              "`add_generation_prompt` to True.")
         return data
 
+    @model_validator(mode="before")
+    @classmethod
+    def check_cache_salt_support(cls, data):
+        if data.get("cache_salt") is not None:
+            if not envs.VLLM_USE_V1:
+                raise ValueError(
+                    "Parameter 'cache_salt' is not supported with "
+                    "this instance of vLLM, which uses engine V0.")
+            if not isinstance(data["cache_salt"],
+                              str) or not data["cache_salt"]:
+                raise ValueError("Parameter 'cache_salt' must be a "
+                                 "non-empty string if provided.")
+        return data
+
 
 class CompletionRequest(OpenAIBaseModel):
     # Ordered by official OpenAI API documentation
@@ -1622,9 +1646,9 @@ class TranscriptionRequest(OpenAIBaseModel):
 
     # doc: begin-transcription-extra-params
     stream: Optional[bool] = False
-    """Custom field not present in the original OpenAI definition. When set, 
+    """Custom field not present in the original OpenAI definition. When set,
     it will enable output to be streamed in a similar fashion as the Chat
-    Completion endpoint. 
+    Completion endpoint.
     """
     # Flattened stream option to simplify form data.
     stream_include_usage: Optional[bool] = False
@@ -1642,7 +1666,7 @@ class TranscriptionRequest(OpenAIBaseModel):
     """
 
     top_p: Optional[float] = None
-    """Enables nucleus (top-p) sampling, where tokens are selected from the 
+    """Enables nucleus (top-p) sampling, where tokens are selected from the
     smallest possible set whose cumulative probability exceeds `p`.
     """
 
@@ -1650,7 +1674,7 @@ class TranscriptionRequest(OpenAIBaseModel):
     """Limits sampling to the `k` most probable tokens at each step."""
 
     min_p: Optional[float] = None
-    """Filters out tokens with a probability lower than `min_p`, ensuring a 
+    """Filters out tokens with a probability lower than `min_p`, ensuring a
     minimum likelihood threshold during sampling.
     """
 
diff --git a/vllm/entrypoints/openai/serving_engine.py b/vllm/entrypoints/openai/serving_engine.py
index c3121eff562d..6123811aabe1 100644
--- a/vllm/entrypoints/openai/serving_engine.py
+++ b/vllm/entrypoints/openai/serving_engine.py
@@ -470,6 +470,9 @@ async def _preprocess_chat(
         if request.mm_processor_kwargs is not None:
             engine_prompt["mm_processor_kwargs"] = request.mm_processor_kwargs
 
+        if hasattr(request, "cache_salt") and request.cache_salt is not None:
+            engine_prompt["cache_salt"] = request.cache_salt
+
         return conversation, [request_prompt], [engine_prompt]
 
     def _log_inputs(
diff --git a/vllm/inputs/data.py b/vllm/inputs/data.py
index 970b36bca9be..167189ed108e 100644
--- a/vllm/inputs/data.py
+++ b/vllm/inputs/data.py
@@ -28,6 +28,11 @@ class TextPrompt(TypedDict):
     to pass the mm_processor_kwargs to each of them.
     """
 
+    cache_salt: NotRequired[str]
+    """
+    Optional cache salt to be used for prefix caching.
+    """
+
 
 class TokensPrompt(TypedDict):
     """Schema for a tokenized prompt."""
@@ -52,6 +57,11 @@ class TokensPrompt(TypedDict):
     to pass the mm_processor_kwargs to each of them.
     """
 
+    cache_salt: NotRequired[str]
+    """
+    Optional cache salt to be used for prefix caching.
+    """
+
 
 SingletonPrompt = Union[str, TextPrompt, TokensPrompt]
 """
@@ -141,11 +151,17 @@ class TokenInputs(TypedDict):
     The original prompt text corresponding to the token IDs, if available.
     """
 
+    cache_salt: NotRequired[str]
+    """
+    Optional cache salt to be used for prefix caching.
+    """
+
 
 def token_inputs(
     prompt_token_ids: list[int],
     token_type_ids: Optional[list[int]] = None,
     prompt: Optional[str] = None,
+    cache_salt: Optional[str] = None,
 ) -> TokenInputs:
     """Construct :class:`TokenInputs` from optional values."""
     inputs = TokenInputs(type="token", prompt_token_ids=prompt_token_ids)
@@ -154,6 +170,8 @@ def token_inputs(
         inputs["prompt"] = prompt
     if token_type_ids is not None:
         inputs["token_type_ids"] = token_type_ids
+    if cache_salt is not None:
+        inputs["cache_salt"] = cache_salt
 
     return inputs
 
@@ -217,7 +235,7 @@ def zip_enc_dec_prompts(
     """
     Zip encoder and decoder prompts together into a list of
     :class:`ExplicitEncoderDecoderPrompt` instances.
-    
+
     ``mm_processor_kwargs`` may also be provided; if a dict is passed, the same
     dictionary will be used for every encoder/decoder prompt. If an iterable is
     provided, it will be zipped with the encoder/decoder prompts.
diff --git a/vllm/inputs/preprocess.py b/vllm/inputs/preprocess.py
index 56b60b893913..83e6907f8c49 100644
--- a/vllm/inputs/preprocess.py
+++ b/vllm/inputs/preprocess.py
@@ -17,7 +17,8 @@
 
 from .data import (DecoderOnlyInputs, EncoderDecoderInputs, ProcessorInputs,
                    PromptType, SingletonInputs, SingletonPrompt, token_inputs)
-from .parse import is_explicit_encoder_decoder_prompt, parse_singleton_prompt
+from .parse import (ParsedStrPrompt, ParsedTextPrompt, ParsedTokensPrompt,
+                    is_explicit_encoder_decoder_prompt, parse_singleton_prompt)
 
 logger = init_logger(__name__)
 
@@ -283,6 +284,29 @@ async def _process_multimodal_async(
         return mm_processor.apply(prompt, mm_data, mm_processor_kwargs,
                                   return_mm_hashes)
 
+    def _get_prompt_data(self, parsed_prompt: Union[ParsedStrPrompt,
+                                                    ParsedTextPrompt,
+                                                    ParsedTokensPrompt]):
+        prompt_text = None
+        prompt_token_ids = None
+        token_type_ids = None
+        cache_salt = None
+
+        if parsed_prompt["type"] == "str":
+            prompt_text = parsed_prompt["content"]
+        else:
+            cache_salt = parsed_prompt["content"].get("cache_salt")
+            if parsed_prompt["type"] == "text":
+                prompt_text = parsed_prompt["content"]["prompt"]
+            elif parsed_prompt["type"] == "tokens":
+                prompt_token_ids = parsed_prompt["content"].get(
+                    "prompt_token_ids")
+                token_type_ids = parsed_prompt["content"].get("token_type_ids")
+            else:
+                assert_never(parsed_prompt)
+
+        return prompt_text, prompt_token_ids, token_type_ids, cache_salt
+
     def _prompt_to_llm_inputs(
         self,
         prompt: SingletonPrompt,
@@ -304,70 +328,36 @@ def _prompt_to_llm_inputs(
         * :class:`SingletonInputs` instance
         """
         parsed = parse_singleton_prompt(prompt)
-
-        if parsed["type"] == "str":
-            prompt_text = parsed["content"]
-            prompt_token_ids = self._tokenize_prompt(
-                prompt_text,
+        prompt_text, prompt_token_ids, token_type_ids, cache_salt = \
+            self._get_prompt_data(parsed)
+
+        # If multimodal data is present, process and return immediately
+        if parsed["type"] != "str" and parsed["content"].get(
+                "multi_modal_data") is not None:
+            inputs = self._process_multimodal(
+                prompt_text if prompt_text is not None else prompt_token_ids,
+                parsed["content"]["multi_modal_data"],
+                parsed["content"].get("mm_processor_kwargs"),
                 lora_request=lora_request,
-                tokenization_kwargs=tokenization_kwargs,
-            )
-
-            return token_inputs(
-                prompt=prompt_text,
-                prompt_token_ids=prompt_token_ids,
+                return_mm_hashes=return_mm_hashes,
             )
+            if cache_salt is not None:
+                inputs["cache_salt"] = cache_salt
+            return inputs
 
-        if parsed["type"] == "tokens":
-            tokens_content = parsed["content"]
-
-            prompt_token_ids = tokens_content["prompt_token_ids"]
-            token_type_ids = tokens_content.get("token_type_ids")
-            multi_modal_data = tokens_content.get("multi_modal_data")
-            mm_processor_kwargs = tokens_content.get("mm_processor_kwargs")
-
-            if multi_modal_data is not None:
-                return self._process_multimodal(
-                    prompt_token_ids,
-                    multi_modal_data,
-                    mm_processor_kwargs,
-                    lora_request=lora_request,
-                    return_mm_hashes=return_mm_hashes,
-                )
-
-            return token_inputs(
-                prompt_token_ids=prompt_token_ids,
-                token_type_ids=token_type_ids,
-            )
-
-        if parsed["type"] == "text":
-            text_content = parsed["content"]
-
-            prompt_text = text_content["prompt"]
-            multi_modal_data = text_content.get("multi_modal_data")
-            mm_processor_kwargs = text_content.get("mm_processor_kwargs")
-
-            if multi_modal_data is not None:
-                return self._process_multimodal(
-                    prompt_text,
-                    multi_modal_data,
-                    mm_processor_kwargs,
-                    lora_request=lora_request,
-                    return_mm_hashes=return_mm_hashes,
-                )
-
+        if prompt_token_ids is None:
             prompt_token_ids = self._tokenize_prompt(
                 prompt_text,
                 lora_request=lora_request,
                 tokenization_kwargs=tokenization_kwargs,
             )
 
-            return token_inputs(
-                prompt=prompt_text,
-                prompt_token_ids=prompt_token_ids,
-            )
-
-        assert_never(parsed)
+        return token_inputs(
+            prompt=prompt_text,
+            prompt_token_ids=prompt_token_ids,
+            token_type_ids=token_type_ids,
+            cache_salt=cache_salt,
+        )
 
     async def _prompt_to_llm_inputs_async(
         self,
@@ -379,64 +369,35 @@ async def _prompt_to_llm_inputs_async(
         """Async version of :meth:`_extract_prompt_components`."""
         parsed = parse_singleton_prompt(prompt)
 
-        if parsed["type"] == "str":
-            prompt_text = parsed["content"]
-            prompt_token_ids = await self._tokenize_prompt_async(
-                prompt_text,
-                lora_request=lora_request,
-                tokenization_kwargs=tokenization_kwargs,
-            )
+        prompt_text, prompt_token_ids, token_type_ids, cache_salt = \
+            self._get_prompt_data(parsed)
 
-            return token_inputs(
-                prompt=prompt_text,
-                prompt_token_ids=prompt_token_ids,
+        if parsed["type"] != "str" and parsed["content"].get(
+                "multi_modal_data") is not None:
+            inputs = await self._process_multimodal_async(
+                prompt_token_ids if prompt_text is None else prompt_text,
+                parsed["content"]["multi_modal_data"],
+                parsed["content"].get("mm_processor_kwargs"),
+                lora_request=lora_request,
+                return_mm_hashes=return_mm_hashes,
             )
+            if cache_salt is not None:
+                inputs["cache_salt"] = cache_salt
+            return inputs
 
-        if parsed["type"] == "tokens":
-            tokens_content = parsed["content"]
-
-            prompt_token_ids = tokens_content["prompt_token_ids"]
-            multi_modal_data = tokens_content.get("multi_modal_data")
-            mm_processor_kwargs = tokens_content.get("mm_processor_kwargs")
-
-            if multi_modal_data is not None:
-                return await self._process_multimodal_async(
-                    prompt_token_ids,
-                    multi_modal_data,
-                    mm_processor_kwargs,
-                    lora_request=lora_request,
-                    return_mm_hashes=return_mm_hashes,
-                )
-
-            return token_inputs(prompt_token_ids=prompt_token_ids)
-
-        if parsed["type"] == "text":
-            text_content = parsed["content"]
-
-            prompt_text = text_content["prompt"]
-            multi_modal_data = text_content.get("multi_modal_data")
-            mm_processor_kwargs = text_content.get("mm_processor_kwargs")
-
-            if multi_modal_data is not None:
-                return await self._process_multimodal_async(
-                    prompt_text,
-                    multi_modal_data,
-                    mm_processor_kwargs,
-                    lora_request=lora_request,
-                    return_mm_hashes=return_mm_hashes,
-                )
-
+        if prompt_token_ids is None:
             prompt_token_ids = await self._tokenize_prompt_async(
                 prompt_text,
                 lora_request=lora_request,
+                tokenization_kwargs=tokenization_kwargs,
             )
 
-            return token_inputs(
-                prompt=prompt_text,
-                prompt_token_ids=prompt_token_ids,
-            )
-
-        assert_never(parsed)
+        return token_inputs(
+            prompt=prompt_text,
+            prompt_token_ids=prompt_token_ids,
+            token_type_ids=token_type_ids,
+            cache_salt=cache_salt,
+        )
 
     def _build_enc_dec_llm_inputs(
         self,
@@ -516,6 +477,11 @@ def _separate_enc_dec_inputs_from_mm_processor_outputs(
                     mm_hashes=inputs["mm_hashes"],
                     mm_placeholders=inputs["mm_placeholders"],
                 )
+
+            cache_salt = inputs.get("cache_salt")
+            if cache_salt is not None:
+                decoder_inputs["cache_salt"] = cache_salt
+
         elif inputs["type"] == "token":
             # Text-only inputs
             encoder_inputs = token_inputs(prompt="", prompt_token_ids=[])
diff --git a/vllm/multimodal/inputs.py b/vllm/multimodal/inputs.py
index 6855808e8e44..978fb4231939 100644
--- a/vllm/multimodal/inputs.py
+++ b/vllm/multimodal/inputs.py
@@ -826,6 +826,11 @@ class MultiModalInputs(TypedDict):
     :code:`prompt_token_ids`.
     """
 
+    cache_salt: NotRequired[str]
+    """
+    Optional cache salt to be used for prefix caching.
+    """
+
 
 class MultiModalEncDecInputs(MultiModalInputs):
     """
diff --git a/vllm/multimodal/processing.py b/vllm/multimodal/processing.py
index d6ba8f1bcffe..e8745a8f1f90 100644
--- a/vllm/multimodal/processing.py
+++ b/vllm/multimodal/processing.py
@@ -1789,7 +1789,7 @@ def create_encoder_prompt(
         mm_data: MultiModalDataDict,
     ) -> Union[str, list[int]]:
         """
-        Create input prompt for the encoder. HF processor will be applied on 
+        Create input prompt for the encoder. HF processor will be applied on
         this prompt during profiling and generation.
         """
         raise NotImplementedError
diff --git a/vllm/v1/core/kv_cache_utils.py b/vllm/v1/core/kv_cache_utils.py
index 3026ecc1c968..27c515835087 100644
--- a/vllm/v1/core/kv_cache_utils.py
+++ b/vllm/v1/core/kv_cache_utils.py
@@ -275,7 +275,10 @@ def need_extra_keys(request: Request) -> bool:
 
     # Multimodal requests need to include the MM hash.
     # LoRA requests need to include the LoRA ID.
-    return bool(request.mm_positions) or (request.lora_request is not None)
+    # Request with provided cache salt need to include the salt.
+    return bool(request.mm_positions) or (request.lora_request
+                                          is not None) or (request.cache_salt
+                                                           is not None)
 
 
 def _gen_mm_extra_hash_keys(request: Request, start_token_idx: int,
@@ -380,8 +383,10 @@ def generate_block_hash_extra_keys(
     mm_extra_keys, new_start_mm_idx = _gen_mm_extra_hash_keys(
         request, start_token_idx, end_token_idx, start_mm_idx)
     lora_extra_keys: list[int] = _gen_lora_extra_hash_keys(request)
+    cache_salt_keys: list[str] = [request.cache_salt] if (
+        start_token_idx == 0 and request.cache_salt) else []
 
-    extra_keys: list[Any] = lora_extra_keys + mm_extra_keys
+    extra_keys: list[Any] = lora_extra_keys + mm_extra_keys + cache_salt_keys
 
     if not extra_keys:
         return None, new_start_mm_idx
@@ -657,10 +662,10 @@ def _get_kv_cache_config_uniform_type(vllm_config: VllmConfig,
 def unify_hybrid_kv_cache_specs(kv_cache_spec: dict[str, KVCacheSpec]):
     """
     Only models with one type of KV cache are supported yet. This function tries
-    to convert the KV cache specs to one type if the model is a hybrid model 
+    to convert the KV cache specs to one type if the model is a hybrid model
     with multiple type of KV cache. It will convert all SlidingWindowSpec to
     FullAttentionSpec if both types are present.
-    
+
     Args:
         kv_cache_spec: The kv cache spec of each attention layer in the model
     """
diff --git a/vllm/v1/engine/__init__.py b/vllm/v1/engine/__init__.py
index 0474669610cd..e33d1a1e5dcd 100644
--- a/vllm/v1/engine/__init__.py
+++ b/vllm/v1/engine/__init__.py
@@ -57,6 +57,7 @@ class EngineCoreRequest(
     eos_token_id: Optional[int]
     arrival_time: float
     lora_request: Optional[LoRARequest]
+    cache_salt: Optional[str]
 
     # Used in DP case to indicate which wave of requests this is expected to
     # belong to, to cover a race condition where the request is sent before
diff --git a/vllm/v1/engine/processor.py b/vllm/v1/engine/processor.py
index b98a31773a15..27d70a781471 100644
--- a/vllm/v1/engine/processor.py
+++ b/vllm/v1/engine/processor.py
@@ -317,6 +317,7 @@ def process_inputs(
             eos_token_id=eos_token_id,
             arrival_time=arrival_time,
             lora_request=lora_request,
+            cache_salt=decoder_inputs.get("cache_salt"),
         )
 
     def _validate_model_inputs(self,
diff --git a/vllm/v1/request.py b/vllm/v1/request.py
index 3b9b666f936a..fde366d61c7d 100644
--- a/vllm/v1/request.py
+++ b/vllm/v1/request.py
@@ -29,6 +29,7 @@ def __init__(
         arrival_time: float,
         lora_request: Optional["LoRARequest"] = None,
         structured_output_request: Optional["StructuredOutputRequest"] = None,
+        cache_salt: Optional[str] = None,
     ) -> None:
         self.request_id = request_id
         self.sampling_params = sampling_params
@@ -51,6 +52,7 @@ def __init__(
         self._all_token_ids: list[int] = self.prompt_token_ids.copy()
         self.spec_token_ids: list[int] = []
         self.num_computed_tokens = 0
+        self.cache_salt: Optional[str] = cache_salt
 
         # Multi-modal related
         self.mm_positions = multi_modal_placeholders or []
@@ -89,6 +91,7 @@ def from_engine_core_request(cls, request: EngineCoreRequest) -> "Request":
             lora_request=request.lora_request,
             structured_output_request=StructuredOutputRequest(
                 sampling_params=request.sampling_params),
+            cache_salt=request.cache_salt,
         )
 
     def append_output_token_ids(",
"url": "https://github.com/vllm-project/vllm/commit/77073c77bc2006eb80ea6d5128f076f5e6c6f54f.patch"
}
] |
CWE-208: Observable Timing Discrepancy
|
CVE-2024-32020
|
Cloning local Git repository by untrusted user allows the untrusted user to modify objects in the cloned repository at will
|
Git is a revision control system. Prior to versions 2.45.1, 2.44.1, 2.43.4, 2.42.2, 2.41.1, 2.40.2, and 2.39.4, local clones may end up hardlinking files into the target repository's object database when source and target repository reside on the same disk. If the source repository is owned by a different user, then those hardlinked files may be rewritten at any point in time by the untrusted user. Cloning local repositories will cause Git to either copy or hardlink files of the source repository into the target repository. This significantly speeds up such local clones compared to doing a "proper" clone and saves both disk space and compute time. When cloning a repository located on the same disk that is owned by a different user than the current user we also end up creating such hardlinks. These files will continue to be owned and controlled by the potentially-untrusted user and can be rewritten by them at will in the future. The problem has been patched in versions 2.45.1, 2.44.1, 2.43.4, 2.42.2, 2.41.1, 2.40.2, and 2.39.4.
|
[
{
"commit_message": "[PATCH] builtin/clone: refuse local clones of unsafe repositories When performing a local clone of a repository we end up either copying or hardlinking the source repository into the target repository. This is significantly more performant than if we were to use git-upload-pack(1) and git-fetch-pack(1) to create the new repository and preserves both disk space and compute time. Unfortunately though, performing such a local clone of a repository that is not owned by the current user is inherently unsafe: - It is possible that source files get swapped out underneath us while we are copying or hardlinking them. While we do perform some checks here to assert that we hardlinked the expected file, they cannot reliably thwart time-of-check-time-of-use (TOCTOU) style races. It is thus possible for an adversary to make us copy or hardlink unexpected files into the target directory. Ideally, we would address this by starting to use openat(3P), fstatat(3P) and friends. Due to platform compatibility with Windows we cannot easily do that though. Furthermore, the scope of these fixes would likely be quite broad and thus not fit for an embargoed security release. - Even if we handled TOCTOU-style races perfectly, hardlinking files owned by a different user into the target repository is not a good idea in general. It is possible for an adversary to rewrite those files to contain whatever data they want even after the clone has completed. Address these issues by completely refusing local clones of a repository that is not owned by the current user. This reuses our existing infra we have in place via `ensure_valid_ownership()` and thus allows a user to override the safety guard by adding the source repository path to the \"safe.directory\" configuration. This addresses CVE-2024-32020. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> builtin/clone.c | 14 ++++++++++++++ t/t0033-safe-directory.sh | 24 ++++++++++++++++++++++++ 2 files changed, 38 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/git/git/commit/1204e1a824c34071019fe106348eaa6d88f9528d.patch"
},
{
"commit_message": "[PATCH 1/4] builtin/clone: stop resolving symlinks when copying files When a user performs a local clone without `--no-local`, then we end up copying the source repository into the target repository directly. To optimize this even further, we try to hardlink files into place instead of copying data over, which helps both disk usage and speed. There is an important edge case in this context though, namely when we try to hardlink symlinks from the source repository into the target repository. Depending on both platform and filesystem the resulting behaviour here can be different: - On macOS and NetBSD, calling link(3P) with a symlink target creates a hardlink to the file pointed to by the symlink. - On Linux, calling link(3P) instead creates a hardlink to the symlink itself. To unify this behaviour, 36596fd2df (clone: better handle symlinked files at .git/objects/, 2019-07-10) introduced logic to resolve symlinks before we try to link(3P) files. Consequently, the new behaviour was to always create a hard link to the target of the symlink on all platforms. Eventually though, we figured out that following symlinks like this can cause havoc when performing a local clone of a malicious repository, which resulted in CVE-2022-39253. This issue was fixed via 6f054f9fb3 (builtin/clone.c: disallow `--local` clones with symlinks, 2022-07-28), by refusing symlinks in the source repository. But even though we now shouldn't ever link symlinks anymore, the code that resolves symlinks still exists. In the best case the code does not end up doing anything because there are no symlinks anymore. In the worst case though this can be abused by an adversary that rewrites the source file after it has been checked not to be a symlink such that it actually is a symlink when we call link(3P). Thus, it is still possible to recreate CVE-2022-39253 due to this time-of-check-time-of-use bug. Remove the call to `realpath()`. This doesn't yet address the actual vulnerability, which will be handled in a subsequent commit. Reported-by: Apple Product Security <product-security@apple.com> Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> builtin/clone.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-)",
"patch_text_b64": "From 150e6b0aedf57d224c3c49038c306477fa159886 Mon Sep 17 00:00:00 2001
From: Patrick Steinhardt <ps@pks.im>
Date: Mon, 15 Apr 2024 13:30:26 +0200
Subject: [PATCH 1/4] builtin/clone: stop resolving symlinks when copying files

When a user performs a local clone without `--no-local`, then we end up
copying the source repository into the target repository directly. To
optimize this even further, we try to hardlink files into place instead
of copying data over, which helps both disk usage and speed.

There is an important edge case in this context though, namely when we
try to hardlink symlinks from the source repository into the target
repository. Depending on both platform and filesystem the resulting
behaviour here can be different:

  - On macOS and NetBSD, calling link(3P) with a symlink target creates
    a hardlink to the file pointed to by the symlink.

  - On Linux, calling link(3P) instead creates a hardlink to the symlink
    itself.

To unify this behaviour, 36596fd2df (clone: better handle symlinked
files at .git/objects/, 2019-07-10) introduced logic to resolve symlinks
before we try to link(3P) files. Consequently, the new behaviour was to
always create a hard link to the target of the symlink on all platforms.

Eventually though, we figured out that following symlinks like this can
cause havoc when performing a local clone of a malicious repository,
which resulted in CVE-2022-39253. This issue was fixed via 6f054f9fb3
(builtin/clone.c: disallow `--local` clones with symlinks, 2022-07-28),
by refusing symlinks in the source repository.

But even though we now shouldn't ever link symlinks anymore, the code
that resolves symlinks still exists. In the best case the code does not
end up doing anything because there are no symlinks anymore. In the
worst case though this can be abused by an adversary that rewrites the
source file after it has been checked not to be a symlink such that it
actually is a symlink when we call link(3P). Thus, it is still possible
to recreate CVE-2022-39253 due to this time-of-check-time-of-use bug.

Remove the call to `realpath()`. This doesn't yet address the actual
vulnerability, which will be handled in a subsequent commit.

Reported-by: Apple Product Security <product-security@apple.com>
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 builtin/clone.c | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/builtin/clone.c b/builtin/clone.c
index 3c2ae31a559f48..073e6323d7e188 100644
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -320,7 +320,6 @@ static void copy_or_link_directory(struct strbuf *src, struct strbuf *dest,
 	int src_len, dest_len;
 	struct dir_iterator *iter;
 	int iter_status;
-	struct strbuf realpath = STRBUF_INIT;
 
 	mkdir_if_missing(dest->buf, 0777);
 
@@ -358,8 +357,7 @@ static void copy_or_link_directory(struct strbuf *src, struct strbuf *dest,
 		if (unlink(dest->buf) && errno != ENOENT)
 			die_errno(_("failed to unlink '%s'"), dest->buf);
 		if (!option_no_hardlinks) {
-			strbuf_realpath(&realpath, src->buf, 1);
-			if (!link(realpath.buf, dest->buf))
+			if (!link(src->buf, dest->buf))
 				continue;
 			if (option_local > 0)
 				die_errno(_("failed to create link '%s'"), dest->buf);
@@ -373,8 +371,6 @@ static void copy_or_link_directory(struct strbuf *src, struct strbuf *dest,
 		strbuf_setlen(src, src_len);
 		die(_("failed to iterate over '%s'"), src->buf);
 	}
-
-	strbuf_release(&realpath);
 }
 
 static void clone_local(const char *src_repo, const char *dest_repo)

From d1bb66a546b4bb46005d17ba711caaad26f26c1e Mon Sep 17 00:00:00 2001
From: Patrick Steinhardt <ps@pks.im>
Date: Mon, 15 Apr 2024 13:30:31 +0200
Subject: [PATCH 2/4] builtin/clone: abort when hardlinked source and target
 file differ

When performing local clones with hardlinks we refuse to copy source
files which are symlinks as a mitigation for CVE-2022-39253. This check
can be raced by an adversary though by changing the file to a symlink
after we have checked it.

Fix the issue by checking whether the hardlinked destination file
matches the source file and abort in case it doesn't.

This addresses CVE-2024-32021.

Reported-by: Apple Product Security <product-security@apple.com>
Suggested-by: Linus Torvalds <torvalds@linuxfoundation.org>
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 builtin/clone.c | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/builtin/clone.c b/builtin/clone.c
index 073e6323d7e188..4b80fa0870b625 100644
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -357,8 +357,27 @@ static void copy_or_link_directory(struct strbuf *src, struct strbuf *dest,
 		if (unlink(dest->buf) && errno != ENOENT)
 			die_errno(_("failed to unlink '%s'"), dest->buf);
 		if (!option_no_hardlinks) {
-			if (!link(src->buf, dest->buf))
+			if (!link(src->buf, dest->buf)) {
+				struct stat st;
+
+				/*
+				 * Sanity-check whether the created hardlink
+				 * actually links to the expected file now. This
+				 * catches time-of-check-time-of-use bugs in
+				 * case the source file was meanwhile swapped.
+				 */
+				if (lstat(dest->buf, &st))
+					die(_("hardlink cannot be checked at '%s'"), dest->buf);
+				if (st.st_mode != iter->st.st_mode ||
+				    st.st_ino != iter->st.st_ino ||
+				    st.st_dev != iter->st.st_dev ||
+				    st.st_size != iter->st.st_size ||
+				    st.st_uid != iter->st.st_uid ||
+				    st.st_gid != iter->st.st_gid)
+					die(_("hardlink different from source at '%s'"), dest->buf);
+
 				continue;
+			}
 			if (option_local > 0)
 				die_errno(_("failed to create link '%s'"), dest->buf);
 			option_no_hardlinks = 1;

From 8c9c051bef3db0fe267f3fb6a1dab293c5f23b38 Mon Sep 17 00:00:00 2001
From: Patrick Steinhardt <ps@pks.im>
Date: Mon, 15 Apr 2024 13:30:36 +0200
Subject: [PATCH 3/4] setup.c: introduce `die_upon_dubious_ownership()`

Introduce a new function `die_upon_dubious_ownership()` that uses
`ensure_valid_ownership()` to verify whether a repositroy is safe for
use, and causes Git to die in case it is not.

This function will be used in a subsequent commit.

Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 cache.h | 12 ++++++++++++
 setup.c | 21 +++++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/cache.h b/cache.h
index fcf49706ad56ad..a46a3e4b6b1ebc 100644
--- a/cache.h
+++ b/cache.h
@@ -606,6 +606,18 @@ void set_git_work_tree(const char *tree);
 
 #define ALTERNATE_DB_ENVIRONMENT "GIT_ALTERNATE_OBJECT_DIRECTORIES"
 
+/*
+ * Check if a repository is safe and die if it is not, by verifying the
+ * ownership of the worktree (if any), the git directory, and the gitfile (if
+ * any).
+ *
+ * Exemptions for known-safe repositories can be added via `safe.directory`
+ * config settings; for non-bare repositories, their worktree needs to be
+ * added, for bare ones their git directory.
+ */
+void die_upon_dubious_ownership(const char *gitfile, const char *worktree,
+				const char *gitdir);
+
 void setup_work_tree(void);
 /*
  * Find the commondir and gitdir of the repository that contains the current
diff --git a/setup.c b/setup.c
index cefd5f63c4680f..9d401ae4c8f1cb 100644
--- a/setup.c
+++ b/setup.c
@@ -1165,6 +1165,27 @@ static int ensure_valid_ownership(const char *gitfile,
 	return data.is_safe;
 }
 
+void die_upon_dubious_ownership(const char *gitfile, const char *worktree,
+				const char *gitdir)
+{
+	struct strbuf report = STRBUF_INIT, quoted = STRBUF_INIT;
+	const char *path;
+
+	if (ensure_valid_ownership(gitfile, worktree, gitdir, &report))
+		return;
+
+	strbuf_complete(&report, '\n');
+	path = gitfile ? gitfile : gitdir;
+	sq_quote_buf_pretty(&quoted, path);
+
+	die(_("detected dubious ownership in repository at '%s'\n"
+	      "%s"
+	      "To add an exception for this directory, call:\n"
+	      "\n"
+	      "\tgit config --global --add safe.directory %s"),
+	    path, report.buf, quoted.buf);
+}
+
 static int allowed_bare_repo_cb(const char *key, const char *value, void *d)
 {
 	enum allowed_bare_repo *allowed_bare_repo = d;

From 1204e1a824c34071019fe106348eaa6d88f9528d Mon Sep 17 00:00:00 2001
From: Patrick Steinhardt <ps@pks.im>
Date: Mon, 15 Apr 2024 13:30:41 +0200
Subject: [PATCH 4/4] builtin/clone: refuse local clones of unsafe repositories

When performing a local clone of a repository we end up either copying
or hardlinking the source repository into the target repository. This is
significantly more performant than if we were to use git-upload-pack(1)
and git-fetch-pack(1) to create the new repository and preserves both
disk space and compute time.

Unfortunately though, performing such a local clone of a repository that
is not owned by the current user is inherently unsafe:

  - It is possible that source files get swapped out underneath us while
    we are copying or hardlinking them. While we do perform some checks
    here to assert that we hardlinked the expected file, they cannot
    reliably thwart time-of-check-time-of-use (TOCTOU) style races. It
    is thus possible for an adversary to make us copy or hardlink
    unexpected files into the target directory.

    Ideally, we would address this by starting to use openat(3P),
    fstatat(3P) and friends. Due to platform compatibility with Windows
    we cannot easily do that though. Furthermore, the scope of these
    fixes would likely be quite broad and thus not fit for an embargoed
    security release.

  - Even if we handled TOCTOU-style races perfectly, hardlinking files
    owned by a different user into the target repository is not a good
    idea in general. It is possible for an adversary to rewrite those
    files to contain whatever data they want even after the clone has
    completed.

Address these issues by completely refusing local clones of a repository
that is not owned by the current user. This reuses our existing infra we
have in place via `ensure_valid_ownership()` and thus allows a user to
override the safety guard by adding the source repository path to the
"safe.directory" configuration.

This addresses CVE-2024-32020.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
 builtin/clone.c           | 14 ++++++++++++++
 t/t0033-safe-directory.sh | 24 ++++++++++++++++++++++++
 2 files changed, 38 insertions(+)

diff --git a/builtin/clone.c b/builtin/clone.c
index 4b80fa0870b625..9ec500d427e315 100644
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -321,6 +321,20 @@ static void copy_or_link_directory(struct strbuf *src, struct strbuf *dest,
 	struct dir_iterator *iter;
 	int iter_status;
 
+	/*
+	 * Refuse copying directories by default which aren't owned by us. The
+	 * code that performs either the copying or hardlinking is not prepared
+	 * to handle various edge cases where an adversary may for example
+	 * racily swap out files for symlinks. This can cause us to
+	 * inadvertently use the wrong source file.
+	 *
+	 * Furthermore, even if we were prepared to handle such races safely,
+	 * creating hardlinks across user boundaries is an inherently unsafe
+	 * operation as the hardlinked files can be rewritten at will by the
+	 * potentially-untrusted user. We thus refuse to do so by default.
+	 */
+	die_upon_dubious_ownership(NULL, NULL, src_repo);
+
 	mkdir_if_missing(dest->buf, 0777);
 
 	iter = dir_iterator_begin(src->buf, DIR_ITERATOR_PEDANTIC);
diff --git a/t/t0033-safe-directory.sh b/t/t0033-safe-directory.sh
index dc3496897abc96..11c3e8f28e0df9 100755
--- a/t/t0033-safe-directory.sh
+++ b/t/t0033-safe-directory.sh
@@ -80,4 +80,28 @@ test_expect_success 'safe.directory in included file' '
 	git status
 '
 
+test_expect_success 'local clone of unowned repo refused in unsafe directory' '
+	test_when_finished "rm -rf source" &&
+	git init source &&
+	(
+		sane_unset GIT_TEST_ASSUME_DIFFERENT_OWNER &&
+		test_commit -C source initial
+	) &&
+	test_must_fail git clone --local source target &&
+	test_path_is_missing target
+'
+
+test_expect_success 'local clone of unowned repo accepted in safe directory' '
+	test_when_finished "rm -rf source" &&
+	git init source &&
+	(
+		sane_unset GIT_TEST_ASSUME_DIFFERENT_OWNER &&
+		test_commit -C source initial
+	) &&
+	test_must_fail git clone --local source target &&
+	git config --global --add safe.directory "$(pwd)/source/.git" &&
+	git clone --local source target &&
+	test_path_is_dir target
+'
+
 test_done",
"url": "https://github.com/git/git/commit/9e65df5eab274bf74c7b570107aacd1303a1e703.patch"
}
] |
CWE-281: Improper Preservation of Permissions
|
CVE-2025-48063
|
XWiki Platform Security Authorization Bridge allows users with just edit right can enforce required rights with programming right
|
XWiki is a generic wiki platform. In XWiki 16.10.0, required rights were introduced as a way to limit which rights a document can have. Part of the security model of required rights is that a user who doesn't have a right also cannot define that right as required right. That way, users who are editing documents on which required rights are enforced can be sure that they're not giving a right to a script or object that it didn't have before. A bug in the implementation of the enforcement of this rule means that in fact, it was possible for any user with edit right on a document to set programming right as required right. If then a user with programming right edited that document, the content of that document would gain programming right, allowing remote code execution. This thereby defeats most of the security benefits of required rights. As XWiki still performs the required rights analysis when a user edits a page even when required rights are enforced, the user with programming right would still be warned about the dangerous content unless the attacker managed to bypass this check. Note also that none of the affected versions include a UI for enabling the enforcing of required rights so it seems unlikely that anybody relied on them for security in the affected versions. As this vulnerability provides no additional attack surface unless all documents in the wiki enforce required rights, we consider the impact of this attack to be low even though gaining programming right could have a high impact. This vulnerability has been patched in XWiki 16.10.4 and 17.1.0RC1. No known workarounds are available except for upgrading.
|
[
{
"commit_message": "[PATCH] XWIKI-22859: RightsFilterListener error when required right scope is null * Fix a null pointer exception in RightsFilterListener which was triggered when the scope of the required right is null. * Add a unit test covering this case. .../internal/RightsFilterListener.java | 2 +- .../internal/RightsFilterListenerTest.java | 24 +++++++++++++++++++ 2 files changed, 25 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/xwiki/xwiki-platform/commit/2557813aef3b863988d6cca58de996e207086898.patch"
}
] |
CWE-285: Improper Authorization
|
CVE-2022-0502
|
Cross-site Scripting (XSS) - Stored in livehelperchat/livehelperchat
|
Cross-site Scripting (XSS) - Stored in Packagist remdex/livehelperchat prior to 3.93v.
|
[
{
"commit_message": "[PATCH] Canned messages fixes .../design/defaulttheme/tpl/lhchat/cannedmsgform.tpl.php | 2 +- .../defaulttheme/tpl/lhuser/parts/canned_messages.tpl.php | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/livehelperchat/livehelperchat/commit/d3b107aaa8ec10816acc762d60e7321079c21706.patch"
}
] |
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
GHSA-p5v3-7243-m33v
| null |
[
{
"commit_message": "[PATCH] encode: protect from stack under-flow From GH #178 fuzzing src/bits.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSBiODRjMmNhYjU1OTQ4YTVlZTcwODYwNzc5YjI2NDA5MTNlM2VlMWVkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBSZWluaSBVcmJhbiA8cnVyYmFuQGNwYW4ub3JnPgpEYXRlOiBUdWUsIDMxIERlYyAyMDE5IDA4OjQ5OjA3ICswMTAwClN1YmplY3Q6IFtQQVRDSF0gZW5jb2RlOiBwcm90ZWN0IGZyb20gc3RhY2sgdW5kZXItZmxvdwoKRnJvbSBHSCAjMTc4IGZ1enppbmcKLS0tCiBzcmMvYml0cy5jIHwgMiArLQogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JpdHMuYyBiL3NyYy9iaXRzLmMKaW5kZXggMDE0YjA0ZmU0Yy4uYTM2OTJiZGM2NiAxMDA2NDQKLS0tIGEvc3JjL2JpdHMuYworKysgYi9zcmMvYml0cy5jCkBAIC05NTMsNyArOTUzLDcgQEAgYml0X3dyaXRlX1VNQyAoQml0X0NoYWluICpkYXQsIEJJVENPREVfVU1DIHZhbCkKICAgICBpZiAoYnl0ZVtpXSAmIDB4N2YpCiAgICAgICBicmVhazsKIAotICBpZiAoYnl0ZVtpXSAmIDB4NDApCisgIGlmIChieXRlW2ldICYgMHg0MCAmJiBpID4gMCkKICAgICBpLS07CiAgIGJ5dGVbaV0gJj0gMHg3ZjsKICAgZm9yIChqID0gNDsgaiA+PSBpOyBqLS0p",
"url": "https://github.com/LibreDWG/libredwg/commit/b84c2cab55948a5ee70860779b2640913e3ee1ed.patch"
}
] | null |
|
GHSA-5wvp-7f3h-6wmm
|
PyArrow: Arbitrary code execution when loading a malicious data file
| null |
[
{
"commit_message": "[PATCH] GH-38607: [Python] Disable PyExtensionType autoload (#38608) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ### Rationale for this change PyExtensionType autoload is really a misfeature. It creates PyArrow-specific extension types, though using ExtensionType is almost the same complexity while allowing deserialization from non-PyArrow software. ### What changes are included in this PR? * Disable PyExtensionType autoloading and deprecate PyExtensionType instantiation. * Update the docs to emphasize ExtensionType. ### Are these changes tested? Yes. ### Are there any user-facing changes? Yes. * Closes: #38607 Authored-by: Antoine Pitrou <antoine@python.org> Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com> docs/source/python/extending_types.rst | 149 ++++------ python/pyarrow/tests/test_cffi.py | 48 ++- python/pyarrow/tests/test_extension_type.py | 313 ++++++++++++++------ python/pyarrow/tests/test_pandas.py | 24 +- python/pyarrow/types.pxi | 88 +++--- 5 files changed, 377 insertions(+), 245 deletions(-)",
"patch_text_b64": "From f14170976372436ec1d03a724d8d3f3925484ecf Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Mon, 6 Nov 2023 23:20:05 +0100
Subject: [PATCH] GH-38607: [Python] Disable PyExtensionType autoload (#38608)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

PyExtensionType autoload is really a misfeature. It creates PyArrow-specific extension types, though using ExtensionType is almost the same complexity while allowing deserialization from non-PyArrow software.

### What changes are included in this PR?

* Disable PyExtensionType autoloading and deprecate PyExtensionType instantiation.
* Update the docs to emphasize ExtensionType.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.

* Closes: #38607

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 docs/source/python/extending_types.rst      | 149 ++++------
 python/pyarrow/tests/test_cffi.py           |  48 ++-
 python/pyarrow/tests/test_extension_type.py | 313 ++++++++++++++------
 python/pyarrow/tests/test_pandas.py         |  24 +-
 python/pyarrow/types.pxi                    |  88 +++---
 5 files changed, 377 insertions(+), 245 deletions(-)

diff --git a/docs/source/python/extending_types.rst b/docs/source/python/extending_types.rst
index b9e875ceebc..ee92cebcb54 100644
--- a/docs/source/python/extending_types.rst
+++ b/docs/source/python/extending_types.rst
@@ -68,34 +68,43 @@ message).
 See the :ref:`format_metadata_extension_types` section of the metadata
 specification for more details.
 
-Pyarrow allows you to define such extension types from Python.
-
-There are currently two ways:
-
-* Subclassing :class:`PyExtensionType`: the (de)serialization is based on pickle.
-  This is a good option for an extension type that is only used from Python.
-* Subclassing :class:`ExtensionType`: this allows to give a custom
-  Python-independent name and serialized metadata, that can potentially be
-  recognized by other (non-Python) Arrow implementations such as PySpark.
+Pyarrow allows you to define such extension types from Python by subclassing
+:class:`ExtensionType` and giving the derived class its own extension name
+and serialization mechanism. The extension name and serialized metadata
+can potentially be recognized by other (non-Python) Arrow implementations
+such as PySpark.
 
 For example, we could define a custom UUID type for 128-bit numbers which can
-be represented as ``FixedSizeBinary`` type with 16 bytes.
-Using the first approach, we create a ``UuidType`` subclass, and implement the
-``__reduce__`` method to ensure the class can be properly pickled::
+be represented as ``FixedSizeBinary`` type with 16 bytes::
 
-    class UuidType(pa.PyExtensionType):
+    class UuidType(pa.ExtensionType):
 
         def __init__(self):
-            pa.PyExtensionType.__init__(self, pa.binary(16))
+            super().__init__(pa.binary(16), "my_package.uuid")
+
+        def __arrow_ext_serialize__(self):
+            # Since we don't have a parameterized type, we don't need extra
+            # metadata to be deserialized
+            return b''
 
-        def __reduce__(self):
-            return UuidType, ()
+        @classmethod
+        def __arrow_ext_deserialize__(cls, storage_type, serialized):
+            # Sanity checks, not required but illustrate the method signature.
+            assert storage_type == pa.binary(16)
+            assert serialized == b''
+            # Return an instance of this subclass given the serialized
+            # metadata.
+            return UuidType()
+
+The special methods ``__arrow_ext_serialize__`` and ``__arrow_ext_deserialize__``
+define the serialization of an extension type instance. For non-parametric
+types such as the above, the serialization payload can be left empty.
 
 This can now be used to create arrays and tables holding the extension type::
 
     >>> uuid_type = UuidType()
     >>> uuid_type.extension_name
-    'arrow.py_extension_type'
+    'my_package.uuid'
     >>> uuid_type.storage_type
     FixedSizeBinaryType(fixed_size_binary[16])
 
@@ -112,8 +121,11 @@ This can now be used to create arrays and tables holding the extension type::
     ]
 
 This array can be included in RecordBatches, sent over IPC and received in
-another Python process. The custom UUID type will be preserved there, as long
-as the definition of the class is available (the type can be unpickled).
+another Python process. The receiving process must explicitly register the
+extension type for deserialization, otherwise it will fall back to the
+storage type::
+
+    >>> pa.register_extension_type(UuidType())
 
 For example, creating a RecordBatch and writing it to a stream using the
 IPC protocol::
@@ -129,43 +141,12 @@ and then reading it back yields the proper type::
     >>> with pa.ipc.open_stream(buf) as reader:
     ...    result = reader.read_all()
     >>> result.column('ext').type
-    UuidType(extension<arrow.py_extension_type>)
-
-We can define the same type using the other option::
-
-    class UuidType(pa.ExtensionType):
-
-        def __init__(self):
-            pa.ExtensionType.__init__(self, pa.binary(16), "my_package.uuid")
-
-        def __arrow_ext_serialize__(self):
-            # since we don't have a parameterized type, we don't need extra
-            # metadata to be deserialized
-            return b''
-
-        @classmethod
-        def __arrow_ext_deserialize__(self, storage_type, serialized):
-            # return an instance of this subclass given the serialized
-            # metadata.
-            return UuidType()
-
-This is a slightly longer implementation (you need to implement the special
-methods ``__arrow_ext_serialize__`` and ``__arrow_ext_deserialize__``), and the
-extension type needs to be registered to be received through IPC (using
-:func:`register_extension_type`), but it has
-now a unique name::
-
-    >>> uuid_type = UuidType()
-    >>> uuid_type.extension_name
-    'my_package.uuid'
-
-    >>> pa.register_extension_type(uuid_type)
+    UuidType(FixedSizeBinaryType(fixed_size_binary[16]))
 
 The receiving application doesn't need to be Python but can still recognize
-the extension type as a "uuid" type, if it has implemented its own extension
-type to receive it.
-If the type is not registered in the receiving application, it will fall back
-to the storage type.
+the extension type as a "my_package.uuid" type, if it has implemented its own
+extension type to receive it. If the type is not registered in the receiving
+application, it will fall back to the storage type.
 
 Parameterized extension type
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -187,7 +168,7 @@ of the given frequency since 1970.
             # attributes need to be set first before calling
             # super init (as that calls serialize)
             self._freq = freq
-            pa.ExtensionType.__init__(self, pa.int64(), 'my_package.period')
+            super().__init__(pa.int64(), 'my_package.period')
 
         @property
         def freq(self):
@@ -198,7 +179,7 @@ of the given frequency since 1970.
 
         @classmethod
         def __arrow_ext_deserialize__(cls, storage_type, serialized):
-            # return an instance of this subclass given the serialized
+            # Return an instance of this subclass given the serialized
             # metadata.
             serialized = serialized.decode()
             assert serialized.startswith("freq=")
@@ -209,31 +190,10 @@ Here, we ensure to store all information in the serialized metadata that is
 needed to reconstruct the instance (in the ``__arrow_ext_deserialize__`` class
 method), in this case the frequency string.
 
-Note that, once created, the data type instance is considered immutable. If,
-in the example above, the ``freq`` parameter would change after instantiation,
-the reconstruction of the type instance after IPC will be incorrect.
+Note that, once created, the data type instance is considered immutable.
 In the example above, the ``freq`` parameter is therefore stored in a private
 attribute with a public read-only property to access it.
 
-Parameterized extension types are also possible using the pickle-based type
-subclassing :class:`PyExtensionType`. The equivalent example for the period
-data type from above would look like::
-
-    class PeriodType(pa.PyExtensionType):
-
-        def __init__(self, freq):
-            self._freq = freq
-            pa.PyExtensionType.__init__(self, pa.int64())
-
-        @property
-        def freq(self):
-            return self._freq
-
-        def __reduce__(self):
-            return PeriodType, (self.freq,)
-
-Also the storage type does not need to be fixed but can be parameterized.
-
 Custom extension array class
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -252,12 +212,16 @@ the data as a 2-D Numpy array ``(N, 3)`` without any copy::
             return self.storage.flatten().to_numpy().reshape((-1, 3))
 
 
-    class Point3DType(pa.PyExtensionType):
+    class Point3DType(pa.ExtensionType):
         def __init__(self):
-            pa.PyExtensionType.__init__(self, pa.list_(pa.float32(), 3))
+            super().__init__(pa.list_(pa.float32(), 3), "my_package.Point3DType")
 
-        def __reduce__(self):
-            return Point3DType, ()
+        def __arrow_ext_serialize__(self):
+            return b''
+
+        @classmethod
+        def __arrow_ext_deserialize__(cls, storage_type, serialized):
+            return Point3DType()
 
         def __arrow_ext_class__(self):
             return Point3DArray
@@ -289,11 +253,8 @@ The additional methods in the extension class are then available to the user::
 
 
 This array can be sent over IPC, received in another Python process, and the custom
-extension array class will be preserved (as long as the definitions of the classes above
-are available).
-
-The same ``__arrow_ext_class__`` specialization can be used with custom types defined
-by subclassing :class:`ExtensionType`.
+extension array class will be preserved (as long as the receiving process registers
+the extension type using :func:`register_extension_type` before reading the IPC data).
 
 Custom scalar conversion
 ~~~~~~~~~~~~~~~~~~~~~~~~
@@ -304,18 +265,24 @@ If you want scalars of your custom extension type to convert to a custom type wh
 For example, if we wanted the above example 3D point type to return a custom
 3D point class instead of a list, we would implement::
 
+    from collections import namedtuple
+
     Point3D = namedtuple("Point3D", ["x", "y", "z"])
 
     class Point3DScalar(pa.ExtensionScalar):
         def as_py(self) -> Point3D:
             return Point3D(*self.value.as_py())
 
-    class Point3DType(pa.PyExtensionType):
+    class Point3DType(pa.ExtensionType):
         def __init__(self):
-            pa.PyExtensionType.__init__(self, pa.list_(pa.float32(), 3))
+            super().__init__(pa.list_(pa.float32(), 3), "my_package.Point3DType")
 
-        def __reduce__(self):
-            return Point3DType, ()
+        def __arrow_ext_serialize__(self):
+            return b''
+
+        @classmethod
+        def __arrow_ext_deserialize__(cls, storage_type, serialized):
+            return Point3DType()
 
         def __arrow_ext_scalar_class__(self):
             return Point3DScalar
diff --git a/python/pyarrow/tests/test_cffi.py b/python/pyarrow/tests/test_cffi.py
index 55bab4359bf..a9c17cc100c 100644
--- a/python/pyarrow/tests/test_cffi.py
+++ b/python/pyarrow/tests/test_cffi.py
@@ -16,6 +16,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import contextlib
 import ctypes
 import gc
 
@@ -51,18 +52,33 @@ def PyCapsule_IsValid(capsule, name):
     return ctypes.pythonapi.PyCapsule_IsValid(ctypes.py_object(capsule), name) == 1
 
 
-class ParamExtType(pa.PyExtensionType):
+@contextlib.contextmanager
+def registered_extension_type(ext_type):
+    pa.register_extension_type(ext_type)
+    try:
+        yield
+    finally:
+        pa.unregister_extension_type(ext_type.extension_name)
+
+
+class ParamExtType(pa.ExtensionType):
 
     def __init__(self, width):
         self._width = width
-        pa.PyExtensionType.__init__(self, pa.binary(width))
+        super().__init__(pa.binary(width),
+                         "pyarrow.tests.test_cffi.ParamExtType")
 
     @property
     def width(self):
         return self._width
 
-    def __reduce__(self):
-        return ParamExtType, (self.width,)
+    def __arrow_ext_serialize__(self):
+        return str(self.width).encode()
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        width = int(serialized.decode())
+        return cls(width)
 
 
 def make_schema():
@@ -75,6 +91,12 @@ def make_extension_schema():
                      metadata={b'key1': b'value1'})
 
 
+def make_extension_storage_schema():
+    # Should be kept in sync with make_extension_schema
+    return pa.schema([('ext', ParamExtType(3).storage_type)],
+                     metadata={b'key1': b'value1'})
+
+
 def make_batch():
     return pa.record_batch([[[1], [2, 42]]], make_schema())
 
@@ -204,7 +226,10 @@ def test_export_import_array():
         pa.Array._import_from_c(ptr_array, ptr_schema)
 
 
-def check_export_import_schema(schema_factory):
+def check_export_import_schema(schema_factory, expected_schema_factory=None):
+    if expected_schema_factory is None:
+        expected_schema_factory = schema_factory
+
     c_schema = ffi.new("struct ArrowSchema*")
     ptr_schema = int(ffi.cast("uintptr_t", c_schema))
 
@@ -215,7 +240,7 @@ def check_export_import_schema(schema_factory):
     assert pa.total_allocated_bytes() > old_allocated
     # Delete and recreate C++ object from exported pointer
     schema_new = pa.Schema._import_from_c(ptr_schema)
-    assert schema_new == schema_factory()
+    assert schema_new == expected_schema_factory()
     assert pa.total_allocated_bytes() == old_allocated
     del schema_new
     assert pa.total_allocated_bytes() == old_allocated
@@ -240,7 +265,13 @@ def test_export_import_schema():
 
 @needs_cffi
 def test_export_import_schema_with_extension():
-    check_export_import_schema(make_extension_schema)
+    # Extension type is unregistered => the storage type is imported
+    check_export_import_schema(make_extension_schema,
+                               make_extension_storage_schema)
+
+    # Extension type is registered => the extension type is imported
+    with registered_extension_type(ParamExtType(1)):
+        check_export_import_schema(make_extension_schema)
 
 
 @needs_cffi
@@ -319,7 +350,8 @@ def test_export_import_batch():
 
 @needs_cffi
 def test_export_import_batch_with_extension():
-    check_export_import_batch(make_extension_batch)
+    with registered_extension_type(ParamExtType(1)):
+        check_export_import_batch(make_extension_batch)
 
 
 def _export_import_batch_reader(ptr_stream, reader_factory):
diff --git a/python/pyarrow/tests/test_extension_type.py b/python/pyarrow/tests/test_extension_type.py
index ce575d984e4..a88e20eefe0 100644
--- a/python/pyarrow/tests/test_extension_type.py
+++ b/python/pyarrow/tests/test_extension_type.py
@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import contextlib
 import os
 import shutil
 import subprocess
@@ -29,31 +30,69 @@
 import pytest
 
 
-class TinyIntType(pa.PyExtensionType):
+@contextlib.contextmanager
+def registered_extension_type(ext_type):
+    pa.register_extension_type(ext_type)
+    try:
+        yield
+    finally:
+        pa.unregister_extension_type(ext_type.extension_name)
+
+
+@contextlib.contextmanager
+def enabled_auto_load():
+    pa.PyExtensionType.set_auto_load(True)
+    try:
+        yield
+    finally:
+        pa.PyExtensionType.set_auto_load(False)
+
+
+class TinyIntType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.int8())
+        super().__init__(pa.int8(), 'pyarrow.tests.TinyIntType')
 
-    def __reduce__(self):
-        return TinyIntType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        assert storage_type == pa.int8()
+        return cls()
 
 
-class IntegerType(pa.PyExtensionType):
+class IntegerType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.int64())
+        super().__init__(pa.int64(), 'pyarrow.tests.IntegerType')
 
-    def __reduce__(self):
-        return IntegerType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        assert storage_type == pa.int64()
+        return cls()
 
 
-class IntegerEmbeddedType(pa.PyExtensionType):
+class IntegerEmbeddedType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, IntegerType())
+        super().__init__(IntegerType(), 'pyarrow.tests.IntegerType')
 
-    def __reduce__(self):
-        return IntegerEmbeddedType, ()
+    def __arrow_ext_serialize__(self):
+        # XXX pa.BaseExtensionType should expose C++ serialization method
+        return self.storage_type.__arrow_ext_serialize__()
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        deserialized_storage_type = storage_type.__arrow_ext_deserialize__(
+            serialized)
+        assert deserialized_storage_type == storage_type
+        return cls()
 
 
 class UuidScalarType(pa.ExtensionScalar):
@@ -61,81 +100,125 @@ def as_py(self):
         return None if self.value is None else UUID(bytes=self.value.as_py())
 
 
-class UuidType(pa.PyExtensionType):
+class UuidType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.binary(16))
-
-    def __reduce__(self):
-        return UuidType, ()
+        super().__init__(pa.binary(16), 'pyarrow.tests.UuidType')
 
     def __arrow_ext_scalar_class__(self):
         return UuidScalarType
 
+    def __arrow_ext_serialize__(self):
+        return b''
 
-class UuidType2(pa.PyExtensionType):
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        return cls()
+
+
+class UuidType2(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.binary(16))
+        super().__init__(pa.binary(16), 'pyarrow.tests.UuidType2')
 
-    def __reduce__(self):
-        return UuidType2, ()
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        return cls()
 
 
-class LabelType(pa.PyExtensionType):
+class LabelType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.string())
+        super().__init__(pa.string(), 'pyarrow.tests.LabelType')
 
-    def __reduce__(self):
-        return LabelType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        return cls()
 
 
-class ParamExtType(pa.PyExtensionType):
+class ParamExtType(pa.ExtensionType):
 
     def __init__(self, width):
         self._width = width
-        pa.PyExtensionType.__init__(self, pa.binary(width))
+        super().__init__(pa.binary(width), 'pyarrow.tests.ParamExtType')
 
     @property
     def width(self):
         return self._width
 
-    def __reduce__(self):
-        return ParamExtType, (self.width,)
+    def __arrow_ext_serialize__(self):
+        return str(self._width).encode()
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        width = int(serialized.decode())
+        assert storage_type == pa.binary(width)
+        return cls(width)
 
 
-class MyStructType(pa.PyExtensionType):
+class MyStructType(pa.ExtensionType):
     storage_type = pa.struct([('left', pa.int64()),
                               ('right', pa.int64())])
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, self.storage_type)
+        super().__init__(self.storage_type, 'pyarrow.tests.MyStructType')
 
-    def __reduce__(self):
-        return MyStructType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
 
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        assert storage_type == cls.storage_type
+        return cls()
 
-class MyListType(pa.PyExtensionType):
+
+class MyListType(pa.ExtensionType):
 
     def __init__(self, storage_type):
-        pa.PyExtensionType.__init__(self, storage_type)
+        assert isinstance(storage_type, pa.ListType)
+        super().__init__(storage_type, 'pyarrow.tests.MyListType')
 
-    def __reduce__(self):
-        return MyListType, (self.storage_type,)
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        return cls(storage_type)
 
 
-class AnnotatedType(pa.PyExtensionType):
+class AnnotatedType(pa.ExtensionType):
     """
     Generic extension type that can store any storage type.
     """
 
     def __init__(self, storage_type, annotation):
         self.annotation = annotation
-        super().__init__(storage_type)
+        super().__init__(storage_type, 'pyarrow.tests.AnnotatedType')
+
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        return cls(storage_type)
+
+
+class LegacyIntType(pa.PyExtensionType):
+
+    def __init__(self):
+        pa.PyExtensionType.__init__(self, pa.int8())
 
     def __reduce__(self):
-        return AnnotatedType, (self.storage_type, self.annotation)
+        return LegacyIntType, ()
 
 
 def ipc_write_batch(batch):
@@ -153,12 +236,12 @@ def ipc_read_batch(buf):
 
 def test_ext_type_basics():
     ty = UuidType()
-    assert ty.extension_name == "arrow.py_extension_type"
+    assert ty.extension_name == "pyarrow.tests.UuidType"
 
 
 def test_ext_type_str():
     ty = IntegerType()
-    expected = "extension<arrow.py_extension_type<IntegerType>>"
+    expected = "extension<pyarrow.tests.IntegerType<IntegerType>>"
     assert str(ty) == expected
     assert pa.DataType.__str__(ty) == expected
 
@@ -223,7 +306,7 @@ def test_uuid_type_pickle(pickle_module):
         del ty
         ty = pickle_module.loads(ser)
         wr = weakref.ref(ty)
-        assert ty.extension_name == "arrow.py_extension_type"
+        assert ty.extension_name == "pyarrow.tests.UuidType"
         del ty
         assert wr() is None
 
@@ -571,9 +654,9 @@ def test_cast_between_extension_types():
     assert tiny_int_arr.type == TinyIntType()
 
     # Casting between extension types w/ different storage types not okay.
-    msg = ("Casting from 'extension<arrow.py_extension_type<TinyIntType>>' "
+    msg = ("Casting from 'extension<.*?<TinyIntType>>' "
            "to different extension type "
-           "'extension<arrow.py_extension_type<IntegerType>>' not permitted. "
+           "'extension<.*?<IntegerType>>' not permitted. "
            "One can first cast to the storage type, "
            "then to the extension type."
            )
@@ -660,53 +743,38 @@ def example_batch():
     return pa.RecordBatch.from_arrays([arr], ["exts"])
 
 
-def check_example_batch(batch):
+def check_example_batch(batch, *, expect_extension):
     arr = batch.column(0)
-    assert isinstance(arr, pa.ExtensionArray)
-    assert arr.type.storage_type == pa.binary(3)
-    assert arr.storage.to_pylist() == [b"foo", b"bar"]
+    if expect_extension:
+        assert isinstance(arr, pa.ExtensionArray)
+        assert arr.type.storage_type == pa.binary(3)
+        assert arr.storage.to_pylist() == [b"foo", b"bar"]
+    else:
+        assert arr.type == pa.binary(3)
+        assert arr.to_pylist() == [b"foo", b"bar"]
     return arr
 
 
-def test_ipc():
+def test_ipc_unregistered():
     batch = example_batch()
     buf = ipc_write_batch(batch)
     del batch
 
     batch = ipc_read_batch(buf)
-    arr = check_example_batch(batch)
-    assert arr.type == ParamExtType(3)
+    batch.validate(full=True)
+    check_example_batch(batch, expect_extension=False)
 
 
-def test_ipc_unknown_type():
-    batch = example_batch()
-    buf = ipc_write_batch(batch)
-    del batch
-
-    orig_type = ParamExtType
-    try:
-        # Simulate the original Python type being unavailable.
-        # Deserialization should not fail but return a placeholder type.
-        del globals()['ParamExtType']
+def test_ipc_registered():
+    with registered_extension_type(ParamExtType(1)):
+        batch = example_batch()
+        buf = ipc_write_batch(batch)
+        del batch
 
         batch = ipc_read_batch(buf)
-        arr = check_example_batch(batch)
-        assert isinstance(arr.type, pa.UnknownExtensionType)
-
-        # Can be serialized again
-        buf2 = ipc_write_batch(batch)
-        del batch, arr
-
-        batch = ipc_read_batch(buf2)
-        arr = check_example_batch(batch)
-        assert isinstance(arr.type, pa.UnknownExtensionType)
-    finally:
-        globals()['ParamExtType'] = orig_type
-
-    # Deserialize again with the type restored
-    batch = ipc_read_batch(buf2)
-    arr = check_example_batch(batch)
-    assert arr.type == ParamExtType(3)
+        batch.validate(full=True)
+        arr = check_example_batch(batch, expect_extension=True)
+        assert arr.type == ParamExtType(3)
 
 
 class PeriodArray(pa.ExtensionArray):
@@ -930,6 +998,7 @@ def test_parquet_period(tmpdir, registered_period_type):
 
     # When reading in, properly create extension type if it is registered
     result = pq.read_table(filename)
+    result.validate(full=True)
     assert result.schema.field("ext").type == period_type
     assert result.schema.field("ext").metadata == {}
     # Get the exact array class defined by the registered type.
@@ -939,6 +1008,7 @@ def test_parquet_period(tmpdir, registered_period_type):
     # When the type is not registered, read in as storage type
     pa.unregister_extension_type(period_type.extension_name)
     result = pq.read_table(filename)
+    result.validate(full=True)
     assert result.schema.field("ext").type == pa.int64()
     # The extension metadata is present for roundtripping.
     assert result.schema.field("ext").metadata == {
@@ -967,13 +1037,28 @@ def test_parquet_extension_with_nested_storage(tmpdir):
     filename = tmpdir / 'nested_extension_storage.parquet'
     pq.write_table(orig_table, filename)
 
+    # Unregistered
     table = pq.read_table(filename)
-    assert table.column('structs').type == mystruct_array.type
-    assert table.column('lists').type == mylist_array.type
-    assert table == orig_table
-
-    with pytest.raises(pa.ArrowInvalid, match='without all of its fields'):
-        pq.ParquetFile(filename).read(columns=['structs.left'])
+    table.validate(full=True)
+    assert table.column('structs').type == struct_array.type
+    assert table.column('structs').combine_chunks() == struct_array
+    assert table.column('lists').type == list_array.type
+    assert table.column('lists').combine_chunks() == list_array
+
+    # Registered
+    with registered_extension_type(mystruct_array.type):
+        with registered_extension_type(mylist_array.type):
+            table = pq.read_table(filename)
+            table.validate(full=True)
+            assert table.column('structs').type == mystruct_array.type
+            assert table.column('lists').type == mylist_array.type
+            assert table == orig_table
+
+            # Cannot select a subfield of an extension type with
+            # a struct storage type.
+            with pytest.raises(pa.ArrowInvalid,
+                               match='without all of its fields'):
+                pq.ParquetFile(filename).read(columns=['structs.left'])
 
 
 @pytest.mark.parquet
@@ -995,8 +1080,14 @@ def test_parquet_nested_extension(tmpdir):
     pq.write_table(orig_table, filename)
 
     table = pq.read_table(filename)
-    assert table.column(0).type == struct_array.type
-    assert table == orig_table
+    table.validate(full=True)
+    assert table.column(0).type == pa.struct({'ints': pa.int64(),
+                                              'exts': pa.int64()})
+    with registered_extension_type(ext_type):
+        table = pq.read_table(filename)
+        table.validate(full=True)
+        assert table.column(0).type == struct_array.type
+        assert table == orig_table
 
     # List of extensions
     list_array = pa.ListArray.from_arrays([0, 1, None, 3], ext_array)
@@ -1006,8 +1097,13 @@ def test_parquet_nested_extension(tmpdir):
     pq.write_table(orig_table, filename)
 
     table = pq.read_table(filename)
-    assert table.column(0).type == list_array.type
-    assert table == orig_table
+    table.validate(full=True)
+    assert table.column(0).type == pa.list_(pa.int64())
+    with registered_extension_type(ext_type):
+        table = pq.read_table(filename)
+        table.validate(full=True)
+        assert table.column(0).type == list_array.type
+        assert table == orig_table
 
     # Large list of extensions
     list_array = pa.LargeListArray.from_arrays([0, 1, None, 3], ext_array)
@@ -1017,8 +1113,13 @@ def test_parquet_nested_extension(tmpdir):
     pq.write_table(orig_table, filename)
 
     table = pq.read_table(filename)
-    assert table.column(0).type == list_array.type
-    assert table == orig_table
+    table.validate(full=True)
+    assert table.column(0).type == pa.large_list(pa.int64())
+    with registered_extension_type(ext_type):
+        table = pq.read_table(filename)
+        table.validate(full=True)
+        assert table.column(0).type == list_array.type
+        assert table == orig_table
 
 
 @pytest.mark.parquet
@@ -1040,8 +1141,12 @@ def test_parquet_extension_nested_in_extension(tmpdir):
     pq.write_table(orig_table, filename)
 
     table = pq.read_table(filename)
-    assert table.column(0).type == mylist_array.type
-    assert table == orig_table
+    assert table.column(0).type == pa.list_(pa.int64())
+    with registered_extension_type(mylist_array.type):
+        with registered_extension_type(inner_ext_array.type):
+            table = pq.read_table(filename)
+            assert table.column(0).type == mylist_array.type
+            assert table == orig_table
 
 
 def test_to_numpy():
@@ -1370,3 +1475,25 @@ def test_tensor_type_is_picklable(pickle_module):
 def test_tensor_type_str(tensor_type, text):
     tensor_type_str = tensor_type.__str__()
     assert text in tensor_type_str
+
+
+def test_legacy_int_type():
+    with pytest.warns(FutureWarning, match="PyExtensionType is deprecated"):
+        ext_ty = LegacyIntType()
+    arr = pa.array([1, 2, 3], type=ext_ty.storage_type)
+    ext_arr = pa.ExtensionArray.from_storage(ext_ty, arr)
+    batch = pa.RecordBatch.from_arrays([ext_arr], names=['ext'])
+    buf = ipc_write_batch(batch)
+
+    with pytest.warns(
+            RuntimeWarning,
+            match="pickle-based deserialization of pyarrow.PyExtensionType "
+                  "subclasses is disabled by default"):
+        batch = ipc_read_batch(buf)
+        assert isinstance(batch.column(0).type, pa.UnknownExtensionType)
+
+    with enabled_auto_load():
+        with pytest.warns(FutureWarning, match="PyExtensionType is deprecated"):
+            batch = ipc_read_batch(buf)
+            assert isinstance(batch.column(0).type, LegacyIntType)
+            assert batch.column(0) == ext_arr
diff --git a/python/pyarrow/tests/test_pandas.py b/python/pyarrow/tests/test_pandas.py
index 62a9443953a..10eb9315920 100644
--- a/python/pyarrow/tests/test_pandas.py
+++ b/python/pyarrow/tests/test_pandas.py
@@ -4096,13 +4096,20 @@ def test_array_protocol():
     assert result.equals(expected2)
 
 
-class DummyExtensionType(pa.PyExtensionType):
+class DummyExtensionType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.int64())
+        super().__init__(pa.int64(),
+                         'pyarrow.tests.test_pandas.DummyExtensionType')
 
-    def __reduce__(self):
-        return DummyExtensionType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        assert storage_type == pa.int64()
+        return cls()
 
 
 def PandasArray__arrow_array__(self, type=None):
@@ -4198,13 +4205,14 @@ def test_convert_to_extension_array(monkeypatch):
     assert not isinstance(_get_mgr(result).blocks[0], _int.ExtensionBlock)
 
 
-class MyCustomIntegerType(pa.PyExtensionType):
+class MyCustomIntegerType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.int64())
+        super().__init__(pa.int64(),
+                         'pyarrow.tests.test_pandas.MyCustomIntegerType')
 
-    def __reduce__(self):
-        return MyCustomIntegerType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
 
     def to_pandas_dtype(self):
         return pd.Int64Dtype()
diff --git a/python/pyarrow/types.pxi b/python/pyarrow/types.pxi
index d394b803e7f..a0ddf09d694 100644
--- a/python/pyarrow/types.pxi
+++ b/python/pyarrow/types.pxi
@@ -1437,7 +1437,10 @@ cdef class ExtensionType(BaseExtensionType):
     Parameters
     ----------
     storage_type : DataType
+        The underlying storage type for the extension type.
     extension_name : str
+        A unique name distinguishing this extension type. The name will be
+        used when deserializing IPC data.
 
     Examples
     --------
@@ -1671,60 +1674,22 @@ cdef class FixedShapeTensorType(BaseExtensionType):
                                     self.dim_names, self.permutation)
 
 
+_py_extension_type_auto_load = False
+
+
 cdef class PyExtensionType(ExtensionType):
     """
     Concrete base class for Python-defined extension types based on pickle
     for (de)serialization.
 
+    .. warning::
+       This class is deprecated and its deserialization is disabled by default.
+       :class:`ExtensionType` is recommended instead.
+
     Parameters
     ----------
     storage_type : DataType
         The storage type for which the extension is built.
-
-    Examples
-    --------
-    Define a UuidType extension type subclassing PyExtensionType:
-
-    >>> import pyarrow as pa
-    >>> class UuidType(pa.PyExtensionType):
-    ...     def __init__(self):
-    ...         pa.PyExtensionType.__init__(self, pa.binary(16))
-    ...     def __reduce__(self):
-    ...         return UuidType, ()
-    ...
-
-    Create an instance of UuidType extension type:
-
-    >>> uuid_type = UuidType() # doctest: +SKIP
-    >>> uuid_type # doctest: +SKIP
-    UuidType(FixedSizeBinaryType(fixed_size_binary[16]))
-
-    Inspect the extension type:
-
-    >>> uuid_type.extension_name # doctest: +SKIP
-    'arrow.py_extension_type'
-    >>> uuid_type.storage_type # doctest: +SKIP
-    FixedSizeBinaryType(fixed_size_binary[16])
-
-    Wrap an array as an extension array:
-
-    >>> import uuid
-    >>> storage_array = pa.array([uuid.uuid4().bytes for _ in range(4)],
-    ...                          pa.binary(16)) # doctest: +SKIP
-    >>> uuid_type.wrap_array(storage_array) # doctest: +SKIP
-    <pyarrow.lib.ExtensionArray object at ...>
-    [
-      ...
-    ]
-
-    Or do the same with creating an ExtensionArray:
-
-    >>> pa.ExtensionArray.from_storage(uuid_type,
-    ...                                storage_array) # doctest: +SKIP
-    <pyarrow.lib.ExtensionArray object at ...>
-    [
-      ...
-    ]
     """
 
     def __cinit__(self):
@@ -1733,6 +1698,12 @@ cdef class PyExtensionType(ExtensionType):
                             "PyExtensionType")
 
     def __init__(self, DataType storage_type):
+        warnings.warn(
+            "pyarrow.PyExtensionType is deprecated "
+            "and will refuse deserialization by default. "
+            "Instead, please derive from pyarrow.ExtensionType and implement "
+            "your own serialization mechanism.",
+            FutureWarning)
         ExtensionType.__init__(self, storage_type, "arrow.py_extension_type")
 
     def __reduce__(self):
@@ -1744,6 +1715,17 @@ cdef class PyExtensionType(ExtensionType):
 
     @classmethod
     def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        if not _py_extension_type_auto_load:
+            warnings.warn(
+                "pickle-based deserialization of pyarrow.PyExtensionType subclasses "
+                "is disabled by default; if you only ingest "
+                "trusted data files, you may re-enable this using "
+                "`pyarrow.PyExtensionType.set_auto_load(True)`.\n"
+                "In the future, Python-defined extension subclasses should "
+                "derive from pyarrow.ExtensionType (not pyarrow.PyExtensionType) "
+                "and implement their own serialization mechanism.\n",
+                RuntimeWarning)
+            return UnknownExtensionType(storage_type, serialized)
         try:
             ty = pickle.loads(serialized)
         except Exception:
@@ -1759,6 +1741,22 @@ cdef class PyExtensionType(ExtensionType):
                             .format(ty.storage_type, storage_type))
         return ty
 
+    # XXX Cython marks extension types as immutable, so cannot expose this
+    # as a writable class attribute.
+    @classmethod
+    def set_auto_load(cls, value):
+        """
+        Enable or disable auto-loading of serialized PyExtensionType instances.
+
+        Parameters
+        ----------
+        value : bool
+            Whether to enable auto-loading.
+        """
+        global _py_extension_type_auto_load
+        assert isinstance(value, bool)
+        _py_extension_type_auto_load = value
+
 
 cdef class UnknownExtensionType(PyExtensionType):
     """",
"url": "https://github.com/apache/arrow/commit/f14170976372436ec1d03a724d8d3f3925484ecf.patch"
}
] | null |
GHSA-69h6-vqxf-rc54
| null |
[
{
"commit_message": "[PATCH] Clean up pkg filter text before use. Fixes #12725 Also remove unnecessary echos of the value. src/usr/local/www/pkg.php | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/pfsense/pfsense/commit/5d82cce0d615a76b738798577a28a15803e59aeb.patch"
}
] | null |
|
GHSA-v9cx-qp5g-qchc
| null |
[
{
"commit_message": "[PATCH] Treat absolute paths as relative paths during extraction Tell libarchive to use the path for extraction that Ark uses internally. In addition, set the ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS flag to avoid that absolute paths are used by accident. (cherry picked from commit cc9ea9e89c1c679d398809e94f1217b1f73c4b48) autotests/kerfuffle/data/absolutepath.tar.xz | Bin 0 -> 280 bytes autotests/kerfuffle/extracttest.cpp | 4 ++++ plugins/libarchive/libarchiveplugin.cpp | 11 +++++++++-- 3 files changed, 13 insertions(+), 2 deletions(-) create mode 100644 autotests/kerfuffle/data/absolutepath.tar.xz",
"patch_text_b64": "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",
"url": "https://github.com/KDE/ark/commit/fe518d81b338941e0bf1c5ce5e75a9ab6de4bb58.patch"
}
] | null |
|
GHSA-phjp-gxh4-rcjp
| null |
[
{
"commit_message": "[PATCH] Add CSRF Token to Clear Table Upload/admin/modules/home/index.php | 204 ++++++++++++++-------------- 1 file changed, 102 insertions(+), 102 deletions(-)",
"patch_text_b64": "From 3deae701cdd89753cb6688302aee5b93a72bc58b Mon Sep 17 00:00:00 2001
From: 0xB9 <0xB9@protonmail.com>
Date: Mon, 14 May 2018 17:02:58 -0400
Subject: [PATCH] Add CSRF Token to Clear Table

---
 Upload/admin/modules/home/index.php | 204 ++++++++++++++--------------
 1 file changed, 102 insertions(+), 102 deletions(-)

diff --git a/Upload/admin/modules/home/index.php b/Upload/admin/modules/home/index.php
index 0935250..6b42ec0 100644
--- a/Upload/admin/modules/home/index.php
+++ b/Upload/admin/modules/home/index.php
@@ -29,41 +29,41 @@
 
 if ($mybb->input['action'] == "version_check") {
     $plugins->run_hooks("admin_home_version_check_start");
-    
+
     $current_version = rawurlencode($mybb->version_code);
-    
+
     $updated_cache = array(
         "last_check" => TIME_NOW
     );
-    
+
     require_once MYBB_ROOT . "inc/class_xml.php";
     $contents = fetch_remote_file("https://mybb.com/version_check.php");
-    
+
     if (!$contents) {
         flash_message($lang->error_communication, 'error');
         admin_redirect('index.php');
     }
-    
+
     $plugins->run_hooks("admin_home_version_check");
-    
+
     $page->add_breadcrumb_item($lang->version_check, "index.php?module=home-version_check");
     $page->output_header($lang->version_check);
     $page->output_nav_tabs($sub_tabs, 'version_check');
-    
+
     // We do this because there is some weird symbols that show up in the xml file for unknown reasons
     $pos = strpos($contents, "<");
     if ($pos > 1) {
         $contents = substr($contents, $pos);
     }
-    
+
     $pos = strpos(strrev($contents), ">");
     if ($pos > 1) {
         $contents = substr($contents, 0, (-1) * ($pos - 1));
     }
-    
+
     $parser = new XMLParser($contents);
     $tree   = $parser->get_tree();
-    
+
     $latest_code    = (int) $tree['mybb']['version_code']['value'];
     $latest_version = "<strong>" . htmlspecialchars_uni($tree['mybb']['latest_version']['value']) . "</strong> (" . $latest_code . ")";
     if ($latest_code > $mybb->version_code) {
@@ -74,50 +74,50 @@
     } else {
         $latest_version = "<span style=\"color: green;\">" . $latest_version . "</span>";
     }
-    
+
     if ($version_warn) {
         $page->output_error("<p><em>{$lang->error_out_of_date}</em> {$lang->update_forum}</p>");
     } else {
         $page->output_success("<p><em>{$lang->success_up_to_date}</em></p>");
     }
-    
+
     $table = new Table;
     $table->construct_header($lang->your_version);
     $table->construct_header($lang->latest_version);
-    
+
     $table->construct_cell("<strong>" . $mybb->version . "</strong> (" . $mybb->version_code . ")");
     $table->construct_cell($latest_version);
     $table->construct_row();
-    
+
     $table->output($lang->version_check);
-    
+
     require_once MYBB_ROOT . "inc/class_feedparser.php";
-    
+
     $feed_parser = new FeedParser();
     $feed_parser->parse_feed("http://feeds.feedburner.com/MyBBDevelopmentBlog");
-    
+
     $updated_cache['news'] = array();
-    
+
     require_once MYBB_ROOT . '/inc/class_parser.php';
     $post_parser = new postParser();
-    
+
     if ($feed_parser->error == '') {
         foreach ($feed_parser->items as $item) {
             if (!isset($updated_cache['news'][2])) {
                 $description = $item['description'];
                 $content     = $item['content'];
-                
+
                 $description = $post_parser->parse_message($description, array(
                     'allow_html' => true
                 ));
-                
+
                 $content = $post_parser->parse_message($content, array(
                     'allow_html' => true
                 ));
-                
+
                 $description = preg_replace('#<img(.*)/>#', '', $description);
                 $content     = preg_replace('#<img(.*)/>#', '', $content);
-                
+
                 $updated_cache['news'][] = array(
                     'title' => htmlspecialchars_uni($item['title']),
                     'description' => $description,
@@ -126,14 +126,14 @@
                     'dateline' => $item['date_timestamp']
                 );
             }
-            
+
             $stamp = '';
             if ($item['date_timestamp']) {
                 $stamp = my_date('relative', $item['date_timestamp']);
             }
-            
+
             $link = htmlspecialchars_uni($item['link']);
-            
+
             $table->construct_cell("<span style=\"font-size: 16px;\"><strong>" . htmlspecialchars_uni($item['title']) . "</strong></span><br /><br />{$content}<strong><span style=\"float: right;\">{$stamp}</span><br /><br /><a href=\"{$link}\" target=\"_blank\" rel=\"noopener\">&raquo; {$lang->read_more}</a></strong>");
             $table->construct_row();
         }
@@ -141,137 +141,137 @@
         $table->construct_cell("{$lang->error_fetch_news} <!-- error code: {$feed_parser->error} -->");
         $table->construct_row();
     }
-    
+
     $cache->update("update_check", $updated_cache);
-    
+
     $table->output($lang->latest_mybb_announcements);
     $page->output_footer();
 } elseif (!$mybb->input['action']) {
     $plugins->run_hooks("admin_home_index_start");
-    
+
     //    if($mybb->request_method == "post" && isset($mybb->input['adminnotes']))
     //    {
     //        // Update Admin Notes cache
     //        $update_cache = array(
     //            "adminmessage" => $mybb->input['adminnotes']
     //        );
-    
+
     //        $cache->update("adminnotes", $update_cache);
-    
+
     //        $plugins->run_hooks("admin_home_index_start_begin");
-    
+
     //        flash_message($lang->success_notes_updated, 'success');
     //        admin_redirect("index.php");
     //    }
-    
+
     $page->add_breadcrumb_item($lang->dashboard);
     $page->output_header($lang->dashboard);
-    
+
     $sub_tabs['dashboard'] = array(
         'title' => $lang->dashboard,
         'link' => "index.php",
         'description' => $lang->dashboard_description
     );
-    
+
     $page->output_nav_tabs($sub_tabs, 'dashboard');
-    
+
     // Load stats cache
     $stats = $cache->read("stats");
-    
+
     $serverload = get_server_load();
-    
+
     // Get the number of users
     $query = $db->simple_select("users", "COUNT(uid) AS numusers");
     $users = my_number_format($db->fetch_field($query, "numusers"));
-    
+
     // Get the number of users awaiting validation
     $awaitingusers = $cache->read('awaitingactivation');
-    
+
     if (!empty($awaitingusers['users'])) {
         $awaitingusers = (int) $awaitingusers['users'];
     } else {
         $awaitingusers = 0;
     }
-    
+
     if ($awaitingusers < 1) {
         $awaitingusers = 0;
     } else {
         $awaitingusers = my_number_format($awaitingusers);
     }
-    
+
     // Get the number of new users for today
     $timecut  = TIME_NOW - 86400;
     $query    = $db->simple_select("users", "COUNT(uid) AS newusers", "regdate > '$timecut'");
     $newusers = my_number_format($db->fetch_field($query, "newusers"));
-    
+
     // Get the number of active users today
     $query       = $db->simple_select("users", "COUNT(uid) AS activeusers", "lastvisit > '$timecut'");
     $activeusers = my_number_format($db->fetch_field($query, "activeusers"));
-    
+
     // Get the number of threads
     $threads = my_number_format($stats['numthreads']);
-    
+
     // Get the number of unapproved threads
     $unapproved_threads = my_number_format($stats['numunapprovedthreads']);
-    
+
     // Get the number of new threads for today
     $query      = $db->simple_select("threads", "COUNT(*) AS newthreads", "dateline > '$timecut' AND visible='1' AND closed NOT LIKE 'moved|%'");
     $newthreads = my_number_format($db->fetch_field($query, "newthreads"));
-    
+
     // Get the number of posts
     $posts = my_number_format($stats['numposts']);
-    
+
     // Get the number of unapproved posts
     if ($stats['numunapprovedposts'] < 0) {
         $stats['numunapprovedposts'] = 0;
     }
-    
+
     $unapproved_posts = my_number_format($stats['numunapprovedposts']);
-    
+
     // Get the number of new posts for today
     $query    = $db->simple_select("posts", "COUNT(*) AS newposts", "dateline > '$timecut' AND visible='1'");
     $newposts = my_number_format($db->fetch_field($query, "newposts"));
-    
+
     // Get the number of reported post
     $query          = $db->simple_select("reportedcontent", "COUNT(*) AS reported_posts", "type = 'post' OR type = ''");
     $reported_posts = my_number_format($db->fetch_field($query, "reported_posts"));
-    
+
     // If report medium is MCP...
     if ($mybb->settings['reportmethod'] == "db") {
         // Get the number of reported posts that haven't been marked as read yet
         $query              = $db->simple_select("reportedcontent", "COUNT(*) AS new_reported_posts", "reportstatus='0' AND (type = 'post' OR type = '')");
         $new_reported_posts = my_number_format($db->fetch_field($query, "new_reported_posts"));
     }
-    
+
     // Get the number and total file size of attachments
     $query                = $db->simple_select("attachments", "COUNT(*) AS numattachs, SUM(filesize) as spaceused", "visible='1' AND pid > '0'");
     $attachs              = $db->fetch_array($query);
     $attachs['spaceused'] = get_friendly_size($attachs['spaceused']);
     $approved_attachs     = my_number_format($attachs['numattachs']);
-    
+
     // Get the number of unapproved attachments
     $query              = $db->simple_select("attachments", "COUNT(*) AS numattachs", "visible='0' AND pid > '0'");
     $unapproved_attachs = my_number_format($db->fetch_field($query, "numattachs"));
-    
+
     // Fetch the last time an update check was run
     $update_check = $cache->read("update_check");
-    
+
     // If last update check was greater than two weeks ago (14 days) show an alert
     if (isset($update_check['last_check']) && $update_check['last_check'] <= TIME_NOW - 60 * 60 * 24 * 14) {
         $lang->last_update_check_two_weeks = $lang->sprintf($lang->last_update_check_two_weeks, "index.php?module=home&amp;action=version_check");
         $page->output_error("<p>{$lang->last_update_check_two_weeks}</p>");
     }
-    
+
     // If the update check contains information about a newer version, show an alert
     if (isset($update_check['latest_version_code']) && $update_check['latest_version_code'] > $mybb->version_code) {
         $lang->new_version_available = $lang->sprintf($lang->new_version_available, "MyBB {$mybb->version}", "<a href=\"https://mybb.com/download\" target=\"_blank\" rel=\"noopener\">MyBB {$update_check['latest_version']}</a>");
         $page->output_error("<p><em>{$lang->new_version_available}</em></p>");
     }
-    
+
     $plugins->run_hooks("admin_home_index_output_message");
-    
+
     $adminmessage = $cache->read("adminnotes");
-    
+
     $table = new Table;
     $table->construct_header($lang->mybb_server_stats, array(
         "colspan" => 2
@@ -279,7 +279,7 @@
     $table->construct_header($lang->forum_stats, array(
         "colspan" => 2
     ));
-    
+
     $table->construct_cell("<strong>{$lang->mybb_version}</strong>", array(
         'width' => '25%'
     ));
@@ -293,7 +293,7 @@
         'width' => '25%'
     ));
     $table->construct_row();
-    
+
     $table->construct_cell("<strong>{$lang->php_version}</strong>", array(
         'width' => '25%'
     ));
@@ -313,7 +313,7 @@
         ));
     }
     $table->construct_row();
-    
+
     $table->construct_cell("<strong>{$lang->sql_engine}</strong>", array(
         'width' => '25%'
     ));
@@ -327,7 +327,7 @@
         'width' => '25%'
     ));
     $table->construct_row();
-    
+
     $table->construct_cell("<strong>{$lang->server_load}</strong>", array(
         'width' => '25%'
     ));
@@ -341,30 +341,30 @@
         'width' => '25%'
     ));
     $table->construct_row();
-    
+
     $table->output($lang->dashboard);
-    
+
     // Admin Notes Start
-    
+
     global $lang;
-    
+
     $lang->load("adminnotes");
-    
+
     $plugins->run_hooks("admin_home_index_start");
-    
+
     if (!$db->table_exists("adminnotes")) {
         if ($mybb->request_method == "post" && isset($mybb->input['adminnotes'])) {
-            
+
             // Update Admin Notes cache
-            
+
             $update_cache = array(
                 "adminmessage" => $mybb->input['adminnotes']
             );
-            
+
             $cache->update("adminnotes", $update_cache);
-            
+
             $plugins->run_hooks("admin_home_index_start_begin");
-            
+
             flash_message($lang->success_notes_updated, 'success');
             admin_redirect("index.php");
         }
@@ -377,29 +377,29 @@
             'style' => 'width: 99%; height: 200px;'
         )));
         $table->construct_row();
-        
+
         $table->output($lang->admin_notes);
-        
+
         $buttons[] = $form->generate_submit_button($lang->save_notes);
         $form->output_submit_wrapper($buttons);
-        
+
         $form->end();
         //        $page->output_footer();
-        
+
         echo '</div>
     <div class="float_left" style="width: 48%;">';
-        
+
         // Latest news widget
-        
+
         $table = new Table;
         $table->construct_header($lang->news_description);
-        
+
         if (!empty($update_check['news']) && is_array($update_check['news'])) {
             foreach ($update_check['news'] as $news_item) {
                 $posted = my_date('relative', $news_item['dateline']);
                 $table->construct_cell("<strong><a href=\"{$news_item['link']}\" target=\"_blank\" rel=\"noopener\">{$news_item['title']}</a></strong><br /><span class=\"smalltext\">{$posted}</span>");
                 $table->construct_row();
-                
+
                 $table->construct_cell($news_item['description']);
                 $table->construct_row();
             }
@@ -407,14 +407,14 @@
             $table->construct_cell($lang->no_announcements);
             $table->construct_row();
         }
-        
+
         $table->output($lang->latest_mybb_announcements);
         echo '</div>';
-        
+
         $page->output_footer();
-        
+
     } else {
-        if ($mybb->input['empty'] == "table" && $mybb->user['usergroup'] == 4) {
+        if ($mybb->input['empty'] == "table" && $mybb->user['usergroup'] == 4 && $mybb->input['my_post_key']) {
             $db->query("truncate " . TABLE_PREFIX . "adminnotes");
             flash_message("the notes were successfully removed!", 'success');
             admin_redirect("index.php");
@@ -425,7 +425,7 @@
                 'text' => $db->escape_string($mybb->input['adminnotes'])
             );
             $nid    = $db->insert_query("adminnotes", $update);
-            
+
             flash_message($lang->success_notes_updated, 'success');
             admin_redirect("index.php");
         }
@@ -435,7 +435,7 @@
         $quantity = $db->fetch_field($query, "notes");
         $page     = intval($mybb->input['page']);
         $perpage  = $mybb->settings['adminnotes_pagination'];
-        
+
         if ($page > 0) {
             $start = ($page - 1) * $perpage;
             $pages = $quantity / $perpage;
@@ -448,7 +448,7 @@
             $start = 0;
             $page  = 1;
         }
-        
+
         $profile_page = "index.php";
         $table        = new Table;
         $table->construct_header("User", array(
@@ -477,41 +477,41 @@
             'style' => 'width: 99%; height: 200px;'
         )));
         $table->construct_row();
-        
+
         echo "<div>";
         echo multipage($quantity, (int) $perpage, (int) $page, $profile_page);
         echo "</div><br />";
         $table->output($lang->admin_notes);
-        
+
         $buttons[] = $form->generate_submit_button($lang->save_notes);
         $form->output_submit_wrapper($buttons);
         $form->end();
-        
+
         echo "<br /><div align=\"right\">
         <table cellpadding=4 cellspacing=1 style=\"background:#F5F5F5;width:25%;margin: left;border: 1px solid #0F5C8E;border-radius:6px;\">
     <tr><td style=\"background: #026CB1 url(../images/thead.png) top left repeat-x;color: #ffffff;border-radius:6px 6px 0px 0px;\"><center><strong>" . $lang->adminnotes_option . "</strong></center></td></tr>
     <tr><td>
-    <a href='index.php?empty=table' onclick=\"return confirm('want to empty the table notes?');\"><strong>" . $lang->adminnotes_clear . "</strong></a>
+    <a href='index.php?empty=table&my_post_key={$mybb->post_code}' onclick=\"return confirm('want to empty the table notes?');\"><strong>" . $lang->adminnotes_clear . "</strong></a>
     </td></tr>
     </table>
     </div><br /><br />";
     }
-    
+
     // Admin Notes End
-    
+
     echo '</div><div class="float_left" style="width: 48%;">';
-    
+
     // Latest news widget
 
     $table = new Table;
     $table->construct_header($lang->news_description);
-    
+
     if (!empty($update_check['news']) && is_array($update_check['news'])) {
         foreach ($update_check['news'] as $news_item) {
             $posted = my_date('relative', $news_item['dateline']);
             $table->construct_cell("<strong><a href=\"{$news_item['link']}\" target=\"_blank\" rel=\"noopener\">{$news_item['title']}</a></strong><br /><span class=\"smalltext\">{$posted}</span>");
             $table->construct_row();
-            
+
             $table->construct_cell($news_item['description']);
             $table->construct_row();
         }
@@ -519,10 +519,10 @@
         $table->construct_cell($lang->no_announcements);
         $table->construct_row();
     }
-    
+
     $table->output($lang->latest_mybb_announcements);
     echo '</div>';
-    
+
     $page->output_footer();
 }
-?> 
\ No newline at end of file
+?>",
"url": "https://github.com/vintagedaddyo/MyBB_Plugin-adminnotes/commit/3deae701cdd89753cb6688302aee5b93a72bc58b.patch"
}
] | null |
|
CVE-2017-20182
|
Mobile Vikings Django AJAX Utilities Backslash pagination.js Pagination cross site scripting
|
A vulnerability was found in Mobile Vikings Django AJAX Utilities up to 1.2.1 and classified as problematic. This issue affects the function Pagination of the file django_ajax/static/ajax-utilities/js/pagination.js of the component Backslash Handler. The manipulation of the argument url leads to cross site scripting. The attack may be initiated remotely. The patch is named 329eb1dd1580ca1f9d4f95bc69939833226515c9. It is recommended to apply a patch to fix this issue. The associated identifier of this vulnerability is VDB-222611.
|
[
{
"commit_message": "[PATCH] Improve XSS protection Modern browsers treat the backslash as normal slashes when used in the URLs. So instead of using the hash value \"#page://google.com\", we can use \"#page:/\\google.com\" to bypasses the XSS protection django_ajax/static/ajax-utilities/js/pagination.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSAzMjllYjFkZDE1ODBjYTFmOWQ0Zjk1YmM2OTkzOTgzMzIyNjUxNWM5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBGcmVkZXJpayBWb29yZGVja2VycyA8ZnJlZGVyaWsudm9vcmRlY2tlcnNAZ21haWwuY29tPgpEYXRlOiBXZWQsIDI5IE5vdiAyMDE3IDE1OjUzOjQ2ICswMTAwClN1YmplY3Q6IFtQQVRDSF0gSW1wcm92ZSBYU1MgcHJvdGVjdGlvbgoKTW9kZXJuIGJyb3dzZXJzIHRyZWF0IHRoZSBiYWNrc2xhc2ggYXMgbm9ybWFsIHNsYXNoZXMgd2hlbiB1c2VkIGluIHRoZSBVUkxzLiBTbyBpbnN0ZWFkIG9mIHVzaW5nIHRoZSBoYXNoIHZhbHVlICIjcGFnZTovL2dvb2dsZS5jb20iLCB3ZSBjYW4gdXNlICIjcGFnZTovXGdvb2dsZS5jb20iIHRvIGJ5cGFzc2VzIHRoZSBYU1MgcHJvdGVjdGlvbgotLS0KIGRqYW5nb19hamF4L3N0YXRpYy9hamF4LXV0aWxpdGllcy9qcy9wYWdpbmF0aW9uLmpzIHwgMyArKy0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9kamFuZ29fYWpheC9zdGF0aWMvYWpheC11dGlsaXRpZXMvanMvcGFnaW5hdGlvbi5qcyBiL2RqYW5nb19hamF4L3N0YXRpYy9hamF4LXV0aWxpdGllcy9qcy9wYWdpbmF0aW9uLmpzCmluZGV4IGYyNmRiNWYuLmRiZWIyNjAgMTAwNjQ0Ci0tLSBhL2RqYW5nb19hamF4L3N0YXRpYy9hamF4LXV0aWxpdGllcy9qcy9wYWdpbmF0aW9uLmpzCisrKyBiL2RqYW5nb19hamF4L3N0YXRpYy9hamF4LXV0aWxpdGllcy9qcy9wYWdpbmF0aW9uLmpzCkBAIC01Miw4ICs1Miw5IEBAIHZhciBQYWdpbmF0aW9uID0gbmV3IGZ1bmN0aW9uKCkgewogCiAgICAgICAgICAgICBmdW5jdGlvbiBhamF4KHVybCwgaGFuZGxlcikgewogICAgICAgICAgICAgICAgIC8vIFVSTCBzaG91bGQgc3RhcnQgd2l0aCBhIHNsYXNoLCBidXQgY2Fubm90IHN0YXJ0IHdpdGggdHdvIHNsYXNoZXMuCisJCS8vIHdlIGNhbm5vdCBzdGFydCB3aXRoICIvXCIuIE1vZGVybiBicm93c2VycyBoYW5kbGUgYmFja3NsYXNoZXMgYXMgbm9ybWFsIHNsYXNoZXMuCiAgICAgICAgICAgICAgICAgLy8gKE90aGVyd2lzZSB3ZSBoYXZlIGFuIFhTUyB2dWxuZXJhYmlsaXR5LikKLSAgICAgICAgICAgICAgICBpZiAodXJsWzBdICE9ICcvJyB8fCB1cmxbMV0gPT0gJy8nKQorICAgICAgICAgICAgICAgIGlmICh1cmxbMF0gIT0gJy8nIHx8IHVybFsxXSA9PSAnLycgfHwgdXJsLnN0YXJ0c1dpdGgoIi9cXCIpCiAgICAgICAgICAgICAgICAgICAgIHVybCA9ICgnJytsb2NhdGlvbikucmVwbGFjZSggL1sjXD9dLiovLCAnJykgKyB1cmw7CiAKICAgICAgICAgICAgICAgICAvLyBBcHBlbmQgJ3hocicgdG8gbWFrZSBzdXJlIGFsbCBjb250ZW50IGlzIGxvYWRlZC4=",
"url": "https://github.com/mvpoland/django-ajax-utilities/commit/329eb1dd1580ca1f9d4f95bc69939833226515c9.patch"
}
] |
CWE-79 Cross Site Scripting
|
CVE-2013-4587
|
Array index error in the kvm_vm_ioctl_create_vcpu function in virt/kvm/kvm_main.c in the KVM subsystem in the Linux kernel through 3.12.5 allows local users to gain privileges via a large id value.
|
[
{
"commit_message": "[PATCH] KVM: Improve create VCPU parameter (CVE-2013-4587) In multiple functions the vcpu_id is used as an offset into a bitfield. Ag malicious user could specify a vcpu_id greater than 255 in order to set or clear bits in kernel memory. This could be used to elevate priveges in the kernel. This patch verifies that the vcpu_id provided is less than 255. The api documentation already specifies that the vcpu_id must be less than max_vcpus, but this is currently not checked. Reported-by: Andrew Honig <ahonig@google.com> Cc: stable@vger.kernel.org Signed-off-by: Andrew Honig <ahonig@google.com> Signed-off-by: Paolo Bonzini <pbonzini@redhat.com> virt/kvm/kvm_main.c | 3 +++ 1 file changed, 3 insertions(+)",
"patch_text_b64": "RnJvbSAzMzhjN2RiYWRkMjY3MTE4OWNlYzdmYWY2NGM4NGQwMTA3MWIzZjk2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmR5IEhvbmlnIDxhaG9uaWdAZ29vZ2xlLmNvbT4KRGF0ZTogTW9uLCAxOCBOb3YgMjAxMyAxNjowOToyMiAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEtWTTogSW1wcm92ZSBjcmVhdGUgVkNQVSBwYXJhbWV0ZXIgKENWRS0yMDEzLTQ1ODcpCgpJbiBtdWx0aXBsZSBmdW5jdGlvbnMgdGhlIHZjcHVfaWQgaXMgdXNlZCBhcyBhbiBvZmZzZXQgaW50byBhIGJpdGZpZWxkLiAgQWcKbWFsaWNpb3VzIHVzZXIgY291bGQgc3BlY2lmeSBhIHZjcHVfaWQgZ3JlYXRlciB0aGFuIDI1NSBpbiBvcmRlciB0byBzZXQgb3IKY2xlYXIgYml0cyBpbiBrZXJuZWwgbWVtb3J5LiAgVGhpcyBjb3VsZCBiZSB1c2VkIHRvIGVsZXZhdGUgcHJpdmVnZXMgaW4gdGhlCmtlcm5lbC4gIFRoaXMgcGF0Y2ggdmVyaWZpZXMgdGhhdCB0aGUgdmNwdV9pZCBwcm92aWRlZCBpcyBsZXNzIHRoYW4gMjU1LgpUaGUgYXBpIGRvY3VtZW50YXRpb24gYWxyZWFkeSBzcGVjaWZpZXMgdGhhdCB0aGUgdmNwdV9pZCBtdXN0IGJlIGxlc3MgdGhhbgptYXhfdmNwdXMsIGJ1dCB0aGlzIGlzIGN1cnJlbnRseSBub3QgY2hlY2tlZC4KClJlcG9ydGVkLWJ5OiBBbmRyZXcgSG9uaWcgPGFob25pZ0Bnb29nbGUuY29tPgpDYzogc3RhYmxlQHZnZXIua2VybmVsLm9yZwpTaWduZWQtb2ZmLWJ5OiBBbmRyZXcgSG9uaWcgPGFob25pZ0Bnb29nbGUuY29tPgpTaWduZWQtb2ZmLWJ5OiBQYW9sbyBCb256aW5pIDxwYm9uemluaUByZWRoYXQuY29tPgotLS0KIHZpcnQva3ZtL2t2bV9tYWluLmMgfCAzICsrKwogMSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL3ZpcnQva3ZtL2t2bV9tYWluLmMgYi92aXJ0L2t2bS9rdm1fbWFpbi5jCmluZGV4IGEwYWE4NGI1OTQxYWM5Li40ZjU4OGJjOTQxODYxYiAxMDA2NDQKLS0tIGEvdmlydC9rdm0va3ZtX21haW4uYworKysgYi92aXJ0L2t2bS9rdm1fbWFpbi5jCkBAIC0xODk4LDYgKzE4OTgsOSBAQCBzdGF0aWMgaW50IGt2bV92bV9pb2N0bF9jcmVhdGVfdmNwdShzdHJ1Y3Qga3ZtICprdm0sIHUzMiBpZCkKIAlpbnQgcjsKIAlzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsICp2OwogCisJaWYgKGlkID49IEtWTV9NQVhfVkNQVVMpCisJCXJldHVybiAtRUlOVkFMOworCiAJdmNwdSA9IGt2bV9hcmNoX3ZjcHVfY3JlYXRlKGt2bSwgaWQpOwogCWlmIChJU19FUlIodmNwdSkpCiAJCXJldHVybiBQVFJfRVJSKHZjcHUpOw==",
"url": "https://github.com/torvalds/linux/commit/338c7dbadd2671189cec7faf64c84d01071b3f96.patch"
}
] |
n/a
|
|
GHSA-v75g-77vf-6jjq
|
Para Server Logs Sensitive Information
| null |
[
{
"commit_message": "[PATCH] removed logging of root app secret when initializing Para .../main/java/com/erudika/para/server/utils/HealthUtils.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)",
"patch_text_b64": "RnJvbSAxZThhODk1NTg1NDI4NTRiYjA2ODNhYjIzNGM0NDI5YWQ5M2IwODM1IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbGV4IEJvZ2Rhbm92c2tpIDxhbGV4QGVydWRpa2EuY29tPgpEYXRlOiBUaHUsIDI5IE1heSAyMDI1IDEzOjU1OjEzICswMzAwClN1YmplY3Q6IFtQQVRDSF0gcmVtb3ZlZCBsb2dnaW5nIG9mIHJvb3QgYXBwIHNlY3JldCB3aGVuIGluaXRpYWxpemluZyBQYXJhCgotLS0KIC4uLi9tYWluL2phdmEvY29tL2VydWRpa2EvcGFyYS9zZXJ2ZXIvdXRpbHMvSGVhbHRoVXRpbHMuamF2YSB8IDUgKystLS0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvcGFyYS1zZXJ2ZXIvc3JjL21haW4vamF2YS9jb20vZXJ1ZGlrYS9wYXJhL3NlcnZlci91dGlscy9IZWFsdGhVdGlscy5qYXZhIGIvcGFyYS1zZXJ2ZXIvc3JjL21haW4vamF2YS9jb20vZXJ1ZGlrYS9wYXJhL3NlcnZlci91dGlscy9IZWFsdGhVdGlscy5qYXZhCmluZGV4IDg2N2JiODQyLi4xYzdjYzNjNiAxMDA2NDQKLS0tIGEvcGFyYS1zZXJ2ZXIvc3JjL21haW4vamF2YS9jb20vZXJ1ZGlrYS9wYXJhL3NlcnZlci91dGlscy9IZWFsdGhVdGlscy5qYXZhCisrKyBiL3BhcmEtc2VydmVyL3NyYy9tYWluL2phdmEvY29tL2VydWRpa2EvcGFyYS9zZXJ2ZXIvdXRpbHMvSGVhbHRoVXRpbHMuamF2YQpAQCAtMTI5LDkgKzEyOSw4IEBAIHByaXZhdGUgdm9pZCBzYXZlQ29uZmlnRmlsZShTdHJpbmcgY29uZkZpbGUsIE1hcDxTdHJpbmcsIFN0cmluZz4gcm9vdEFwcENyZWRlbnRpCiAJCQkJdHJ5IHsKIAkJCQkJY29uZlN0cmluZyA9IGxvYWRDb25maWdGaWxlKGNvbmZGaWxlKTsKIAkJCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7Ci0JCQkJCWxvZ2dlci5pbmZvKCJJbml0aWFsaXplZCByb290IGFwcCB3aXRoIGFjY2VzcyBrZXkgJ3t9JyBhbmQgc2VjcmV0ICd7fScsICIKLQkJCQkJCQkrICJidXQgY291bGQgbm90IHdyaXRlIHRoZXNlIHRvIHt9LiIsCi0JCQkJCQkJcm9vdEFwcENyZWRlbnRpYWxzLmdldCgiYWNjZXNzS2V5IiksIHJvb3RBcHBDcmVkZW50aWFscy5nZXQoInNlY3JldEtleSIpLCBjb25mRmlsZSk7CisJCQkJCWxvZ2dlci5pbmZvKCJJbml0aWFsaXplZCByb290IGFwcCB3aXRoIGFjY2VzcyBrZXkgJ3t9JywgIgorCQkJCQkJCSsgImJ1dCBjb3VsZCBub3Qgd3JpdGUgdG8ge30uIiwgcm9vdEFwcENyZWRlbnRpYWxzLmdldCgiYWNjZXNzS2V5IiksIGNvbmZGaWxlKTsKIAkJCQl9CiAJCQkJU3RyaW5nIGFjY2Vzc0tleSA9ICJwYXJhLnJvb3RfYWNjZXNzX2tleSA9IFwiIiArIHJvb3RBcHBDcmVkZW50aWFscy5nZXQoImFjY2Vzc0tleSIpICsgIlwiIjsKIAkJCQlTdHJpbmcgc2VjcmV0S2V5ID0gInBhcmEucm9vdF9zZWNyZXRfa2V5ID0gXCIiICsgcm9vdEFwcENyZWRlbnRpYWxzLmdldCgic2VjcmV0S2V5IikgKyAiXCIiOw==",
"url": "https://github.com/Erudika/para/commit/1e8a89558542854bb0683ab234c4429ad93b0835.patch"
}
] | null |
CVE-2025-3933
|
Regular Expression Denial of Service (ReDoS) in huggingface/transformers
|
A Regular Expression Denial of Service (ReDoS) vulnerability was discovered in the Hugging Face Transformers library, specifically within the DonutProcessor class's `token2json()` method. This vulnerability affects versions 4.50.3 and earlier, and is fixed in version 4.52.1. The issue arises from the regex pattern `<s_(.*?)>` which can be exploited to cause excessive CPU consumption through crafted input strings due to catastrophic backtracking. This vulnerability can lead to service disruption, resource exhaustion, and potential API service vulnerabilities, impacting document processing tasks using the Donut model.
|
[
{
"commit_message": "[PATCH] Fix donut backtracking (#37788) * Fix donut backtracking * make fixup * Trigger tests * Remove old line * Update code * Fix reversed slice src/transformers/models/donut/processing_donut.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/huggingface/transformers/commit/ebbe9b12dd75b69f92100d684c47f923ee262a93.patch"
}
] |
CWE-1333 Inefficient Regular Expression Complexity
|
CVE-2025-25285
|
@octokit/endpoint has a Regular Expression in parse that Leads to ReDoS Vulnerability Due to Catastrophic Backtracking
|
@octokit/endpoint turns REST API endpoints into generic request options. Starting in version 4.1.0 and prior to version 10.1.3, by crafting specific `options` parameters, the `endpoint.parse(options)` call can be triggered, leading to a regular expression denial-of-service (ReDoS) attack. This causes the program to hang and results in high CPU utilization. The issue occurs in the `parse` function within the `parse.ts` file of the npm package `@octokit/endpoint`. Version 10.1.3 contains a patch for the issue.
|
[
{
"commit_message": "[PATCH] Merge commit from fork * Fix regular term vulnerability * add test to prevent future regressions * Fix the other regular term vulnerability * Trigger Build Co-authored-by: DayShift <113507098+ShiyuBanzhou@users.noreply.github.com> Co-authored-by: DayShift <2922897389@qq.com> src/parse.ts | 2 +- src/util/extract-url-variable-names.ts | 4 +- test/parse.test.ts | 90 ++++++++++++++++++++++++++ 3 files changed, 93 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/octokit/endpoint.js/commit/6c9c5be033c450d436efb37de41b6470c22f7db8.patch"
}
] |
CWE-1333: Inefficient Regular Expression Complexity
|
GHSA-mjvp-pgrg-jw5h
| null |
[
{
"commit_message": "[PATCH] Update tests to pick up upstream changes. core/php7.1Action/CHANGELOG.md | 4 + core/php7.1Action/router.php | 2 +- core/php7.2Action/CHANGELOG.md | 4 + core/php7.2Action/router.php | 2 +- tests/.pydevproject | 5 - .../Php7ActionContainerTests.scala | 157 +++++++++--------- 6 files changed, 87 insertions(+), 87 deletions(-) delete mode 100644 tests/.pydevproject",
"patch_text_b64": "From 6caf902f527250ee4b7b695929b628d560e0dad1 Mon Sep 17 00:00:00 2001
From: Rodric Rabbah <rodric@gmail.com>
Date: Sat, 7 Jul 2018 21:20:35 -0400
Subject: [PATCH] Update tests to pick up upstream changes.

---
 core/php7.1Action/CHANGELOG.md                |   4 +
 core/php7.1Action/router.php                  |   2 +-
 core/php7.2Action/CHANGELOG.md                |   4 +
 core/php7.2Action/router.php                  |   2 +-
 tests/.pydevproject                           |   5 -
 .../Php7ActionContainerTests.scala            | 157 +++++++++---------
 6 files changed, 87 insertions(+), 87 deletions(-)
 delete mode 100644 tests/.pydevproject

diff --git a/core/php7.1Action/CHANGELOG.md b/core/php7.1Action/CHANGELOG.md
index 57ff219c..8ad347b0 100644
--- a/core/php7.1Action/CHANGELOG.md
+++ b/core/php7.1Action/CHANGELOG.md
@@ -17,6 +17,10 @@
 #
 -->
 
+## 1.0.2
+Changes:
+  - Disallow re-initialization of function.
+
 ## 1.0.1
 
 - Change: Update PHP to 7.1.18
diff --git a/core/php7.1Action/router.php b/core/php7.1Action/router.php
index d023f1ac..76d8765e 100644
--- a/core/php7.1Action/router.php
+++ b/core/php7.1Action/router.php
@@ -108,7 +108,7 @@ function init() : array
     $binary = $data['binary'] ?? false;  // code is binary?
 
     if (!$code) {
-        throw new RuntimeException("No code to execute");
+        throw new RuntimeException("Missing main/no code to execute.");
     }
 
     if ($binary) {
diff --git a/core/php7.2Action/CHANGELOG.md b/core/php7.2Action/CHANGELOG.md
index 702b708d..4e4c56e1 100644
--- a/core/php7.2Action/CHANGELOG.md
+++ b/core/php7.2Action/CHANGELOG.md
@@ -17,6 +17,10 @@
 #
 -->
 
+## 1.0.1
+Changes:
+  - Disallow re-initialization of function.
+
 ## 1.0.0
 Initial release
 
diff --git a/core/php7.2Action/router.php b/core/php7.2Action/router.php
index 87456d16..bbf50e1c 100644
--- a/core/php7.2Action/router.php
+++ b/core/php7.2Action/router.php
@@ -139,7 +139,7 @@ function init() : array
     $binary = $data['binary'] ?? false;  // code is binary?
 
     if (!$code) {
-        throw new RuntimeException("No code to execute");
+        throw new RuntimeException("Missing main/no code to execute.");
     }
 
     if ($binary) {
diff --git a/tests/.pydevproject b/tests/.pydevproject
deleted file mode 100644
index 40e9f40a..00000000
--- a/tests/.pydevproject
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<?eclipse-pydev version="1.0"?><pydev_project>
-<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
-<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
-</pydev_project>
diff --git a/tests/src/test/scala/runtime/actionContainers/Php7ActionContainerTests.scala b/tests/src/test/scala/runtime/actionContainers/Php7ActionContainerTests.scala
index 000d0b03..5e5c9e79 100644
--- a/tests/src/test/scala/runtime/actionContainers/Php7ActionContainerTests.scala
+++ b/tests/src/test/scala/runtime/actionContainers/Php7ActionContainerTests.scala
@@ -27,11 +27,10 @@ import spray.json._
 
 @RunWith(classOf[JUnitRunner])
 abstract class Php7ActionContainerTests extends BasicActionRunnerTests with WskActorSystem {
-  // note: "out" will not be empty as the PHP web server outputs a message when
-  // it starts up
+  // note: "out" will not be empty as the PHP web server outputs a message when it starts up
   val enforceEmptyOutputStream = false
 
-  lazy val phpContainerImageName = "action-php-v7.x"
+  lazy val phpContainerImageName: String = ???
 
   override def withActionContainer(env: Map[String, String] = Map.empty)(code: ActionContainer => Unit) = {
     withContainer(phpContainerImageName, env)(code)
@@ -41,30 +40,56 @@ abstract class Php7ActionContainerTests extends BasicActionRunnerTests with WskA
 
   behavior of phpContainerImageName
 
-  testEcho(Seq {
-    (
-      "PHP",
+  override val testNoSourceOrExec = TestConfig("")
+
+  override val testNotReturningJson = {
+    TestConfig(
+      """
+       |<?php
+       |function main(array $args) {
+       |    return "not a json object";
+       |}
+     """.stripMargin,
+      enforceEmptyOutputStream = enforceEmptyOutputStream,
+      enforceEmptyErrorStream = false)
+  }
+
+  override val testInitCannotBeCalledMoreThanOnce = {
+    TestConfig(
       """
-          |<?php
-          |function main(array $args) : array {
-          |    echo 'hello stdout';
-          |    error_log('hello stderr');
-          |    return $args;
-          |}
-          """.stripMargin)
-  })
-
-  testNotReturningJson("""
         |<?php
-        |function main(array $args) {
-        |    return "not a json object";
+        |function main(array $args) : array {
+        |    return $args;
         |}
-        """.stripMargin)
+      """.stripMargin,
+      enforceEmptyOutputStream = enforceEmptyOutputStream)
+  }
 
-  testUnicode(Seq {
-    (
-      "PHP",
+  override val testEntryPointOtherThanMain = {
+    TestConfig(
       """
+        | <?php
+        | function niam(array $args) {
+        |     return $args;
+        | }
+      """.stripMargin,
+      main = "niam",
+      enforceEmptyOutputStream = enforceEmptyOutputStream)
+  }
+
+  override val testEcho = {
+    TestConfig("""
+                 |<?php
+                 |function main(array $args) : array {
+                 |    echo 'hello stdout';
+                 |    error_log('hello stderr');
+                 |    return $args;
+                 |}
+               """.stripMargin)
+  }
+
+  override val testUnicode = {
+    TestConfig("""
          |<?php
          |function main(array $args) : array {
          |    $str = $args['delimiter'] . " ☃ " . $args['delimiter'];
@@ -72,37 +97,37 @@ abstract class Php7ActionContainerTests extends BasicActionRunnerTests with WskA
          |    return  ["winter" => $str];
          |}
          """.stripMargin.trim)
-  })
+  }
 
-  testEnv(
-    Seq {
-      (
-        "PHP",
-        """
-         |<?php
-         |function main(array $args) : array {
-         |    return [
-         |       "env" => $_ENV,
-         |       "api_host" => $_ENV['__OW_API_HOST'],
-         |       "api_key" => $_ENV['__OW_API_KEY'],
-         |       "namespace" => $_ENV['__OW_NAMESPACE'],
-         |       "action_name" => $_ENV['__OW_ACTION_NAME'],
-         |       "activation_id" => $_ENV['__OW_ACTIVATION_ID'],
-         |       "deadline" => $_ENV['__OW_DEADLINE'],
-         |    ];
-         |}
-         """.stripMargin.trim)
-    },
-    enforceEmptyOutputStream)
-
-  testInitCannotBeCalledMoreThanOnce("""
-          |<?php
-          |function main(array $args) : array {
-          |    echo 'hello stdout';
-          |    error_log('hello stderr');
-          |    return $args;
-          |}
-          """.stripMargin)
+  override val testEnv = {
+    TestConfig(
+      """
+        |<?php
+        |function main(array $args) : array {
+        |    return [
+        |       "env" => $_ENV,
+        |       "api_host" => $_ENV['__OW_API_HOST'],
+        |       "api_key" => $_ENV['__OW_API_KEY'],
+        |       "namespace" => $_ENV['__OW_NAMESPACE'],
+        |       "action_name" => $_ENV['__OW_ACTION_NAME'],
+        |       "activation_id" => $_ENV['__OW_ACTIVATION_ID'],
+        |       "deadline" => $_ENV['__OW_DEADLINE'],
+        |    ];
+        |}
+      """.stripMargin.trim,
+      enforceEmptyOutputStream = enforceEmptyOutputStream)
+  }
+
+  override val testLargeInput = {
+    TestConfig("""
+                 |<?php
+                 |function main(array $args) : array {
+                 |    echo 'hello stdout';
+                 |    error_log('hello stderr');
+                 |    return $args;
+                 |}
+               """.stripMargin)
+  }
 
   it should "fail to initialize with bad code" in {
     val (out, err) = withPhp7Container { c =>
@@ -127,19 +152,6 @@ abstract class Php7ActionContainerTests extends BasicActionRunnerTests with WskA
     })
   }
 
-  it should "fail to initialize with no code" in {
-    val (out, err) = withPhp7Container { c =>
-      val code = ""
-
-      val (initCode, error) = c.init(initPayload(code))
-
-      initCode should not be (200)
-      error shouldBe a[Some[_]]
-      error.get shouldBe a[JsObject]
-      error.get.fields("error").toString should include("No code to execute")
-    }
-  }
-
   it should "return some error on action error" in {
     val (out, err) = withPhp7Container { c =>
       val code = """
@@ -467,21 +479,6 @@ abstract class Php7ActionContainerTests extends BasicActionRunnerTests with WskA
     })
   }
 
-  it should "support actions using non-default entry point" in {
-    val (out, err) = withPhp7Container { c =>
-      val code = """
-            | <?php
-            | function niam(array $args) {
-            |     return [result => "it works"];
-            | }
-            """.stripMargin
-
-      c.init(initPayload(code, main = "niam"))._1 should be(200)
-      val (runCode, runRes) = c.run(runPayload(JsObject()))
-      runRes.get.fields.get("result") shouldBe Some(JsString("it works"))
-    }
-  }
-
   it should "support zipped actions using non-default entry point" in {
     val srcs = Seq(Seq("index.php") -> """
                 | <?php",
"url": "https://github.com/apache/incubator-openwhisk-runtime-php/commit/6caf902f527250ee4b7b695929b628d560e0dad1.patch"
}
] | null |
|
CVE-2017-9224
|
An issue was discovered in Oniguruma 6.2.0, as used in Oniguruma-mod in Ruby through 2.4.1 and mbstring in PHP through 7.1.5. A stack out-of-bounds read occurs in match_at() during regular expression searching. A logical error involving order of validation and access in match_at() could result in an out-of-bounds read from a stack buffer.
|
[
{
"commit_message": "[PATCH] fix #57 : DATA_ENSURE() check must be before data access src/regexec.c | 5 ----- 1 file changed, 5 deletions(-)",
"patch_text_b64": "RnJvbSA2OTAzMTNhMDYxZjdhNGZhNjE0ZWM1Y2M4MzY4YjRmMjI4NGUwNTliIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiAiSy5Lb3Nha28iIDxrb3Nha29Ac29mbmVjLmNvLmpwPgpEYXRlOiBUdWUsIDIzIE1heSAyMDE3IDEwOjI4OjU4ICswOTAwClN1YmplY3Q6IFtQQVRDSF0gZml4ICM1NyA6IERBVEFfRU5TVVJFKCkgY2hlY2sgbXVzdCBiZSBiZWZvcmUgZGF0YSBhY2Nlc3MKCi0tLQogc3JjL3JlZ2V4ZWMuYyB8IDUgLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCA1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9yZWdleGVjLmMgYi9zcmMvcmVnZXhlYy5jCmluZGV4IDM1ZmVmMTE1Li5kNGU1NzdkOSAxMDA2NDQKLS0tIGEvc3JjL3JlZ2V4ZWMuYworKysgYi9zcmMvcmVnZXhlYy5jCkBAIC0xNDczLDE0ICsxNDczLDkgQEAgbWF0Y2hfYXQocmVnZXhfdCogcmVnLCBjb25zdCBVQ2hhciogc3RyLCBjb25zdCBVQ2hhciogZW5kLAogICAgICAgYnJlYWs7CiAKICAgICBjYXNlIE9QX0VYQUNUMTogIE1PUF9JTihPUF9FWEFDVDEpOwotI2lmIDAKICAgICAgIERBVEFfRU5TVVJFKDEpOwogICAgICAgaWYgKCpwICE9ICpzKSBnb3RvIGZhaWw7CiAgICAgICBwKys7IHMrKzsKLSNlbmRpZgotICAgICAgaWYgKCpwICE9ICpzKyspIGdvdG8gZmFpbDsKLSAgICAgIERBVEFfRU5TVVJFKDApOwotICAgICAgcCsrOwogICAgICAgTU9QX09VVDsKICAgICAgIGJyZWFrOw==",
"url": "https://github.com/kkos/oniguruma/commit/690313a061f7a4fa614ec5cc8368b4f2284e059b.patch"
}
] |
n/a
|
|
CVE-2015-1593
|
The stack randomization feature in the Linux kernel before 3.19.1 on 64-bit platforms uses incorrect data types for the results of bitwise left-shift operations, which makes it easier for attackers to bypass the ASLR protection mechanism by predicting the address of the top of the stack, related to the randomize_stack_top function in fs/binfmt_elf.c and the stack_maxrandom_size function in arch/x86/mm/mmap.c.
|
[
{
"commit_message": "[PATCH] x86, mm/ASLR: Fix stack randomization on 64-bit systems The issue is that the stack for processes is not properly randomized on 64 bit architectures due to an integer overflow. The affected function is randomize_stack_top() in file \"fs/binfmt_elf.c\": static unsigned long randomize_stack_top(unsigned long stack_top) { unsigned int random_variable = 0; if ((current->flags & PF_RANDOMIZE) && !(current->personality & ADDR_NO_RANDOMIZE)) { random_variable = get_random_int() & STACK_RND_MASK; random_variable <<= PAGE_SHIFT; } return PAGE_ALIGN(stack_top) + random_variable; return PAGE_ALIGN(stack_top) - random_variable; } Note that, it declares the \"random_variable\" variable as \"unsigned int\". Since the result of the shifting operation between STACK_RND_MASK (which is 0x3fffff on x86_64, 22 bits) and PAGE_SHIFT (which is 12 on x86_64): random_variable <<= PAGE_SHIFT; then the two leftmost bits are dropped when storing the result in the \"random_variable\". This variable shall be at least 34 bits long to hold the (22+12) result. These two dropped bits have an impact on the entropy of process stack. Concretely, the total stack entropy is reduced by four: from 2^28 to 2^30 (One fourth of expected entropy). This patch restores back the entropy by correcting the types involved in the operations in the functions randomize_stack_top() and stack_maxrandom_size(). The successful fix can be tested with: $ for i in `seq 1 10`; do cat /proc/self/maps | grep stack; done 7ffeda566000-7ffeda587000 rw-p 00000000 00:00 0 [stack] 7fff5a332000-7fff5a353000 rw-p 00000000 00:00 0 [stack] 7ffcdb7a1000-7ffcdb7c2000 rw-p 00000000 00:00 0 [stack] 7ffd5e2c4000-7ffd5e2e5000 rw-p 00000000 00:00 0 [stack] ... Once corrected, the leading bytes should be between 7ffc and 7fff, rather than always being 7fff. Signed-off-by: Hector Marco-Gisbert <hecmargi@upv.es> Signed-off-by: Ismael Ripoll <iripoll@upv.es> [ Rebased, fixed 80 char bugs, cleaned up commit message, added test example and CVE ] Signed-off-by: Kees Cook <keescook@chromium.org> Cc: <stable@vger.kernel.org> Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Andrew Morton <akpm@linux-foundation.org> Cc: Al Viro <viro@zeniv.linux.org.uk> Fixes: CVE-2015-1593 Link: http://lkml.kernel.org/r/20150214173350.GA18393@www.outflux.net Signed-off-by: Borislav Petkov <bp@suse.de> arch/x86/mm/mmap.c | 6 +++--- fs/binfmt_elf.c | 5 +++-- 2 files changed, 6 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/torvalds/linux/commit/4e7c22d447bb6d7e37bfe39ff658486ae78e8d77.patch"
}
] |
n/a
|
|
GHSA-rg7g-558c-fp2q
| null |
[
{
"commit_message": "[PATCH] Mandril: check decoded URI (fix #92) Signed-off-by: Eduardo Silva <eduardo@monkey.io> plugins/mandril/mandril.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSAxNWY3MmMxZWU1ZTBhZmFkMjAyMzJiZGYwZmNlY2FiOGQ2MmE1ZDg5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFZHVhcmRvIFNpbHZhIDxlZHVhcmRvQG1vbmtleS5pbz4KRGF0ZTogVHVlLCAyMCBNYXkgMjAxNCAxMToyMjoxOSAtMDYwMApTdWJqZWN0OiBbUEFUQ0hdIE1hbmRyaWw6IGNoZWNrIGRlY29kZWQgVVJJIChmaXggIzkyKQoKU2lnbmVkLW9mZi1ieTogRWR1YXJkbyBTaWx2YSA8ZWR1YXJkb0Btb25rZXkuaW8+Ci0tLQogcGx1Z2lucy9tYW5kcmlsL21hbmRyaWwuYyB8IDMgKystCiAxIGZpbGUgY2hhbmdlZCwgMiBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvcGx1Z2lucy9tYW5kcmlsL21hbmRyaWwuYyBiL3BsdWdpbnMvbWFuZHJpbC9tYW5kcmlsLmMKaW5kZXggOGRmMDg3YjNjLi44MjBmNDQxNmQgMTAwNjQ0Ci0tLSBhL3BsdWdpbnMvbWFuZHJpbC9tYW5kcmlsLmMKKysrIGIvcGx1Z2lucy9tYW5kcmlsL21hbmRyaWwuYwpAQCAtMzQ5LDcgKzM0OSw4IEBAIGludCBfbWtwX3N0YWdlXzMwKHN0cnVjdCBwbHVnaW4gKnAsCiAgICAgKHZvaWQpIGNzOwogCiAgICAgUExVR0lOX1RSQUNFKCJbRkQgJWldIE1hbmRyaWwgdmFsaWRhdGluZyBVUkwiLCBjcy0+c29ja2V0KTsKLSAgICBpZiAobWtfc2VjdXJpdHlfY2hlY2tfdXJsKHNyLT51cmkpIDwgMCkgeworCisgICAgaWYgKG1rX3NlY3VyaXR5X2NoZWNrX3VybChzci0+dXJpX3Byb2Nlc3NlZCkgPCAwKSB7CiAgICAgICAgIFBMVUdJTl9UUkFDRSgiW0ZEICVpXSBDbG9zZSBjb25uZWN0aW9uLCBibG9ja2VkIFVSTCIsIGNzLT5zb2NrZXQpOwogICAgICAgICBta19hcGktPmhlYWRlcl9zZXRfaHR0cF9zdGF0dXMoc3IsIE1LX0NMSUVOVF9GT1JCSURERU4pOwogICAgICAgICByZXR1cm4gTUtfUExVR0lOX1JFVF9DTE9TRV9DT05YOw==",
"url": "https://github.com/monkey/monkey/commit/15f72c1ee5e0afad20232bdf0fcecab8d62a5d89.patch"
}
] | null |
|
GHSA-v8r4-hc5w-5ww3
| null |
[
{
"commit_message": "[PATCH] patch 9.0.0101: invalid memory access in diff mode with \"dp\" and undo Problem: Invalid memory access in diff mode with \"dp\" and undo. Solution: Make sure the line number does not go below one. src/diff.c | 9 ++++++--- src/testdir/test_diffmode.vim | 14 ++++++++++++++ src/version.c | 2 ++ 3 files changed, 22 insertions(+), 3 deletions(-)",
"patch_text_b64": "RnJvbSA0ZTY3N2I5YzQwY2NiYzVmMDkwOTcxYjMxZGMyZmUwN2JmMDU1NDFkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCcmFtIE1vb2xlbmFhciA8QnJhbUB2aW0ub3JnPgpEYXRlOiBUaHUsIDI4IEp1bCAyMDIyIDE4OjQ0OjI3ICswMTAwClN1YmplY3Q6IFtQQVRDSF0gcGF0Y2ggOS4wLjAxMDE6IGludmFsaWQgbWVtb3J5IGFjY2VzcyBpbiBkaWZmIG1vZGUgd2l0aCAiZHAiCiBhbmQgdW5kbwoKUHJvYmxlbTogICAgSW52YWxpZCBtZW1vcnkgYWNjZXNzIGluIGRpZmYgbW9kZSB3aXRoICJkcCIgYW5kIHVuZG8uClNvbHV0aW9uOiAgIE1ha2Ugc3VyZSB0aGUgbGluZSBudW1iZXIgZG9lcyBub3QgZ28gYmVsb3cgb25lLgotLS0KIHNyYy9kaWZmLmMgICAgICAgICAgICAgICAgICAgIHwgIDkgKysrKysrLS0tCiBzcmMvdGVzdGRpci90ZXN0X2RpZmZtb2RlLnZpbSB8IDE0ICsrKysrKysrKysrKysrCiBzcmMvdmVyc2lvbi5jICAgICAgICAgICAgICAgICB8ICAyICsrCiAzIGZpbGVzIGNoYW5nZWQsIDIyIGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2RpZmYuYyBiL3NyYy9kaWZmLmMKaW5kZXggZTRiYWZlMmM5MzRlMi4uZmI0M2VlZTg0NGNkOCAxMDA2NDQKLS0tIGEvc3JjL2RpZmYuYworKysgYi9zcmMvZGlmZi5jCkBAIC00NjQsNyArNDY0LDEwIEBAIGRpZmZfbWFya19hZGp1c3RfdHAoCiAJCSAgICBmb3IgKGkgPSAwOyBpIDwgREJfQ09VTlQ7ICsraSkKIAkJCWlmICh0cC0+dHBfZGlmZmJ1ZltpXSAhPSBOVUxMICYmIGkgIT0gaWR4KQogCQkJewotCQkJICAgIGRwLT5kZl9sbnVtW2ldIC09IG9mZjsKKwkJCSAgICBpZiAoZHAtPmRmX2xudW1baV0gPiBvZmYpCisJCQkJZHAtPmRmX2xudW1baV0gLT0gb2ZmOworCQkJICAgIGVsc2UKKwkJCQlkcC0+ZGZfbG51bVtpXSA9IDE7CiAJCQkgICAgZHAtPmRmX2NvdW50W2ldICs9IG47CiAJCQl9CiAJCX0KQEAgLTI4NjMsOCArMjg2Niw4IEBAIGV4X2RpZmZnZXRwdXQoZXhhcmdfVCAqZWFwKQogCSAgICB7CiAJCS8vIHJlbWVtYmVyIGRlbGV0aW5nIHRoZSBsYXN0IGxpbmUgb2YgdGhlIGJ1ZmZlcgogCQlidWZfZW1wdHkgPSBjdXJidWYtPmJfbWwubWxfbGluZV9jb3VudCA9PSAxOwotCQltbF9kZWxldGUobG51bSk7Ci0JCS0tYWRkZWQ7CisJCWlmIChtbF9kZWxldGUobG51bSkgPT0gT0spCisJCSAgICAtLWFkZGVkOwogCSAgICB9CiAJICAgIGZvciAoaSA9IDA7IGkgPCBkcC0+ZGZfY291bnRbaWR4X2Zyb21dIC0gc3RhcnRfc2tpcCAtIGVuZF9za2lwOyArK2kpCiAJICAgIHsKZGlmZiAtLWdpdCBhL3NyYy90ZXN0ZGlyL3Rlc3RfZGlmZm1vZGUudmltIGIvc3JjL3Rlc3RkaXIvdGVzdF9kaWZmbW9kZS52aW0KaW5kZXggZGNhY2Q1NTE2YmI3ZC4uNDFmN2ZlMzQ5M2NhNSAxMDA2NDQKLS0tIGEvc3JjL3Rlc3RkaXIvdGVzdF9kaWZmbW9kZS52aW0KKysrIGIvc3JjL3Rlc3RkaXIvdGVzdF9kaWZmbW9kZS52aW0KQEAgLTE2MjgsNSArMTYyOCwxOSBAQCBmdW5jIFRlc3RfZGlmZl9tYW5pcHVsYXRpb25zKCkKICAgJWJ3aXBlIQogZW5kZnVuYwogCisiIFRoaXMgd2FzIGNhdXNpbmcgdGhlIGxpbmUgbnVtYmVyIGluIHRoZSBkaWZmIGJsb2NrIHRvIGdvIGJlbG93IG9uZS4KKyIgRklYTUU6IHNvbWVob3cgdGhpcyBjYXVzZXMgYSB2YWxncmluZCBlcnJvciB3aGVuIHJ1biBkaXJlY3RseSBidXQgbm90IHdoZW4KKyIgcnVuIGFzIGEgdGVzdC4KK2Z1bmMgVGVzdF9kaWZmX3B1dF9hbmRfdW5kbygpCisgIHNldCBkaWZmCisgIG5leHQgMAorICBzcGxpdCAwMAorICBzaWwhIG5vcm0gbzAbZ2d1dWRwbzAbZ2dKdXVkcAorCisgIGJ3aXBlIQorICBid2lwZSEKKyAgc2V0IG5vZGlmZgorZW5kZnVuYworCiAKICIgdmltOiBzaGlmdHdpZHRoPTIgc3RzPTIgZXhwYW5kdGFiCmRpZmYgLS1naXQgYS9zcmMvdmVyc2lvbi5jIGIvc3JjL3ZlcnNpb24uYwppbmRleCA5ZTY4MmE1ZmQ2MzU3Li4xMjQxZTk4YjA4YjBmIDEwMDY0NAotLS0gYS9zcmMvdmVyc2lvbi5jCisrKyBiL3NyYy92ZXJzaW9uLmMKQEAgLTczNSw2ICs3MzUsOCBAQCBzdGF0aWMgY2hhciAqKGZlYXR1cmVzW10pID0KIAogc3RhdGljIGludCBpbmNsdWRlZF9wYXRjaGVzW10gPQogeyAgIC8qIEFkZCBuZXcgcGF0Y2ggbnVtYmVyIGJlbG93IHRoaXMgbGluZSAqLworLyoqLworICAgIDEwMSwKIC8qKi8KICAgICAxMDAsCiAvKiov",
"url": "https://github.com/vim/vim/commit/4e677b9c40ccbc5f090971b31dc2fe07bf05541d.patch"
}
] | null |
|
PYSEC-2023-55
| null |
[
{
"commit_message": "[PATCH] Release note for CVE-2023-28836 in 4.1.4 CHANGELOG.txt | 1 + docs/releases/4.1.4.md | 6 ++++++ 2 files changed, 7 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/wagtail/wagtail/commit/eefc3381d37b476791610e5d30594fae443f33af.patch"
},
{
"commit_message": "[PATCH] Release note for CVE-2023-28836 in 4.2.2 CHANGELOG.txt | 1 + docs/releases/4.2.2.md | 6 ++++++ 2 files changed, 7 insertions(+)",
"patch_text_b64": "RnJvbSBiYzg0YmY5ODE1NjEwY2ZiZjhkYjNiNjA1MGM3ZGRjYmFhNGI5NzEzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXR0IFdlc3Rjb3R0IDxtYXR0QHdlc3QuY28udHQ+CkRhdGU6IE1vbiwgMyBBcHIgMjAyMyAxMToxODo1OCArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIFJlbGVhc2Ugbm90ZSBmb3IgQ1ZFLTIwMjMtMjg4MzYgaW4gNC4yLjIKCi0tLQogQ0hBTkdFTE9HLnR4dCAgICAgICAgICB8IDEgKwogZG9jcy9yZWxlYXNlcy80LjIuMi5tZCB8IDYgKysrKysrCiAyIGZpbGVzIGNoYW5nZWQsIDcgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL0NIQU5HRUxPRy50eHQgYi9DSEFOR0VMT0cudHh0CmluZGV4IGQ1ZmJjMjIyNTMyZC4uODk3ODJhMWQzZGE2IDEwMDY0NAotLS0gYS9DSEFOR0VMT0cudHh0CisrKyBiL0NIQU5HRUxPRy50eHQKQEAgLTEwNSw2ICsxMDUsNyBAQCBDaGFuZ2Vsb2cKIDQuMi4yICh4eC54eC54eHh4KSAtIElOIERFVkVMT1BNRU5UCiB+fn5+fn5+fn5+fn5+fn5+fn4KIAorICogRml4OiBDVkUtMjAyMy0yODgzNiAtIFN0b3JlZCBYU1MgYXR0YWNrIHZpYSBNb2RlbEFkbWluIHZpZXdzIChUaGliYXVkIENvbGFzKQogICogRml4OiBGaXggcmFkaW8gYW5kIGNoZWNrYm94IGVsZW1lbnRzIHNocmlua2luZyB3aGVuIHVzaW5nIGEgbG9uZyBsYWJlbCAoU2FnZSBBYmR1bGxhaCkKICAqIEZpeDogRml4IHNlbGVjdCBlbGVtZW50cyBleHBhbmRpbmcgYmV5b25kIHRoZWlyIGNvbnRhaW5lciB3aGVuIHVzaW5nIGEgbG9uZyBvcHRpb24gbGFiZWwgKFNhZ2UgQWJkdWxsYWgpCiAgKiBGaXg6IEZpeCB0aW1lem9uZSBoYW5kbGluZyBvZiBgVGVtcGxhdGVSZXNwb25zZWBzIGZvciB1c2VycyB3aXRoIGEgY3VzdG9tIHRpbWV6b25lIChTdGVmYW4gSGFtbWVyLCBTYWdlIEFiZHVsbGFoKQpkaWZmIC0tZ2l0IGEvZG9jcy9yZWxlYXNlcy80LjIuMi5tZCBiL2RvY3MvcmVsZWFzZXMvNC4yLjIubWQKaW5kZXggNzQwOGMyNDRlY2EyLi5mOWQ3MGVkNjAwNjAgMTAwNjQ0Ci0tLSBhL2RvY3MvcmVsZWFzZXMvNC4yLjIubWQKKysrIGIvZG9jcy9yZWxlYXNlcy80LjIuMi5tZApAQCAtMTEsNiArMTEsMTIgQEAgZGVwdGg6IDEKIAogIyMgV2hhdCdzIG5ldwogCisjIyMgQ1ZFLTIwMjMtMjg4MzY6IFN0b3JlZCBYU1MgYXR0YWNrIHZpYSBNb2RlbEFkbWluIHZpZXdzCisKK1RoaXMgcmVsZWFzZSBhZGRyZXNzZXMgYSBzdG9yZWQgY3Jvc3Mtc2l0ZSBzY3JpcHRpbmcgKFhTUykgdnVsbmVyYWJpbGl0eSBvbiBNb2RlbEFkbWluIHZpZXdzIHdpdGhpbiB0aGUgV2FndGFpbCBhZG1pbiBpbnRlcmZhY2UuIEEgdXNlciB3aXRoIGEgbGltaXRlZC1wZXJtaXNzaW9uIGVkaXRvciBhY2NvdW50IGZvciB0aGUgV2FndGFpbCBhZG1pbiBjb3VsZCBwb3RlbnRpYWxseSBjcmFmdCBwYWdlcyBhbmQgZG9jdW1lbnRzIHRoYXQsIHdoZW4gdmlld2VkIGJ5IGEgdXNlciB3aXRoIGhpZ2hlciBwcml2aWxlZ2VzLCBjb3VsZCBwZXJmb3JtIGFjdGlvbnMgd2l0aCB0aGF0IHVzZXIncyBjcmVkZW50aWFscy4gVGhlIHZ1bG5lcmFiaWxpdHkgaXMgbm90IGV4cGxvaXRhYmxlIGJ5IGFuIG9yZGluYXJ5IHNpdGUgdmlzaXRvciB3aXRob3V0IGFjY2VzcyB0byB0aGUgV2FndGFpbCBhZG1pbiwgYW5kIG9ubHkgYWZmZWN0cyBzaXRlcyB3aXRoIE1vZGVsQWRtaW4gZW5hYmxlZC4KKworTWFueSB0aGFua3MgdG8gVGhpYmF1ZCBDb2xhcyBmb3IgcmVwb3J0aW5nIHRoaXMgaXNzdWUuIEZvciBmdXJ0aGVyIGRldGFpbHMsIHBsZWFzZSBzZWUgW3RoZSBDVkUtMjAyMy0yODgzNiBzZWN1cml0eSBhZHZpc29yeV0oaHR0cHM6Ly9naXRodWIuY29tL3dhZ3RhaWwvd2FndGFpbC9zZWN1cml0eS9hZHZpc29yaWVzL0dIU0EtNTI4Ni1mMnJmLTM1YzIpLgorCiAjIyMgQnVnIGZpeGVzCiAKICogRml4IHJhZGlvIGFuZCBjaGVja2JveCBlbGVtZW50cyBzaHJpbmtpbmcgd2hlbiB1c2luZyBhIGxvbmcgbGFiZWwgKFNhZ2UgQWJkdWxsYWgp",
"url": "https://github.com/wagtail/wagtail/commit/bc84bf9815610cfbf8db3b6050c7ddcbaa4b9713.patch"
},
{
"commit_message": "[PATCH] Change ChooseParentView to use plain text breadcrumbs for page titles, avoiding stored XSS vector wagtail/contrib/modeladmin/forms.py | 3 +-- .../modeladmin/tests/test_page_modeladmin.py | 15 +++++++++++++++ 2 files changed, 16 insertions(+), 2 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/wagtail/wagtail/commit/5be2b1ed55fd7259dfdf2c82e7701dba407b8b62.patch"
},
{
"commit_message": "[PATCH] Change ModelAdmin InspectView to escape any HTML from document titles .../modeladmin/tests/test_simple_modeladmin.py | 16 ++++++++++++++++ wagtail/contrib/modeladmin/views.py | 16 +++++++--------- 2 files changed, 23 insertions(+), 9 deletions(-)",
"patch_text_b64": "RnJvbSBmZjgwNmFiMTczYTUwNDM5NWZkZmIzMTM5ZWIwYTI5NDQ0YWI0YjkxIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUaGliYXVkIENvbGFzIDx0aGliYXVkY29sYXNAZ21haWwuY29tPgpEYXRlOiBNb24sIDI3IE1hciAyMDIzIDEzOjAzOjQ2ICswMTAwClN1YmplY3Q6IFtQQVRDSF0gQ2hhbmdlIE1vZGVsQWRtaW4gSW5zcGVjdFZpZXcgdG8gZXNjYXBlIGFueSBIVE1MIGZyb20KIGRvY3VtZW50IHRpdGxlcwoKLS0tCiAuLi4vbW9kZWxhZG1pbi90ZXN0cy90ZXN0X3NpbXBsZV9tb2RlbGFkbWluLnB5ICAgfCAxNiArKysrKysrKysrKysrKysrCiB3YWd0YWlsL2NvbnRyaWIvbW9kZWxhZG1pbi92aWV3cy5weSAgICAgICAgICAgICAgfCAxNiArKysrKysrLS0tLS0tLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDIzIGluc2VydGlvbnMoKyksIDkgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvd2FndGFpbC9jb250cmliL21vZGVsYWRtaW4vdGVzdHMvdGVzdF9zaW1wbGVfbW9kZWxhZG1pbi5weSBiL3dhZ3RhaWwvY29udHJpYi9tb2RlbGFkbWluL3Rlc3RzL3Rlc3Rfc2ltcGxlX21vZGVsYWRtaW4ucHkKaW5kZXggMTdiYmY2Y2Q3M2Q2Li4zMjU1MzcwOTdlYWMgMTAwNjQ0Ci0tLSBhL3dhZ3RhaWwvY29udHJpYi9tb2RlbGFkbWluL3Rlc3RzL3Rlc3Rfc2ltcGxlX21vZGVsYWRtaW4ucHkKKysrIGIvd2FndGFpbC9jb250cmliL21vZGVsYWRtaW4vdGVzdHMvdGVzdF9zaW1wbGVfbW9kZWxhZG1pbi5weQpAQCAtMTMsNiArMTMsOCBAQAogZnJvbSB3YWd0YWlsLmFkbWluLmFkbWluX3VybF9maW5kZXIgaW1wb3J0IEFkbWluVVJMRmluZGVyCiBmcm9tIHdhZ3RhaWwuYWRtaW4ucGFuZWxzIGltcG9ydCBGaWVsZFBhbmVsLCBUYWJiZWRJbnRlcmZhY2UKIGZyb20gd2FndGFpbC5jb250cmliLm1vZGVsYWRtaW4uaGVscGVycy5zZWFyY2ggaW1wb3J0IERqYW5nb09STVNlYXJjaEhhbmRsZXIKK2Zyb20gd2FndGFpbC5kb2N1bWVudHMubW9kZWxzIGltcG9ydCBEb2N1bWVudAorZnJvbSB3YWd0YWlsLmRvY3VtZW50cy50ZXN0cy51dGlscyBpbXBvcnQgZ2V0X3Rlc3RfZG9jdW1lbnRfZmlsZQogZnJvbSB3YWd0YWlsLmltYWdlcy5tb2RlbHMgaW1wb3J0IEltYWdlCiBmcm9tIHdhZ3RhaWwuaW1hZ2VzLnRlc3RzLnV0aWxzIGltcG9ydCBnZXRfdGVzdF9pbWFnZV9maWxlCiBmcm9tIHdhZ3RhaWwubW9kZWxzIGltcG9ydCBMb2NhbGUsIE1vZGVsTG9nRW50cnksIFBhZ2UKQEAgLTU5MSw2ICs1OTMsMjAgQEAgZGVmIHRlc3RfYm9va19hdXRob3JfcHJlc2VudChzZWxmKToKICAgICAgICAgcmVzcG9uc2UgPSBzZWxmLmdldF9mb3JfYm9vaygxKQogICAgICAgICBzZWxmLmFzc2VydENvbnRhaW5zKHJlc3BvbnNlLCAiSi4gUi4gUi4gVG9sa2llbiIsIDEpCiAKKyAgICBkZWYgdGVzdF9ib29rX2V4dHJhY3RfZG9jdW1lbnRfaHRtbF9lc2NhcGluZyhzZWxmKToKKyAgICAgICAgZG9jID0gRG9jdW1lbnQub2JqZWN0cy5jcmVhdGUoCisgICAgICAgICAgICB0aXRsZT0iVGl0bGUgd2l0aCA8c2NyaXB0PmFsZXJ0KCdYU1MnKTwvc2NyaXB0PiIsCisgICAgICAgICAgICBmaWxlPWdldF90ZXN0X2RvY3VtZW50X2ZpbGUoKSwKKyAgICAgICAgKQorICAgICAgICBib29rID0gQm9vay5vYmplY3RzLmdldCh0aXRsZT0iVGhlIExvcmQgb2YgdGhlIFJpbmdzIikKKyAgICAgICAgYm9vay5leHRyYWN0X2RvY3VtZW50ID0gZG9jCisgICAgICAgIGJvb2suc2F2ZSgpCisgICAgICAgIHJlc3BvbnNlID0gc2VsZi5nZXRfZm9yX2Jvb2soMSkKKyAgICAgICAgc2VsZi5hc3NlcnROb3RDb250YWlucyhyZXNwb25zZSwgIlRpdGxlIHdpdGggPHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4iKQorICAgICAgICBzZWxmLmFzc2VydENvbnRhaW5zKAorICAgICAgICAgICAgcmVzcG9uc2UsICJUaXRsZSB3aXRoICZsdDtzY3JpcHQmZ3Q7YWxlcnQoJiN4Mjc7WFNTJiN4Mjc7KSZsdDsvc2NyaXB0Jmd0OyIKKyAgICAgICAgKQorCiAgICAgZGVmIHRlc3Rfbm9uX2V4aXN0ZW50KHNlbGYpOgogICAgICAgICByZXNwb25zZSA9IHNlbGYuZ2V0X2Zvcl9ib29rKDEwMCkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChyZXNwb25zZS5zdGF0dXNfY29kZSwgNDA0KQpkaWZmIC0tZ2l0IGEvd2FndGFpbC9jb250cmliL21vZGVsYWRtaW4vdmlld3MucHkgYi93YWd0YWlsL2NvbnRyaWIvbW9kZWxhZG1pbi92aWV3cy5weQppbmRleCA2Yjc3ODhjMTdmODcuLjUxM2U5NWRjNTUzZiAxMDA2NDQKLS0tIGEvd2FndGFpbC9jb250cmliL21vZGVsYWRtaW4vdmlld3MucHkKKysrIGIvd2FndGFpbC9jb250cmliL21vZGVsYWRtaW4vdmlld3MucHkKQEAgLTI5LDggKzI5LDggQEAKIGZyb20gZGphbmdvLnV0aWxzLmRlY29yYXRvcnMgaW1wb3J0IG1ldGhvZF9kZWNvcmF0b3IKIGZyb20gZGphbmdvLnV0aWxzLmVuY29kaW5nIGltcG9ydCBmb3JjZV9zdHIKIGZyb20gZGphbmdvLnV0aWxzLmZ1bmN0aW9uYWwgaW1wb3J0IGNhY2hlZF9wcm9wZXJ0eQorZnJvbSBkamFuZ28udXRpbHMuaHRtbCBpbXBvcnQgZm9ybWF0X2h0bWwKIGZyb20gZGphbmdvLnV0aWxzLmh0dHAgaW1wb3J0IHVybGVuY29kZQotZnJvbSBkamFuZ28udXRpbHMuc2FmZXN0cmluZyBpbXBvcnQgbWFya19zYWZlCiBmcm9tIGRqYW5nby51dGlscy50ZXh0IGltcG9ydCBjYXBmaXJzdAogZnJvbSBkamFuZ28udXRpbHMudHJhbnNsYXRpb24gaW1wb3J0IGdldHRleHQgYXMgXwogZnJvbSBkamFuZ28udXRpbHMudHJhbnNsYXRpb24gaW1wb3J0IGdldHRleHRfbGF6eQpAQCAtMTEzMSwxNCArMTEzMSwxMiBAQCBkZWYgZ2V0X2RvY3VtZW50X2ZpZWxkX2Rpc3BsYXkoc2VsZiwgZmllbGRfbmFtZSwgZmllbGQpOgogICAgICAgICAiIiJSZW5kZXIgYSBsaW5rIHRvIGEgZG9jdW1lbnQiIiIKICAgICAgICAgZG9jdW1lbnQgPSBnZXRhdHRyKHNlbGYuaW5zdGFuY2UsIGZpZWxkX25hbWUpCiAgICAgICAgIGlmIGRvY3VtZW50OgotICAgICAgICAgICAgcmV0dXJuIG1hcmtfc2FmZSgKLSAgICAgICAgICAgICAgICAnPGEgaHJlZj0iJXMiPiVzIDxzcGFuIGNsYXNzPSJtZXRhIj4oJXMsICVzKTwvc3Bhbj48L2E+JwotICAgICAgICAgICAgICAgICUgKAotICAgICAgICAgICAgICAgICAgICBkb2N1bWVudC51cmwsCi0gICAgICAgICAgICAgICAgICAgIGRvY3VtZW50LnRpdGxlLAotICAgICAgICAgICAgICAgICAgICBkb2N1bWVudC5maWxlX2V4dGVuc2lvbi51cHBlcigpLAotICAgICAgICAgICAgICAgICAgICBmaWxlc2l6ZWZvcm1hdChkb2N1bWVudC5maWxlLnNpemUpLAotICAgICAgICAgICAgICAgICkKKyAgICAgICAgICAgIHJldHVybiBmb3JtYXRfaHRtbCgKKyAgICAgICAgICAgICAgICAnPGEgaHJlZj0ie30iPnt9IDxzcGFuIGNsYXNzPSJtZXRhIj4oe30sIHt9KTwvc3Bhbj48L2E+JywKKyAgICAgICAgICAgICAgICBkb2N1bWVudC51cmwsCisgICAgICAgICAgICAgICAgZG9jdW1lbnQudGl0bGUsCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZmlsZV9leHRlbnNpb24udXBwZXIoKSwKKyAgICAgICAgICAgICAgICBmaWxlc2l6ZWZvcm1hdChkb2N1bWVudC5maWxlLnNpemUpLAogICAgICAgICAgICAgKQogICAgICAgICByZXR1cm4gc2VsZi5tb2RlbF9hZG1pbi5nZXRfZW1wdHlfdmFsdWVfZGlzcGxheShmaWVsZF9uYW1lKQ==",
"url": "https://github.com/wagtail/wagtail/commit/ff806ab173a504395fdfb3139eb0a29444ab4b91.patch"
}
] | null |
|
GHSA-f8gp-vg7w-rp8x
| null |
[
{
"commit_message": "[PATCH] Set correct content type for JSON responses MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Michal Čihař <michal@cihar.com> import_status.php | 6 +++--- libraries/Response.class.php | 5 +---- libraries/core.lib.php | 20 ++++++++++++++++++++ libraries/display_import_ajax.lib.php | 2 +- lint.php | 5 +++-- normalization.php | 2 ++ setup/validate.php | 2 +- version_check.php | 2 +- 8 files changed, 32 insertions(+), 12 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/0a24f92d081033576bfdd9d4bdec1a54501734c1.patch"
},
{
"commit_message": "[PATCH] Tell jQuery we're expecting JSON here MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit It's better to be explicit rather than relying on autodetection. Signed-off-by: Michal Čihař <michal@cihar.com> js/codemirror/addon/lint/sql-lint.js | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)",
"patch_text_b64": "RnJvbSAxMTQ5Njg5MGQ3ZTIxNzg2Y2JmZDlmZDE3YWI5NjhmNDk4MTE2YjNmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/TWljaGFsPTIwPUM0PThDaWhhPUM1PTk5Pz0gPG1pY2hhbEBjaWhhci5jb20+CkRhdGU6IFR1ZSwgMTkgSmFuIDIwMTYgMTA6MTc6MjAgKzAxMDAKU3ViamVjdDogW1BBVENIXSBUZWxsIGpRdWVyeSB3ZSdyZSBleHBlY3RpbmcgSlNPTiBoZXJlCk1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CgpJdCdzIGJldHRlciB0byBiZSBleHBsaWNpdCByYXRoZXIgdGhhbiByZWx5aW5nIG9uIGF1dG9kZXRlY3Rpb24uCgpTaWduZWQtb2ZmLWJ5OiBNaWNoYWwgxIxpaGHFmSA8bWljaGFsQGNpaGFyLmNvbT4KLS0tCiBqcy9jb2RlbWlycm9yL2FkZG9uL2xpbnQvc3FsLWxpbnQuanMgfCA1ICsrLS0tCiAxIGZpbGUgY2hhbmdlZCwgMiBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2pzL2NvZGVtaXJyb3IvYWRkb24vbGludC9zcWwtbGludC5qcyBiL2pzL2NvZGVtaXJyb3IvYWRkb24vbGludC9zcWwtbGludC5qcwppbmRleCAyMmE1Nzg1YTZkYjQuLjBhMWYzOTZmNGIwYyAxMDA2NDQKLS0tIGEvanMvY29kZW1pcnJvci9hZGRvbi9saW50L3NxbC1saW50LmpzCisrKyBiL2pzL2NvZGVtaXJyb3IvYWRkb24vbGludC9zcWwtbGludC5qcwpAQCAtNiw5ICs2LDcgQEAgQ29kZU1pcnJvci5zcWxMaW50ID0gZnVuY3Rpb24odGV4dCwgdXBkYXRlTGludGluZywgb3B0aW9ucywgY20pIHsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIGZ1bmN0aW9uIGhhbmRsZVJlc3BvbnNlKGpzb24pIHsKLSAgICAgICAgcmVzcG9uc2UgPSBKU09OLnBhcnNlKGpzb24pOwotCisgICAgZnVuY3Rpb24gaGFuZGxlUmVzcG9uc2UocmVzcG9uc2UpIHsKICAgICAgICAgdmFyIGZvdW5kID0gW107CiAgICAgICAgIGZvciAodmFyIGlkeCBpbiByZXNwb25zZSkgewogICAgICAgICAgICAgZm91bmQucHVzaCh7CkBAIC0yOSw2ICsyNyw3IEBAIENvZGVNaXJyb3Iuc3FsTGludCA9IGZ1bmN0aW9uKHRleHQsIHVwZGF0ZUxpbnRpbmcsIG9wdGlvbnMsIGNtKSB7CiAgICAgJC5hamF4KHsKICAgICAgICAgbWV0aG9kOiAiUE9TVCIsCiAgICAgICAgIHVybDogImxpbnQucGhwIiwKKyAgICAgICAgZGF0YVR5cGU6ICdqc29uJywKICAgICAgICAgZGF0YTogewogICAgICAgICAgICAgc3FsX3F1ZXJ5OiB0ZXh0LAogICAgICAgICAgICAgdG9rZW46IFBNQV9jb21tb25QYXJhbXMuZ2V0KCd0b2tlbicpLA==",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/11496890d7e21786cbfd9fd17ab968f498116b3f.patch"
}
] | null |
|
CVE-2020-14971
|
Pi-hole through 5.0 allows code injection in piholedhcp (the Static DHCP Leases section) by modifying Teleporter backup files and then restoring them. This occurs in settings.php. To exploit this, an attacker would request a backup of limited files via teleporter.php. These are placed into a .tar.gz archive. The attacker then modifies the host parameter in dnsmasq.d files, and then compresses and uploads these files again.
|
[
{
"commit_message": "[PATCH] make use of utils.escapeHtml on the JS side of things, and html_entity_decode/htmlentities in PHP Signed-off-by: Adam Warner <me@adamwarner.co.uk> dns_records.php | 1 + scripts/pi-hole/js/customdns.js | 6 +++-- scripts/pi-hole/js/groups-adlists.js | 10 +++---- scripts/pi-hole/js/groups-clients.js | 12 ++++----- scripts/pi-hole/js/groups-domains.js | 10 +++---- scripts/pi-hole/js/groups.js | 10 +++---- scripts/pi-hole/php/database.php | 4 +-- scripts/pi-hole/php/func.php | 39 +++++++++++++++------------- scripts/pi-hole/php/groups.php | 25 ++++++++++-------- scripts/pi-hole/php/teleporter.php | 4 +-- settings.php | 4 +-- 11 files changed, 67 insertions(+), 58 deletions(-)",
"patch_text_b64": "From c949516ee15fa6a9b0c8511cc4c4d6b0893f3e69 Mon Sep 17 00:00:00 2001
From: Adam Warner <me@adamwarner.co.uk>
Date: Sat, 13 Jun 2020 18:50:36 +0100
Subject: [PATCH] make use of utils.escapeHtml on the JS side of things, and
 html_entity_decode/htmlentities in PHP

Signed-off-by: Adam Warner <me@adamwarner.co.uk>
---
 dns_records.php                      |  1 +
 scripts/pi-hole/js/customdns.js      |  6 +++--
 scripts/pi-hole/js/groups-adlists.js | 10 +++----
 scripts/pi-hole/js/groups-clients.js | 12 ++++-----
 scripts/pi-hole/js/groups-domains.js | 10 +++----
 scripts/pi-hole/js/groups.js         | 10 +++----
 scripts/pi-hole/php/database.php     |  4 +--
 scripts/pi-hole/php/func.php         | 39 +++++++++++++++-------------
 scripts/pi-hole/php/groups.php       | 25 ++++++++++--------
 scripts/pi-hole/php/teleporter.php   |  4 +--
 settings.php                         |  4 +--
 11 files changed, 67 insertions(+), 58 deletions(-)

diff --git a/dns_records.php b/dns_records.php
index 4d429af44a..dc9e5d5f76 100644
--- a/dns_records.php
+++ b/dns_records.php
@@ -89,6 +89,7 @@
     </div>
 </div>
 
+<script src="scripts/pi-hole/js/utils.js"></script>
 <script src="scripts/pi-hole/js/ip-address-sorting.js"></script>
 <script src="scripts/pi-hole/js/customdns.js"></script>
 
diff --git a/scripts/pi-hole/js/customdns.js b/scripts/pi-hole/js/customdns.js
index 116ea602d7..d2f4ad567c 100644
--- a/scripts/pi-hole/js/customdns.js
+++ b/scripts/pi-hole/js/customdns.js
@@ -5,6 +5,8 @@
  *  This file is copyright under the latest version of the EUPL.
  *  Please see LICENSE file for your rights under this license. */
 
+/* global utils:false */
+
 var table;
 var token = $("#token").text();
 
@@ -76,8 +78,8 @@ $(function () {
 });
 
 function addCustomDNS() {
-  var ip = $("#ip").val();
-  var domain = $("#domain").val();
+  var ip = utils.escapeHtml($("#ip").val());
+  var domain = utils.escapeHtml($("#domain").val());
 
   showAlert("info");
   $.ajax({
diff --git a/scripts/pi-hole/js/groups-adlists.js b/scripts/pi-hole/js/groups-adlists.js
index 4bcdde8185..4f58b1c417 100644
--- a/scripts/pi-hole/js/groups-adlists.js
+++ b/scripts/pi-hole/js/groups-adlists.js
@@ -212,8 +212,8 @@ function initTable() {
 }
 
 function addAdlist() {
-  var address = $("#new_address").val();
-  var comment = $("#new_comment").val();
+  var address = utils.escapeHtml($("#new_address").val());
+  var comment = utils.escapeHtml($("#new_comment").val());
 
   utils.disableAll();
   utils.showAlert("info", "", "Adding adlist...", address);
@@ -258,9 +258,9 @@ function editAdlist() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
   var status = tr.find("#status_" + id).is(":checked") ? 1 : 0;
-  var comment = tr.find("#comment_" + id).val();
+  var comment = utils.escapeHtml(tr.find("#comment_" + id).val());
   var groups = tr.find("#multiselect_" + id).val();
-  var address = tr.find("#address_" + id).text();
+  var address = utils.escapeHtml(tr.find("#address_" + id).text());
 
   var done = "edited";
   var notDone = "editing";
@@ -338,7 +338,7 @@ function editAdlist() {
 function deleteAdlist() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
-  var address = tr.find("#address_" + id).text();
+  var address = utils.escapeHtml(tr.find("#address_" + id).text());
 
   utils.disableAll();
   utils.showAlert("info", "", "Deleting adlist...", address);
diff --git a/scripts/pi-hole/js/groups-clients.js b/scripts/pi-hole/js/groups-clients.js
index 609606ce44..70ff81ff39 100644
--- a/scripts/pi-hole/js/groups-clients.js
+++ b/scripts/pi-hole/js/groups-clients.js
@@ -246,9 +246,9 @@ function initTable() {
 
 function addClient() {
   var ip = $("#select").val();
-  var comment = $("#new_comment").val();
+  var comment = utils.escapeHtml($("#new_comment").val());
   if (ip === "custom") {
-    ip = $("#ip-custom").val().trim();
+    ip = utils.escapeHtml($("#ip-custom").val().trim());
   }
 
   utils.disableAll();
@@ -303,9 +303,9 @@ function editClient() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
   var groups = tr.find("#multiselect_" + id).val();
-  var ip = tr.find("#ip_" + id).text();
-  var name = tr.find("#name_" + id).text();
-  var comment = tr.find("#comment_" + id).val();
+  var ip = utils.escapeHtml(tr.find("#ip_" + id).text());
+  var name = utils.escapeHtml(tr.find("#name_" + id).text());
+  var comment = utils.escapeHtml(tr.find("#comment_" + id).val());
 
   var done = "edited";
   var notDone = "editing";
@@ -370,7 +370,7 @@ function deleteClient() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
   var ip = tr.find("#ip_" + id).text();
-  var name = tr.find("#name_" + id).text();
+  var name = utils.escapeHtml(tr.find("#name_" + id).text());
 
   if (name.length > 0) {
     ip += " (" + name + ")";
diff --git a/scripts/pi-hole/js/groups-domains.js b/scripts/pi-hole/js/groups-domains.js
index 74768f8d69..5128ef14cb 100644
--- a/scripts/pi-hole/js/groups-domains.js
+++ b/scripts/pi-hole/js/groups-domains.js
@@ -318,8 +318,8 @@ function addDomain() {
     commentEl = $("#new_regex_comment");
   }
 
-  var domain = domainEl.val();
-  var comment = commentEl.val();
+  var domain = utils.escapeHtml(domainEl.val());
+  var comment = utils.escapeHtml(commentEl.val());
 
   utils.disableAll();
   utils.showAlert("info", "", "Adding " + domainRegex + "...", domain);
@@ -385,10 +385,10 @@ function editDomain() {
   var elem = $(this).attr("id");
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
-  var domain = tr.find("#domain_" + id).text();
+  var domain = utils.escapeHtml(tr.find("#domain_" + id).text());
   var type = tr.find("#type_" + id).val();
   var status = tr.find("#status_" + id).is(":checked") ? 1 : 0;
-  var comment = tr.find("#comment_" + id).val();
+  var comment = utils.escapeHtml(tr.find("#comment_" + id).val());
 
   // Show group assignment field only if in full domain management mode
   // if not included, just use the row data.
@@ -485,7 +485,7 @@ function editDomain() {
 function deleteDomain() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
-  var domain = tr.find("#domain_" + id).text();
+  var domain = utils.escapeHtml(tr.find("#domain_" + id).text());
   var type = tr.find("#type_" + id).val();
 
   var domainRegex;
diff --git a/scripts/pi-hole/js/groups.js b/scripts/pi-hole/js/groups.js
index f7d16d533b..9835c4c764 100644
--- a/scripts/pi-hole/js/groups.js
+++ b/scripts/pi-hole/js/groups.js
@@ -127,8 +127,8 @@ $(function () {
 });
 
 function addGroup() {
-  var name = $("#new_name").val();
-  var desc = $("#new_desc").val();
+  var name = utils.escapeHtml($("#new_name").val());
+  var desc = utils.escapeHtml($("#new_desc").val());
 
   utils.disableAll();
   utils.showAlert("info", "", "Adding group...", name);
@@ -166,9 +166,9 @@ function editGroup() {
   var elem = $(this).attr("id");
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
-  var name = tr.find("#name_" + id).val();
+  var name = utils.escapeHtml(tr.find("#name_" + id).val());
   var status = tr.find("#status_" + id).is(":checked") ? 1 : 0;
-  var desc = tr.find("#desc_" + id).val();
+  var desc = utils.escapeHtml(tr.find("#desc_" + id).val());
 
   var done = "edited";
   var notDone = "editing";
@@ -239,7 +239,7 @@ function editGroup() {
 function deleteGroup() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
-  var name = tr.find("#name_" + id).val();
+  var name = utils.escapeHtml(tr.find("#name_" + id).val());
 
   utils.disableAll();
   utils.showAlert("info", "", "Deleting group...", name);
diff --git a/scripts/pi-hole/php/database.php b/scripts/pi-hole/php/database.php
index 0a6af81489..46b7decea4 100644
--- a/scripts/pi-hole/php/database.php
+++ b/scripts/pi-hole/php/database.php
@@ -161,9 +161,9 @@ function add_to_table($db, $table, $domains, $comment=null, $wildcardstyle=false
 		if($wildcardstyle)
 			$domain = "(\\.|^)".str_replace(".","\\.",$domain)."$";
 
-		$stmt->bindValue(":$field", $domain, SQLITE3_TEXT);
+		$stmt->bindValue(":$field", htmlentities($domain), SQLITE3_TEXT);
 		if($bindcomment) {
-			$stmt->bindValue(":comment", $comment, SQLITE3_TEXT);
+			$stmt->bindValue(":comment", htmlentities($comment), SQLITE3_TEXT);
 		}
 
 		if($stmt->execute() && $stmt->reset())
diff --git a/scripts/pi-hole/php/func.php b/scripts/pi-hole/php/func.php
index 37eb8e9d39..efb7c3b8ca 100644
--- a/scripts/pi-hole/php/func.php
+++ b/scripts/pi-hole/php/func.php
@@ -214,31 +214,34 @@ function deleteCustomDNSEntry()
 
 function deleteAllCustomDNSEntries()
 {
-    $handle = fopen($customDNSFile, "r");
-    if ($handle)
+    if (isset($customDNSFile))
     {
-        try
+        $handle = fopen($customDNSFile, "r");
+        if ($handle)
         {
-            while (($line = fgets($handle)) !== false) {
-                $line = str_replace("\r","", $line);
-                $line = str_replace("\n","", $line);
-                $explodedLine = explode (" ", $line);
+            try
+            {
+                while (($line = fgets($handle)) !== false) {
+                    $line = str_replace("\r","", $line);
+                    $line = str_replace("\n","", $line);
+                    $explodedLine = explode (" ", $line);
 
-                if (count($explodedLine) != 2)
-                    continue;
+                    if (count($explodedLine) != 2)
+                        continue;
 
-                $ip = $explodedLine[0];
-                $domain = $explodedLine[1];
+                    $ip = $explodedLine[0];
+                    $domain = $explodedLine[1];
 
-                pihole_execute("-a removecustomdns ".$ip." ".$domain);
+                    pihole_execute("-a removecustomdns ".$ip." ".$domain);
+                }
+            }
+            catch (\Exception $ex)
+            {
+                return errorJsonResponse($ex->getMessage());
             }
-        }
-        catch (\Exception $ex)
-        {
-            return errorJsonResponse($ex->getMessage());
-        }
 
-        fclose($handle);
+            fclose($handle);
+        }
     }
 
     return successJsonResponse();
diff --git a/scripts/pi-hole/php/groups.php b/scripts/pi-hole/php/groups.php
index 1eb4e72b13..04a9030c39 100644
--- a/scripts/pi-hole/php/groups.php
+++ b/scripts/pi-hole/php/groups.php
@@ -58,7 +58,8 @@ function JSON_error($message = null)
 } elseif ($_POST['action'] == 'add_group') {
     // Add new group
     try {
-        $names = str_getcsv(trim($_POST['name']), ' ');
+        $input = html_entity_decode(trim($_POST['name']));
+        $names = str_getcsv($input, ' ');
         $total = count($names);
         $added = 0;
         $stmt = $db->prepare('INSERT INTO "group" (name,description) VALUES (:name,:desc)');
@@ -96,6 +97,9 @@ function JSON_error($message = null)
 } elseif ($_POST['action'] == 'edit_group') {
     // Edit group identified by ID
     try {
+        $name = html_entity_decode($_POST['name']);
+        $desc = html_entity_decode($_POST['desc']);
+
         $stmt = $db->prepare('UPDATE "group" SET enabled=:enabled, name=:name, description=:desc WHERE id = :id');
         if (!$stmt) {
             throw new Exception('While preparing statement: ' . $db->lastErrorMsg());
@@ -106,11 +110,10 @@ function JSON_error($message = null)
             throw new Exception('While binding enabled: ' . $db->lastErrorMsg());
         }
 
-        if (!$stmt->bindValue(':name', $_POST['name'], SQLITE3_TEXT)) {
+        if (!$stmt->bindValue(':name', $name, SQLITE3_TEXT)) {
             throw new Exception('While binding name: ' . $db->lastErrorMsg());
         }
 
-        $desc = $_POST['desc'];
         if (strlen($desc) === 0) {
             // Store NULL in database for empty descriptions
             $desc = null;
@@ -263,7 +266,7 @@ function JSON_error($message = null)
                 throw new Exception('While binding ip: ' . $db->lastErrorMsg());
             }
 
-            $comment = $_POST['comment'];
+            $comment = html_entity_decode($_POST['comment']);
             if (strlen($comment) === 0) {
                     // Store NULL in database for empty comments
                     $comment = null;
@@ -293,7 +296,7 @@ function JSON_error($message = null)
             throw new Exception('While preparing statement: ' . $db->lastErrorMsg());
         }
 
-        $comment = $_POST['comment'];
+        $comment = html_entity_decode($_POST['comment']);
         if (strlen($comment) === 0) {
                 // Store NULL in database for empty comments
                 $comment = null;
@@ -453,7 +456,7 @@ function JSON_error($message = null)
 } elseif ($_POST['action'] == 'add_domain') {
     // Add new domain
     try {
-        $domains = explode(' ', trim($_POST['domain']));
+        $domains = explode(' ', html_entity_decode(trim($_POST['domain'])));
         $before = intval($db->querySingle("SELECT COUNT(*) FROM domainlist;"));
         $total = count($domains);
         $added = 0;
@@ -474,7 +477,7 @@ function JSON_error($message = null)
             throw new Exception('While binding type: ' . $db->lastErrorMsg());
         }
 
-        $comment = $_POST['comment'];
+        $comment = html_entity_decode($_POST['comment']);
         if (strlen($comment) === 0) {
             // Store NULL in database for empty comments
             $comment = null;
@@ -573,7 +576,7 @@ function JSON_error($message = null)
             throw new Exception('While binding enabled: ' . $db->lastErrorMsg());
         }
 
-        $comment = $_POST['comment'];
+        $comment = html_entity_decode($_POST['comment']);
         if (strlen($comment) === 0) {
                 // Store NULL in database for empty comments
                 $comment = null;
@@ -742,7 +745,7 @@ function JSON_error($message = null)
 } elseif ($_POST['action'] == 'add_adlist') {
     // Add new adlist
     try {
-        $addresses = explode(' ', trim($_POST['address']));
+        $addresses = explode(' ', html_entity_decode(trim($_POST['address'])));
         $total = count($addresses);
         $added = 0;
 
@@ -751,7 +754,7 @@ function JSON_error($message = null)
             throw new Exception('While preparing statement: ' . $db->lastErrorMsg());
         }
 
-        $comment = $_POST['comment'];
+        $comment = html_entity_decode($_POST['comment']);
         if (strlen($comment) === 0) {
             // Store NULL in database for empty comments
             $comment = null;
@@ -800,7 +803,7 @@ function JSON_error($message = null)
             throw new Exception('While binding enabled: ' . $db->lastErrorMsg());
         }
 
-        $comment = $_POST['comment'];
+        $comment = html_entity_decode($_POST['comment']);
         if (strlen($comment) === 0) {
                 // Store NULL in database for empty comments
                 $comment = null;
diff --git a/scripts/pi-hole/php/teleporter.php b/scripts/pi-hole/php/teleporter.php
index 52951067ca..cfd4bc479c 100644
--- a/scripts/pi-hole/php/teleporter.php
+++ b/scripts/pi-hole/php/teleporter.php
@@ -173,7 +173,7 @@ function archive_restore_table($file, $table, $flush=false)
 	foreach($contents as $row)
 	{
 		// Limit max length for a domain entry to 253 chars
-		if(strlen($row[$field]) > 253)
+		if(isset($field) && strlen($row[$field]) > 253)
 			continue;
 
 		// Bind properties from JSON data
@@ -196,7 +196,7 @@ function archive_restore_table($file, $table, $flush=false)
 				default:
 					$sqltype = "UNK";
 			}
-			$stmt->bindValue(":".$key, $value, $sqltype);
+			$stmt->bindValue(":".$key, htmlentities($value), $sqltype);
 		}
 
 		if($stmt->execute() && $stmt->reset() && $stmt->clear())
diff --git a/settings.php b/settings.php
index 51292f4c89..06512b48c0 100644
--- a/settings.php
+++ b/settings.php
@@ -714,7 +714,7 @@ function convertseconds($argument)
                                                             title="Lease type: IPv<?php echo $lease["type"]; ?><br/>Remaining lease time: <?php echo $lease["TIME"]; ?><br/>DHCP UID: <?php echo $lease["clid"]; ?>">
                                                             <td id="MAC"><?php echo $lease["hwaddr"]; ?></td>
                                                             <td id="IP" data-order="<?php echo bin2hex(inet_pton($lease["IP"])); ?>"><?php echo $lease["IP"]; ?></td>
-                                                            <td id="HOST"><?php echo $lease["host"]; ?></td>
+                                                            <td id="HOST"><?php echo htmlentities($lease["host"]); ?></td>
                                                             <td>
                                                                 <button type="button" id="button" class="btn btn-warning btn-xs" data-static="alert">
                                                                     <span class="fas fas fa-file-import"></span>
@@ -742,7 +742,7 @@ function convertseconds($argument)
                                                         <tr>
                                                             <td><?php echo $lease["hwaddr"]; ?></td>
                                                             <td data-order="<?php echo bin2hex(inet_pton($lease["IP"])); ?>"><?php echo $lease["IP"]; ?></td>
-                                                            <td><?php echo $lease["host"]; ?></td>
+                                                            <td><?php echo htmlentities($lease["host"]); ?></td>
                                                             <td><?php if (strlen($lease["hwaddr"]) > 0) { ?>
                                                                 <button type="submit" class="btn btn-danger btn-xs" name="removestatic"
                                                                         value="<?php echo $lease["hwaddr"]; ?>">",
"url": "https://github.com/pi-hole/AdminLTE/commit/c949516ee15fa6a9b0c8511cc4c4d6b0893f3e69.patch"
},
{
"commit_message": "[PATCH] missed one (yes yes this can all be squashed) Signed-off-by: Adam Warner <me@adamwarner.co.uk> scripts/pi-hole/js/groups-clients.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA4ZjZlMTM2NWI2ZGVjMGFlMWFhMGIwYjE1YjEwMmM5MTMzZjM0N2U1IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBZGFtIFdhcm5lciA8bWVAYWRhbXdhcm5lci5jby51az4KRGF0ZTogU2F0LCAxMyBKdW4gMjAyMCAxNDozMTowOSArMDEwMApTdWJqZWN0OiBbUEFUQ0hdIG1pc3NlZCBvbmUgKHllcyB5ZXMgdGhpcyBjYW4gYWxsIGJlIHNxdWFzaGVkKQoKU2lnbmVkLW9mZi1ieTogQWRhbSBXYXJuZXIgPG1lQGFkYW13YXJuZXIuY28udWs+Ci0tLQogc2NyaXB0cy9waS1ob2xlL2pzL2dyb3Vwcy1jbGllbnRzLmpzIHwgMiArLQogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvc2NyaXB0cy9waS1ob2xlL2pzL2dyb3Vwcy1jbGllbnRzLmpzIGIvc2NyaXB0cy9waS1ob2xlL2pzL2dyb3Vwcy1jbGllbnRzLmpzCmluZGV4IDMyYTk0ZDRiM2UuLjcwZmY4MWZmMzkgMTAwNjQ0Ci0tLSBhL3NjcmlwdHMvcGktaG9sZS9qcy9ncm91cHMtY2xpZW50cy5qcworKysgYi9zY3JpcHRzL3BpLWhvbGUvanMvZ3JvdXBzLWNsaWVudHMuanMKQEAgLTMwMyw3ICszMDMsNyBAQCBmdW5jdGlvbiBlZGl0Q2xpZW50KCkgewogICB2YXIgdHIgPSAkKHRoaXMpLmNsb3Nlc3QoInRyIik7CiAgIHZhciBpZCA9IHRyLmF0dHIoImRhdGEtaWQiKTsKICAgdmFyIGdyb3VwcyA9IHRyLmZpbmQoIiNtdWx0aXNlbGVjdF8iICsgaWQpLnZhbCgpOwotICB2YXIgaXAgPSB0ci5maW5kKCIjaXBfIiArIGlkKS50ZXh0KCk7CisgIHZhciBpcCA9IHV0aWxzLmVzY2FwZUh0bWwodHIuZmluZCgiI2lwXyIgKyBpZCkudGV4dCgpKTsKICAgdmFyIG5hbWUgPSB1dGlscy5lc2NhcGVIdG1sKHRyLmZpbmQoIiNuYW1lXyIgKyBpZCkudGV4dCgpKTsKICAgdmFyIGNvbW1lbnQgPSB1dGlscy5lc2NhcGVIdG1sKHRyLmZpbmQoIiNjb21tZW50XyIgKyBpZCkudmFsKCkpOw==",
"url": "https://github.com/pi-hole/AdminLTE/commit/8f6e1365b6dec0ae1aa0b0b15b102c9133f347e5.patch"
}
] |
n/a
|
|
CVE-2022-31129
|
Inefficient Regular Expression Complexity in moment
|
moment is a JavaScript date library for parsing, validating, manipulating, and formatting dates. Affected versions of moment were found to use an inefficient parsing algorithm. Specifically using string-to-date parsing in moment (more specifically rfc2822 parsing, which is tried by default) has quadratic (N^2) complexity on specific inputs. Users may notice a noticeable slowdown is observed with inputs above 10k characters. Users who pass user-provided strings without sanity length checks to moment constructor are vulnerable to (Re)DoS attacks. The problem is patched in 2.29.4, the patch can be applied to all affected versions with minimal tweaking. Users are advised to upgrade. Users unable to upgrade should consider limiting date lengths accepted from user input.
|
[
{
"commit_message": "[PATCH] [bugfix] Fix redos in preprocessRFC2822 regex (#6015) * fix ReDoS in preprocessRFC2822 regex Fixes: [#2936](https://github.com/moment/moment/issues/6012) Disallow nested rfc2822 comments to prevent quadratic regex execution time (i.e each open bracket is considered at most twice). src/lib/create/from-string.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA5YTNiNTg5NGYzZDVkNjAyOTQ4YWM4YTAyZTRlZTUyOGE0OWNhM2EzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiAiS2hhbmcgVm8gKGRvdWJsZXZrYXkpIiA8NDU0MTExMTMrdm92aWtoYW5nY2R2QHVzZXJzLm5vcmVwbHkuZ2l0aHViLmNvbT4KRGF0ZTogV2VkLCA2IEp1bCAyMDIyIDIyOjI4OjI1ICswNzAwClN1YmplY3Q6IFtQQVRDSF0gW2J1Z2ZpeF0gRml4IHJlZG9zIGluIHByZXByb2Nlc3NSRkMyODIyIHJlZ2V4ICgjNjAxNSkKCiogZml4IFJlRG9TIGluIHByZXByb2Nlc3NSRkMyODIyIHJlZ2V4CgpGaXhlczogWyMyOTM2XShodHRwczovL2dpdGh1Yi5jb20vbW9tZW50L21vbWVudC9pc3N1ZXMvNjAxMikKCkRpc2FsbG93IG5lc3RlZCByZmMyODIyIGNvbW1lbnRzIHRvIHByZXZlbnQgcXVhZHJhdGljIHJlZ2V4IGV4ZWN1dGlvbiB0aW1lIChpLmUgZWFjaCBvcGVuIGJyYWNrZXQgaXMgY29uc2lkZXJlZCBhdCBtb3N0IHR3aWNlKS4KLS0tCiBzcmMvbGliL2NyZWF0ZS9mcm9tLXN0cmluZy5qcyB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL3NyYy9saWIvY3JlYXRlL2Zyb20tc3RyaW5nLmpzIGIvc3JjL2xpYi9jcmVhdGUvZnJvbS1zdHJpbmcuanMKaW5kZXggNWM0ZDExZjc0MC4uNTg3MzliOWQ3YyAxMDA2NDQKLS0tIGEvc3JjL2xpYi9jcmVhdGUvZnJvbS1zdHJpbmcuanMKKysrIGIvc3JjL2xpYi9jcmVhdGUvZnJvbS1zdHJpbmcuanMKQEAgLTE1MSw3ICsxNTEsNyBAQCBmdW5jdGlvbiB1bnRydW5jYXRlWWVhcih5ZWFyU3RyKSB7CiBmdW5jdGlvbiBwcmVwcm9jZXNzUkZDMjgyMihzKSB7CiAgICAgLy8gUmVtb3ZlIGNvbW1lbnRzIGFuZCBmb2xkaW5nIHdoaXRlc3BhY2UgYW5kIHJlcGxhY2UgbXVsdGlwbGUtc3BhY2VzIHdpdGggYSBzaW5nbGUgc3BhY2UKICAgICByZXR1cm4gcwotICAgICAgICAucmVwbGFjZSgvXChbXildKlwpfFtcblx0XS9nLCAnICcpCisgICAgICAgIC5yZXBsYWNlKC9cKFteKCldKlwpfFtcblx0XS9nLCAnICcpCiAgICAgICAgIC5yZXBsYWNlKC8oXHNccyspL2csICcgJykKICAgICAgICAgLnJlcGxhY2UoL15cc1xzKi8sICcnKQogICAgICAgICAucmVwbGFjZSgvXHNccyokLywgJycpOw==",
"url": "https://github.com/moment/moment/commit/9a3b5894f3d5d602948ac8a02e4ee528a49ca3a3.patch"
}
] |
CWE-400: Uncontrolled Resource Consumption
|
CVE-2024-47178
|
basic-auth-connect's callback uses time unsafe string comparison
|
basic-auth-connect is Connect's Basic Auth middleware in its own module. basic-auth-connect < 1.1.0 uses a timing-unsafe equality comparison that can leak timing information. This issue has been fixed in basic-auth-connect 1.1.0.
|
[
{
"commit_message": "[PATCH] feat: add timing safe equal comparison * chore: add tsscmp@1.0.6 as dependency * feat: add timing safe equal comparison Co-authored-by: Blake Embrey <hello@blakeembrey.com> index.js | 5 ++++- package.json | 7 +++++-- 2 files changed, 9 insertions(+), 3 deletions(-)",
"patch_text_b64": "RnJvbSBiYWMxZTZhODUzMGUxZWZkMDAyODgwMGI5YjU4OGEzN2FkYjBkMjAzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/VWxpc2VzPTIwR2FzYz1DMz1CM24/PSA8dWxpc2VzZ2FzY29uZ29uemFsZXpAZ21haWwuY29tPgpEYXRlOiBNb24sIDMwIFNlcCAyMDI0IDExOjU3OjIxICswMjAwClN1YmplY3Q6IFtQQVRDSF0gZmVhdDogYWRkIHRpbWluZyBzYWZlIGVxdWFsIGNvbXBhcmlzb24KCiogY2hvcmU6IGFkZCB0c3NjbXBAMS4wLjYgYXMgZGVwZW5kZW5jeQoqIGZlYXQ6IGFkZCB0aW1pbmcgc2FmZSBlcXVhbCBjb21wYXJpc29uCgpDby1hdXRob3JlZC1ieTogQmxha2UgRW1icmV5IDxoZWxsb0BibGFrZWVtYnJleS5jb20+Ci0tLQogaW5kZXguanMgICAgIHwgNSArKysrLQogcGFja2FnZS5qc29uIHwgNyArKysrKy0tCiAyIGZpbGVzIGNoYW5nZWQsIDkgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9pbmRleC5qcyBiL2luZGV4LmpzCmluZGV4IDc2OWFlNjAuLmNiODZkNWYgMTAwNjQ0Ci0tLSBhL2luZGV4LmpzCisrKyBiL2luZGV4LmpzCkBAIC0xLDMgKzEsNCBAQAordmFyIHRpbWluZ1NhZmVDb21wYXJlID0gcmVxdWlyZSgndHNzY21wJyk7CiB2YXIgaHR0cCA9IHJlcXVpcmUoJ2h0dHAnKTsKIAogLyohCkBAIC01Myw3ICs1NCw5IEBAIG1vZHVsZS5leHBvcnRzID0gZnVuY3Rpb24gYmFzaWNBdXRoKGNhbGxiYWNrLCByZWFsbSkgewogICAgIGlmICgnc3RyaW5nJyAhPSB0eXBlb2YgcGFzc3dvcmQpIHRocm93IG5ldyBFcnJvcigncGFzc3dvcmQgYXJndW1lbnQgcmVxdWlyZWQnKTsKICAgICByZWFsbSA9IGFyZ3VtZW50c1syXTsKICAgICBjYWxsYmFjayA9IGZ1bmN0aW9uKHVzZXIsIHBhc3MpewotICAgICAgcmV0dXJuIHVzZXIgPT0gdXNlcm5hbWUgJiYgcGFzcyA9PSBwYXNzd29yZDsKKyAgICAgIGNvbnN0IHVzZXJuYW1lVmFsaWQgPSB0aW1pbmdTYWZlQ29tcGFyZSh1c2VyLCB1c2VybmFtZSk7CisgICAgICBjb25zdCBwYXNzd29yZFZhbGlkID0gdGltaW5nU2FmZUNvbXBhcmUocGFzcywgcGFzc3dvcmQpOworICAgICAgcmV0dXJuIHVzZXJuYW1lVmFsaWQgJiYgcGFzc3dvcmRWYWxpZDsKICAgICB9CiAgIH0KIApkaWZmIC0tZ2l0IGEvcGFja2FnZS5qc29uIGIvcGFja2FnZS5qc29uCmluZGV4IGE1ZDdiMDAuLjc0OTk3MmIgMTAwNjQ0Ci0tLSBhL3BhY2thZ2UuanNvbgorKysgYi9wYWNrYWdlLmpzb24KQEAgLTE4LDEyICsxOCwxNSBAQAogICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL2V4cHJlc3Nqcy9iYXNpYy1hdXRoLWNvbm5lY3QvaXNzdWVzIgogICB9LAogICAiZGV2RGVwZW5kZW5jaWVzIjogeworICAgICJjb25uZWN0IjogIioiLAogICAgICJtb2NoYSI6ICIqIiwKICAgICAic2hvdWxkIjogIioiLAotICAgICJzdXBlcnRlc3QiOiAiKiIsCi0gICAgImNvbm5lY3QiOiAiKiIKKyAgICAic3VwZXJ0ZXN0IjogIioiCiAgIH0sCiAgICJzY3JpcHRzIjogewogICAgICJ0ZXN0IjogIm1ha2UgdGVzdCIKKyAgfSwKKyAgImRlcGVuZGVuY2llcyI6IHsKKyAgICAidHNzY21wIjogIl4xLjAuNiIKICAgfQogfQ==",
"url": "https://github.com/expressjs/basic-auth-connect/commit/bac1e6a8530e1efd0028800b9b588a37adb0d203.patch"
}
] |
CWE-208: Observable Timing Discrepancy
|
CVE-2021-31256
|
Memory leak in the stbl_GetSampleInfos function in MP4Box in GPAC 1.0.1 allows attackers to read memory via a crafted file.
|
[
{
"commit_message": "[PATCH] fixed #1705 src/isomedia/stbl_read.c | 2 ++ 1 file changed, 2 insertions(+)",
"patch_text_b64": "RnJvbSAyZGEyZjY4YmZmZDUxZDg5YjFkMjcyZDIyYWE4Y2MwMjNjMWMwNjZlIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBqZWFubGYgPGplYW5sZkBncGFjLmlvPgpEYXRlOiBGcmksIDEyIE1hciAyMDIxIDExOjQ2OjU2ICswMTAwClN1YmplY3Q6IFtQQVRDSF0gZml4ZWQgIzE3MDUKCi0tLQogc3JjL2lzb21lZGlhL3N0YmxfcmVhZC5jIHwgMiArKwogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL3NyYy9pc29tZWRpYS9zdGJsX3JlYWQuYyBiL3NyYy9pc29tZWRpYS9zdGJsX3JlYWQuYwppbmRleCBlYmZiZTYyYWJlLi4zODRkNGY3ODI3IDEwMDY0NAotLS0gYS9zcmMvaXNvbWVkaWEvc3RibF9yZWFkLmMKKysrIGIvc3JjL2lzb21lZGlhL3N0YmxfcmVhZC5jCkBAIC00MTksMTEgKzQxOSwxMyBAQCBHRl9FcnIgc3RibF9HZXRTYW1wbGVJbmZvcyhHRl9TYW1wbGVUYWJsZUJveCAqc3RibCwgdTMyIHNhbXBsZU51bWJlciwgdTY0ICpvZmZzZQogCQlpZiAoIHN0YmwtPkNodW5rT2Zmc2V0LT50eXBlID09IEdGX0lTT01fQk9YX1RZUEVfU1RDTykgewogCQkJc3RjbyA9IChHRl9DaHVua09mZnNldEJveCAqKXN0YmwtPkNodW5rT2Zmc2V0OwogCQkJaWYgKCFzdGNvLT5vZmZzZXRzKSByZXR1cm4gR0ZfSVNPTV9JTlZBTElEX0ZJTEU7CisJCQlpZiAoc3Rjby0+bmJfZW50cmllcyA8IHNhbXBsZU51bWJlcikgcmV0dXJuIEdGX0lTT01fSU5WQUxJRF9GSUxFOwogCiAJCQkoKm9mZnNldCkgPSAodTY0KSBzdGNvLT5vZmZzZXRzW3NhbXBsZU51bWJlciAtIDFdOwogCQl9IGVsc2UgewogCQkJY282NCA9IChHRl9DaHVua0xhcmdlT2Zmc2V0Qm94ICopc3RibC0+Q2h1bmtPZmZzZXQ7CiAJCQlpZiAoIWNvNjQtPm9mZnNldHMpIHJldHVybiBHRl9JU09NX0lOVkFMSURfRklMRTsKKwkJCWlmIChjbzY0LT5uYl9lbnRyaWVzIDwgc2FtcGxlTnVtYmVyKSByZXR1cm4gR0ZfSVNPTV9JTlZBTElEX0ZJTEU7CiAKIAkJCSgqb2Zmc2V0KSA9IGNvNjQtPm9mZnNldHNbc2FtcGxlTnVtYmVyIC0gMV07CiAJCX0=",
"url": "https://github.com/gpac/gpac/commit/2da2f68bffd51d89b1d272d22aa8cc023c1c066e.patch"
}
] |
n/a
|
|
GHSA-qc3q-8rr8-8p5v
|
Cross site scripting in opencart
| null |
[
{
"commit_message": "[PATCH] added login to comment upload/catalog/controller/account/login.php | 12 +++++++--- upload/catalog/controller/cms/comment.php | 20 ++++++++++------ upload/catalog/controller/startup/seo_url.php | 6 ++--- .../catalog/view/template/account/login.twig | 6 ++--- upload/catalog/view/template/cms/comment.twig | 8 ++++--- .../view/template/cms/comment_list.twig | 24 +++++++------------ .../view/template/cms/comment_reply.twig | 2 +- 7 files changed, 42 insertions(+), 36 deletions(-)",
"patch_text_b64": "From 0fd1ee4b6c94366bf3e5d3831a8336f3275d1860 Mon Sep 17 00:00:00 2001
From: Daniel Kerr <webmaster@opencart.com>
Date: Fri, 5 Jan 2024 11:26:12 +0800
Subject: [PATCH] added login to comment

---
 upload/catalog/controller/account/login.php   | 12 +++++++---
 upload/catalog/controller/cms/comment.php     | 20 ++++++++++------
 upload/catalog/controller/startup/seo_url.php |  6 ++---
 .../catalog/view/template/account/login.twig  |  6 ++---
 upload/catalog/view/template/cms/comment.twig |  8 ++++---
 .../view/template/cms/comment_list.twig       | 24 +++++++------------
 .../view/template/cms/comment_reply.twig      |  2 +-
 7 files changed, 42 insertions(+), 36 deletions(-)

diff --git a/upload/catalog/controller/account/login.php b/upload/catalog/controller/account/login.php
index d2924893687..6b7f0dadda7 100644
--- a/upload/catalog/controller/account/login.php
+++ b/upload/catalog/controller/account/login.php
@@ -77,7 +77,7 @@ public function index(): void {
 
 			unset($this->session->data['redirect']);
 		} elseif (isset($this->request->get['redirect'])) {
-			$data['redirect'] = urldecode($this->request->get['redirect']);
+			$data['redirect'] = $this->request->get['redirect'];
 		} else {
 			$data['redirect'] = '';
 		}
@@ -186,9 +186,15 @@ public function login(): void {
 
 			$this->model_account_customer->deleteLoginAttempts($this->request->post['email']);
 
+			if (isset($this->request->post['redirect'])) {
+				$redirect = urldecode($this->request->post['redirect']);
+			} else {
+				$redirect = '';
+			}
+
 			// Added strpos check to pass McAfee PCI compliance test (http://forum.opencart.com/viewtopic.php?f=10&t=12043&p=151494#p151295)
-			if (isset($this->request->post['redirect']) && str_starts_with(html_entity_decode($this->request->post['redirect'], ENT_QUOTES, 'UTF-8'), $this->config->get('config_url'))) {
-				$json['redirect'] = html_entity_decode($this->request->post['redirect'], ENT_QUOTES, 'UTF-8') . '&customer_token=' . $this->session->data['customer_token'];
+			if ($redirect && str_starts_with($redirect, $this->config->get('config_url'))) {
+				$json['redirect'] = $redirect . '&customer_token=' . $this->session->data['customer_token'];
 			} else {
 				$json['redirect'] = $this->url->link('account/account', 'language=' . $this->config->get('config_language') . '&customer_token=' . $this->session->data['customer_token'], true);
 			}
diff --git a/upload/catalog/controller/cms/comment.php b/upload/catalog/controller/cms/comment.php
index 334e2260f66..f0a8b1ba577 100644
--- a/upload/catalog/controller/cms/comment.php
+++ b/upload/catalog/controller/cms/comment.php
@@ -37,7 +37,7 @@ public function index(): string {
 		}
 
 		$data['logged'] = $this->customer->isLogged();
-		$data['login'] = $this->url->link('account/login', 'language=' . $this->config->get('config_language'));
+		$data['login'] = $this->url->link('account/login', 'language=' . $this->config->get('config_language') . '&page=' . $page . '&redirect=' . urlencode($this->url->link('cms/blog.info', 'language=' . $this->config->get('config_language') . '&article_id=' . $data['article_id'], true)));
 
 		$this->session->data['comment_token'] = oc_token(32);
 
@@ -180,7 +180,7 @@ public function getList(): string {
 		$data['refresh'] = $this->url->link('cms/comment.list', 'language=' . $this->config->get('config_language') . '&article_id=' . $article_id . '&page=' . $page, true);
 
 		$data['logged'] = $this->customer->isLogged();
-
+		$data['login'] = $this->url->link('account/login', 'language=' . $this->config->get('config_language') . '&redirect=' . urlencode($this->url->link('cms/blog.info', 'language=' . $this->config->get('config_language') . '&article_id=' . $article_id, true)));
 
 		return $this->load->view('cms/comment_list', $data);
 	}
@@ -420,10 +420,20 @@ public function rating(): void {
 			$article_comment_id = 0;
 		}
 
+		if (isset($this->request->get['rating'])) {
+			$rating = (bool)$this->request->get['rating'];
+		} else {
+			$rating = 0;
+		}
+
 		if (!isset($this->request->get['comment_token']) || !isset($this->session->data['comment_token']) || $this->request->get['comment_token'] != $this->session->data['comment_token']) {
 			$json['error'] = $this->language->get('error_token');
 		}
 
+		if (!$this->customer->isLogged()) {
+			$json['error'] = $this->language->get('error_login');
+		}
+
 		$this->load->model('cms/article');
 
 		$article_info = $this->model_cms_article->getArticle($article_id);
@@ -439,16 +449,12 @@ public function rating(): void {
 			$json['error'] = $this->language->get('error_article_comment');
 		}
 
-		if (!$this->customer->isLogged() && !$this->config->get('config_comment_guest')) {
-			$json['error'] = $this->language->get('error_login');
-		}
-
 		if (!$json) {
 			// Anti-Spam
 			$rating_data = $this->request->post + [
 				'article_comment_id' => $article_comment_id,
 				'customer_id'        => $this->customer->getId(),
-				'rating'             => (bool)$this->request->get['rating'],
+				'rating'             => $rating,
 				'ip'                 => $this->request->server['REMOTE_ADDR']
 			];
 
diff --git a/upload/catalog/controller/startup/seo_url.php b/upload/catalog/controller/startup/seo_url.php
index d67d67118ec..2bfd57fef77 100644
--- a/upload/catalog/controller/startup/seo_url.php
+++ b/upload/catalog/controller/startup/seo_url.php
@@ -81,10 +81,10 @@ public function rewrite(string $link): string {
 		$paths = [];
 
 		// Parse the query into its separate parts
-		$parts = explode('&', $url_info['query']);
+		$queries = explode('&', $url_info['query']);
 
-		foreach ($parts as $part) {
-			$pair = explode('=', $part);
+		foreach ($queries as $query) {
+			$pair = explode('=', $query);
 
 			if (isset($pair[0])) {
 				$key = (string)$pair[0];
diff --git a/upload/catalog/view/template/account/login.twig b/upload/catalog/view/template/account/login.twig
index e98b5280afb..0402e9b75b9 100644
--- a/upload/catalog/view/template/account/login.twig
+++ b/upload/catalog/view/template/account/login.twig
@@ -38,12 +38,12 @@
                 <input type="password" name="password" value="{{ password }}" placeholder="{{ entry_password }}" id="input-password" class="form-control mb-1"/>
                 <a href="{{ forgotten }}">{{ text_forgotten }}</a>
               </div>
-              <div class="text-end">
-                <button type="submit" class="btn btn-primary">{{ button_login }}</button>
-              </div>
               {% if redirect %}
                 <input type="hidden" name="redirect" value="{{ redirect }}"/>
               {% endif %}
+              <div class="text-end">
+                <button type="submit" class="btn btn-primary">{{ button_login }}</button>
+              </div>
             </form>
           </div>
         </div>
diff --git a/upload/catalog/view/template/cms/comment.twig b/upload/catalog/view/template/cms/comment.twig
index d5e8a668231..1d261f03517 100644
--- a/upload/catalog/view/template/cms/comment.twig
+++ b/upload/catalog/view/template/cms/comment.twig
@@ -1,10 +1,12 @@
 <div class="text-center">
-  <button type="button" value="{{ like }}" id="input-rating-like" data-oc-toggle="rate" class="btn btn-secondary"><i class="fa fa-thumbs-up"></i></button>
-  <button type="button" value="{{ dislike }}" id="input-rating-dislike" data-oc-toggle="rate" class="btn btn-secondary"><i class="fa fa-thumbs-down"></i></button>
   {% if logged %}
+    <button type="button" value="{{ like }}" id="input-rating-like" data-oc-toggle="rate" class="btn btn-secondary"><i class="fa fa-thumbs-up"></i></button>
+    <button type="button" value="{{ dislike }}" id="input-rating-dislike" data-oc-toggle="rate" class="btn btn-secondary"><i class="fa fa-thumbs-down"></i></button>
     <button type="button" value="{{ comment_add }}" data-oc-toggle="comment" data-oc-target="#comment-0" data-oc-trigger="#button-refresh" class="btn btn-secondary">{{ button_comment }}</button>
   {% else %}
-    <a href="" class="btn btn-secondary">{{ button_login }}</a>
+    <a href="{{ login }}" class="btn btn-secondary"><i class="fa fa-thumbs-up"></i></a>
+    <a href="{{ login }}" class="btn btn-secondary"><i class="fa fa-thumbs-down"></i></a>
+    <a href="{{ login }}" class="btn btn-secondary">{{ button_login }}</a>
   {% endif %}
 </div>
 <hr/>
diff --git a/upload/catalog/view/template/cms/comment_list.twig b/upload/catalog/view/template/cms/comment_list.twig
index 20dfe57919f..e98e45f9f71 100644
--- a/upload/catalog/view/template/cms/comment_list.twig
+++ b/upload/catalog/view/template/cms/comment_list.twig
@@ -2,40 +2,32 @@
   {% if comments %}
     {% for comment in comments %}
       <div id="comment-{{ comment.article_comment_id }}" class="border mb-3">
-
         <div class="p-2">
           <p>{{ text_by }} {{ comment.author }} - {{ comment.date_added }}</p>
           <p>{{ comment.comment }}</p>
           <div class="text-end">
-
-            <button type="button" value="{{ comment.like }}" data-oc-toggle="rate" class="btn btn-secondary"><i class="fa fa-thumbs-up"></i></button>
-            <button type="button" value="{{ comment.dislike }}" data-oc-toggle="rate" class="btn btn-secondary"><i class="fa fa-thumbs-down"></i></button>
-
-            {% if comment_guest %}
+            {% if logged %}
+              <button type="button" value="{{ comment.like }}" data-oc-toggle="rate" class="btn btn-secondary"><i class="fa fa-thumbs-up"></i></button>
+              <button type="button" value="{{ comment.dislike }}" data-oc-toggle="rate" class="btn btn-secondary"><i class="fa fa-thumbs-down"></i></button>
               <button type="button" value="{{ comment.reply_add }}" data-oc-toggle="comment" data-oc-target="#reply-{{ comment.article_comment_id }}" data-oc-trigger="#button-refresh-{{ comment.article_comment_id }}" class="btn btn-secondary">{{ button_reply }}</button>
             {% else %}
-              <button type="button" class="btn btn-secondary" disabled="disabled">{{ button_reply }}</button>
+              <a href="{{ login }}" class="btn btn-secondary"><i class="fa fa-thumbs-up"></i></a>
+              <a href="{{ login }}" class="btn btn-secondary"><i class="fa fa-thumbs-down"></i></a>
+              <a href="{{ login }}" class="btn btn-secondary">{{ button_login_reply }}</a>
             {% endif %}
-
           </div>
         </div>
-
         <div id="reply-{{ comment.article_comment_id }}">
-
           <div id="reply-{{ comment.article_comment_id }}-0"></div>
-
           <div class="text-center p-2 border-top">
-            <button type="button" value="{{ comment.reply }}" id="button-refresh-{{ comment.article_comment_id }}" data-oc-toggle="refresh" data-oc-target="#reply-{{ comment.article_comment_id }}-0" class="btn btn-secondary"><i class="fa fa-sync"></i></button>
-
+            <button type="button" value="{{ comment.reply }}" id="button-refresh-{{ comment.article_comment_id }}" data-oc-toggle="refresh" data-oc-target="#reply-{{ comment.article_comment_id }}-0" class="btn btn-secondary d-none"><i class="fa fa-sync"></i></button>
             {% if comment.reply_total %}
               <button type="button" value="{{ comment.reply }}" data-oc-toggle="next" class="btn btn-secondary">{{ button_replies }} ({{ comment.reply_total }})</button>
             {% else %}
               <button type="button" class="btn btn-secondary" disabled>{{ button_replies }}</button>
             {% endif %}
-
           </div>
         </div>
-
       </div>
     {% endfor %}
     <div class="row">
@@ -47,7 +39,7 @@
   {% endif %}
 </div>
 <div class="text-center p-2">
-  <button type="button" value="{{ refresh }}" id="button-refresh" data-oc-toggle="refresh" data-oc-target="#comment-0" class="btn btn-secondary"><i class="fa fa-sync"></i></button>
+  <button type="button" value="{{ refresh }}" id="button-refresh" data-oc-toggle="refresh" data-oc-target="#comment-0" class="btn btn-secondary d-none"><i class="fa fa-sync"></i></button>
 </div>
 
 
diff --git a/upload/catalog/view/template/cms/comment_reply.twig b/upload/catalog/view/template/cms/comment_reply.twig
index 71566cd5c2b..f0da2b85d2b 100644
--- a/upload/catalog/view/template/cms/comment_reply.twig
+++ b/upload/catalog/view/template/cms/comment_reply.twig
@@ -9,7 +9,7 @@
   </div>
 {% endif %}
 <div class="text-center p-2 border-top">
-  <button type="button" value="{{ refresh }}" id="button-refresh-{{ parent_id }}" data-oc-toggle="refresh" data-oc-target="#reply-{{ parent_id }}-{{ page }}" class="btn btn-secondary"><i class="fa fa-sync"></i></button>
+  <button type="button" value="{{ refresh }}" id="button-refresh-{{ parent_id }}" data-oc-toggle="refresh" data-oc-target="#reply-{{ parent_id }}-{{ page }}" class="btn btn-secondary d-none"><i class="fa fa-sync"></i></button>
   {% if not replies %}
     <button type="button" class="btn btn-secondary" disabled>{{ button_replies }}</button>
   {% elseif next %}",
"url": "https://github.com/opencart/opencart/commit/0fd1ee4b6c94366bf3e5d3831a8336f3275d1860.patch"
}
] | null |
GHSA-gjhx-wc4x-rwwp
| null |
[
{
"commit_message": "[PATCH] hw/nvme: fix null pointer access in directive receive nvme_directive_receive() does not check if an endurance group has been configured (set) prior to testing if flexible data placement is enabled or not. Fix this. Cc: qemu-stable@nongnu.org Resolves: https://gitlab.com/qemu-project/qemu/-/issues/1815 Fixes: 73064edfb864 (\"hw/nvme: flexible data placement emulation\") Reviewed-by: Jesper Wendel Devantier <j.devantier@samsung.com> Signed-off-by: Klaus Jensen <k.jensen@samsung.com> hw/nvme/ctrl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA2YzhmODQ1NmNiMGIyMzk4MTJkZWU1MjExODgxNDI2NDk2ZGE3Yjk4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBLbGF1cyBKZW5zZW4gPGsuamVuc2VuQHNhbXN1bmcuY29tPgpEYXRlOiBUdWUsIDggQXVnIDIwMjMgMTc6MTY6MTMgKzAyMDAKU3ViamVjdDogW1BBVENIXSBody9udm1lOiBmaXggbnVsbCBwb2ludGVyIGFjY2VzcyBpbiBkaXJlY3RpdmUgcmVjZWl2ZQoKbnZtZV9kaXJlY3RpdmVfcmVjZWl2ZSgpIGRvZXMgbm90IGNoZWNrIGlmIGFuIGVuZHVyYW5jZSBncm91cCBoYXMgYmVlbgpjb25maWd1cmVkIChzZXQpIHByaW9yIHRvIHRlc3RpbmcgaWYgZmxleGlibGUgZGF0YSBwbGFjZW1lbnQgaXMgZW5hYmxlZApvciBub3QuCgpGaXggdGhpcy4KCkNjOiBxZW11LXN0YWJsZUBub25nbnUub3JnClJlc29sdmVzOiBodHRwczovL2dpdGxhYi5jb20vcWVtdS1wcm9qZWN0L3FlbXUvLS9pc3N1ZXMvMTgxNQpGaXhlczogNzMwNjRlZGZiODY0ICgiaHcvbnZtZTogZmxleGlibGUgZGF0YSBwbGFjZW1lbnQgZW11bGF0aW9uIikKUmV2aWV3ZWQtYnk6IEplc3BlciBXZW5kZWwgRGV2YW50aWVyIDxqLmRldmFudGllckBzYW1zdW5nLmNvbT4KU2lnbmVkLW9mZi1ieTogS2xhdXMgSmVuc2VuIDxrLmplbnNlbkBzYW1zdW5nLmNvbT4KLS0tCiBody9udm1lL2N0cmwuYyB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2h3L252bWUvY3RybC5jIGIvaHcvbnZtZS9jdHJsLmMKaW5kZXggZDIxN2FlOTFiNS4uZTViNWM3MDM0ZCAxMDA2NDQKLS0tIGEvaHcvbnZtZS9jdHJsLmMKKysrIGIvaHcvbnZtZS9jdHJsLmMKQEAgLTY5MDAsNyArNjkwMCw3IEBAIHN0YXRpYyB1aW50MTZfdCBudm1lX2RpcmVjdGl2ZV9yZWNlaXZlKE52bWVDdHJsICpuLCBOdm1lUmVxdWVzdCAqcmVxKQogICAgIGNhc2UgTlZNRV9ESVJFQ1RJVkVfSURFTlRJRlk6CiAgICAgICAgIHN3aXRjaCAoZG9wZXIpIHsKICAgICAgICAgY2FzZSBOVk1FX0RJUkVDVElWRV9SRVRVUk5fUEFSQU1TOgotICAgICAgICAgICAgaWYgKG5zLT5lbmRncnAtPmZkcC5lbmFibGVkKSB7CisgICAgICAgICAgICBpZiAobnMtPmVuZGdycCAmJiBucy0+ZW5kZ3JwLT5mZHAuZW5hYmxlZCkgewogICAgICAgICAgICAgICAgIGlkLnN1cHBvcnRlZCB8PSAxIDw8IE5WTUVfRElSRUNUSVZFX0RBVEFfUExBQ0VNRU5UOwogICAgICAgICAgICAgICAgIGlkLmVuYWJsZWQgfD0gMSA8PCBOVk1FX0RJUkVDVElWRV9EQVRBX1BMQUNFTUVOVDsKICAgICAgICAgICAgICAgICBpZC5wZXJzaXN0ZW50IHw9IDEgPDwgTlZNRV9ESVJFQ1RJVkVfREFUQV9QTEFDRU1FTlQ7Ci0tIApHaXRMYWI=",
"url": "https://gitlab.com/birkelund/qemu/-/commit/6c8f8456cb0b239812dee5211881426496da7b98"
}
] | null |
|
GHSA-mc7w-4cjf-c973
|
OS Command Injection in node-opencv
| null |
[
{
"commit_message": "[PATCH] Remove untrusted input to exec utils/find-opencv.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/peterbraden/node-opencv/commit/81a4b8620188e89f7e4fc985f3c89b58d4bcc86b.patch"
},
{
"commit_message": "[PATCH] Fix install script README.md | 3 +-- src/FaceRecognizer.h | 1 + utils/find-opencv.js | 9 ++++++++- 3 files changed, 10 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/peterbraden/node-opencv/commit/aaece6921d7368577511f06c94c99dd4e9653563.patch"
}
] | null |
CVE-2020-9757
|
The SEOmatic component before 3.3.0 for Craft CMS allows Server-Side Template Injection that leads to RCE via malformed data to the metacontainers controller.
|
[
{
"commit_message": "[PATCH] Version 3.3.0 CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+)",
"patch_text_b64": "RnJvbSA2NWFiNjU5Y2I2YzkxNGM3YWQ2NzFhZjFlNDE3YzBkYTI0MzFmNzliIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZXcgV2VsY2ggPGFuZHJld0BrZWx1bGkubG9jYWw+CkRhdGU6IE1vbiwgMjcgQXByIDIwMjAgMTk6MjU6MTIgLTA0MDAKU3ViamVjdDogW1BBVENIXSBWZXJzaW9uIDMuMy4wCgotLS0KIENIQU5HRUxPRy5tZCB8IDMgKysrCiAxIGZpbGUgY2hhbmdlZCwgMyBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvQ0hBTkdFTE9HLm1kIGIvQ0hBTkdFTE9HLm1kCmluZGV4IDczYjM0OWFmZi4uOTBhZDA0ZGZmIDEwMDY0NAotLS0gYS9DSEFOR0VMT0cubWQKKysrIGIvQ0hBTkdFTE9HLm1kCkBAIC0xOCw2ICsxOCw5IEBACiAqIE5vIGxvbmdlciBkZWxldGUgY2FjaGVzICBpbiByZXNwb25zZSB0byBgVGVtcGxhdGVDYWNoZXM6OkVWRU5UX0FGVEVSX0RFTEVURV9DQUNIRVNgCiAqIEZpeGVkIGFuIGlzc3VlIHdoZXJlIFNFTyBwcmV2aWV3cyBjb3VsZCBoYXZlIHRoZSB3cm9uZyBVUkxzIGZvciBtdWx0aS1zaXRlIHNldHVwcwogCisjIyMgU2VjdXJpdHkKKyogRml4ZWQgYSByZWdyZXNzaW9uIHdoZXJlIG1hbGZvcm1lZCBkYXRhIHBhc3NlZCB0byB0aGUgbWV0YWNvbnRhaW5lcnMgY29udHJvbGxlciBjb3VsZCByZXN1bHQgaW4gU1NUSSB3aGljaCBsZWFkcyB0byBpbmZvcm1hdGlvbiBkaXNjbG9zdXJlCisKICMjIDMuMi41MSAtIDIwMjAuMDQuMDYKICMjIyBBZGRlZAogKiBVcGRhdGVkIHRvIFtTY2hlbWEub3JnIDcuMC4zXShodHRwczovL3NjaGVtYS5vcmcvdmVyc2lvbi83LjAzL3NjaGVtYS1hbGwuaHRtbCkgaW5jbHVkaW5nIFtTcGVjaWFsQW5ub3VuY2VtZW50XShodHRwczovL3dlYm1hc3RlcnMuZ29vZ2xlYmxvZy5jb20vMjAyMC8wNC9oaWdobGlnaHQtY292aWQtMTktYW5ub3VuY2VtZW50cy1zZWFyY2guaHRtbCkgYW5kIG90aGVyIHR5cGVzL2NoYW5nZXMgdG8gaGFuZGxlIHRoZSBDT1ZJRC0xOSBjcmlzaXM=",
"url": "https://github.com/nystudio107/craft-seomatic/commit/65ab659cb6c914c7ad671af1e417c0da2431f79b.patch"
},
{
"commit_message": "[PATCH] Version 3.2.46 Signed-off-by: Andrew Welch <andrew@nystudio107.com> CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSBhMWMyY2FkN2UxMjYxMzJkMjQ0MmVjOGVjOGU5YWI0M2RmMDJjYzBmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZXcgV2VsY2ggPGFuZHJld0BueXN0dWRpbzEwNy5jb20+CkRhdGU6IFR1ZSwgMyBNYXIgMjAyMCAyMjowMjoxMyArMTEwMApTdWJqZWN0OiBbUEFUQ0hdIFZlcnNpb24gMy4yLjQ2CgpTaWduZWQtb2ZmLWJ5OiBBbmRyZXcgV2VsY2ggPGFuZHJld0BueXN0dWRpbzEwNy5jb20+Ci0tLQogQ0hBTkdFTE9HLm1kIHwgMiArLQogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvQ0hBTkdFTE9HLm1kIGIvQ0hBTkdFTE9HLm1kCmluZGV4IGIwMWEwNzYwMi4uZmQzNjM4YjY3IDEwMDY0NAotLS0gYS9DSEFOR0VMT0cubWQKKysrIGIvQ0hBTkdFTE9HLm1kCkBAIC01LDcgKzUsNyBAQAogKiBGaXhlZCBzb21lIGRhdGVzIHRvIGRhdGVDcmVhdGVkIGFzIGNhdGVnb3JpZXMgZG9lc24ndCBoYXZlIHBvc3REYXRlCiAKICMjIyBTZWN1cml0eQotKiBGaXhlZCBhbiBpc3N1ZSB3aGVyZSBtYWxmb3JtZWQgZGF0YSBwYXNzZWQgdG8gdGhlIG1ldGFjb250YWluZXJzIGNvbnRyb2xsZXIgY291bGQgcmVzdWx0IGluIFhTUworKiBGaXhlZCBhbiBpc3N1ZSB3aGVyZSBtYWxmb3JtZWQgZGF0YSBwYXNzZWQgdG8gdGhlIG1ldGFjb250YWluZXJzIGNvbnRyb2xsZXIgY291bGQgcmVzdWx0IGluIFNTVEkgd2hpY2ggbGVhZHMgdG8gaW5mb3JtYXRpb24gZGlzY2xvc3VyZQogCiAjIyAzLjIuNDUgLSAyMDIwLjAyLjI4CiAjIyMgQWRkZWQ=",
"url": "https://github.com/nystudio107/craft-seomatic/commit/a1c2cad7e126132d2442ec8ec8e9ab43df02cc0f.patch"
}
] |
n/a
|
|
CVE-2015-10116
|
RealFaviconGenerator Favicon Plugin class-favicon-by-realfavicongenerator-admin.php install_new_favicon cross-site request forgery
|
A vulnerability classified as problematic has been found in RealFaviconGenerator Favicon Plugin up to 1.2.12 on WordPress. This affects the function install_new_favicon of the file admin/class-favicon-by-realfavicongenerator-admin.php. The manipulation leads to cross-site request forgery. It is possible to initiate the attack remotely. Upgrading to version 1.2.13 is able to address this issue. The identifier of the patch is 949a1ae7216216350458844f50a72f100b56d4e7. It is recommended to upgrade the affected component. The identifier VDB-230661 was assigned to this vulnerability.
|
[
{
"commit_message": "[PATCH] XSS vulnerability fixed, reported by Kacper Szurek git-svn-id: https://plugins.svn.wordpress.org/favicon-by-realfavicongenerator/trunk@1125286 b8457f37-d9ea-0310-8a92-e5e31aec5664 README.txt | 8 +++-- ...-favicon-by-realfavicongenerator-admin.php | 35 +++++++++++++------ admin/views/appearance.php | 1 + favicon-by-realfavicongenerator.php | 2 +- 4 files changed, 33 insertions(+), 13 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/wp-plugins/favicon-by-realfavicongenerator/commit/949a1ae7216216350458844f50a72f100b56d4e7.patch"
}
] |
CWE-352 Cross-Site Request Forgery
|
CVE-2024-28233
|
XSS in JupyterHub via Self-XSS leveraged by Cookie Tossing
|
JupyterHub is an open source multi-user server for Jupyter notebooks. By tricking a user into visiting a malicious subdomain, the attacker can achieve an XSS directly affecting the former's session. More precisely, in the context of JupyterHub, this XSS could achieve full access to JupyterHub API and user's single-user server. The affected configurations are single-origin JupyterHub deployments and JupyterHub deployments with user-controlled applications running on subdomains or peer subdomains of either the Hub or a single-user server. This vulnerability is fixed in 4.1.0.
|
[
{
"commit_message": "[PATCH] 4.1.0 .github/workflows/test.yml | 3 + docs/source/explanation/websecurity.md | 178 ++++++++++++++-- docs/source/reference/changelog.md | 51 +++++ jupyterhub/_xsrf_utils.py | 210 +++++++++++++++++++ jupyterhub/apihandlers/base.py | 11 +- jupyterhub/app.py | 22 ++ jupyterhub/handlers/base.py | 102 +++++++-- jupyterhub/services/auth.py | 244 ++++++++++++++++++++-- jupyterhub/singleuser/extension.py | 22 +- jupyterhub/singleuser/mixins.py | 24 +-- jupyterhub/spawner.py | 5 + jupyterhub/tests/browser/test_browser.py | 253 +++++++++++++++++++++-- jupyterhub/tests/mocking.py | 25 ++- jupyterhub/tests/test_api.py | 11 +- jupyterhub/tests/test_pages.py | 26 ++- jupyterhub/tests/test_services_auth.py | 6 +- jupyterhub/tests/test_singleuser.py | 41 ++-- jupyterhub/tests/utils.py | 13 +- jupyterhub/user.py | 3 + jupyterhub/utils.py | 16 ++ 20 files changed, 1131 insertions(+), 135 deletions(-) create mode 100644 jupyterhub/_xsrf_utils.py",
"patch_text_b64": "From 3fa60e6849668ec1be35082d7f6e81f3db96222d Mon Sep 17 00:00:00 2001
From: Min RK <benjaminrk@gmail.com>
Date: Tue, 19 Mar 2024 12:55:10 +0100
Subject: [PATCH] 4.1.0

---
 .github/workflows/test.yml               |   3 +
 docs/source/explanation/websecurity.md   | 178 ++++++++++++++--
 docs/source/reference/changelog.md       |  51 +++++
 jupyterhub/_xsrf_utils.py                | 210 +++++++++++++++++++
 jupyterhub/apihandlers/base.py           |  11 +-
 jupyterhub/app.py                        |  22 ++
 jupyterhub/handlers/base.py              | 102 +++++++--
 jupyterhub/services/auth.py              | 244 ++++++++++++++++++++--
 jupyterhub/singleuser/extension.py       |  22 +-
 jupyterhub/singleuser/mixins.py          |  24 +--
 jupyterhub/spawner.py                    |   5 +
 jupyterhub/tests/browser/test_browser.py | 253 +++++++++++++++++++++--
 jupyterhub/tests/mocking.py              |  25 ++-
 jupyterhub/tests/test_api.py             |  11 +-
 jupyterhub/tests/test_pages.py           |  26 ++-
 jupyterhub/tests/test_services_auth.py   |   6 +-
 jupyterhub/tests/test_singleuser.py      |  41 ++--
 jupyterhub/tests/utils.py                |  13 +-
 jupyterhub/user.py                       |   3 +
 jupyterhub/utils.py                      |  16 ++
 20 files changed, 1131 insertions(+), 135 deletions(-)
 create mode 100644 jupyterhub/_xsrf_utils.py

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 5e248b5f4e..9c06694a41 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -100,6 +100,9 @@ jobs:
             subset: singleuser
           - python: "3.11"
             browser: browser
+          - python: "3.11"
+            subdomain: subdomain
+            browser: browser
           - python: "3.11"
             main_dependencies: main_dependencies
 
diff --git a/docs/source/explanation/websecurity.md b/docs/source/explanation/websecurity.md
index d497018727..854ff1f115 100644
--- a/docs/source/explanation/websecurity.md
+++ b/docs/source/explanation/websecurity.md
@@ -16,7 +16,8 @@ works.
 
 JupyterHub is designed to be a _simple multi-user server for modestly sized
 groups_ of **semi-trusted** users. While the design reflects serving
-semi-trusted users, JupyterHub can also be suitable for serving **untrusted** users.
+semi-trusted users, JupyterHub can also be suitable for serving **untrusted** users,
+but **is not suitable for untrusted users** in its default configuration.
 
 As a result, using JupyterHub with **untrusted** users means more work by the
 administrator, since much care is required to secure a Hub, with extra caution on
@@ -52,33 +53,67 @@ ensure that:
     their single-user server;
   - the modification of the configuration of the notebook server
     (the `~/.jupyter` or `JUPYTER_CONFIG_DIR` directory).
+  - unrestricted selection of the base environment (e.g. the image used in container-based Spawners)
 
 If any additional services are run on the same domain as the Hub, the services
 **must never** display user-authored HTML that is neither _sanitized_ nor _sandboxed_
-(e.g. IFramed) to any user that lacks authentication as the author of a file.
+to any user that lacks authentication as the author of a file.
+
+### Sharing access to servers
+
+Because sharing access to servers (via `access:servers` scopes or the sharing feature in JupyterHub 5) by definition means users can serve each other files, enabling sharing is not suitable for untrusted users without also enabling per-user domains.
+
+JupyterHub does not enable any sharing by default.
 
 ## Mitigate security issues
 
 The several approaches to mitigating security issues with configuration
 options provided by JupyterHub include:
 
-### Enable subdomains
+### Enable user subdomains
 
 JupyterHub provides the ability to run single-user servers on their own
-subdomains. This means the cross-origin protections between servers has the
-desired effect, and user servers and the Hub are protected from each other. A
-user's single-user server will be at `username.jupyter.mydomain.com`. This also
-requires all user subdomains to point to the same address, which is most easily
-accomplished with wildcard DNS. Since this spreads the service across multiple
-domains, you will need wildcard SSL as well. Unfortunately, for many
-institutional domains, wildcard DNS and SSL are not available. **If you do plan
-to serve untrusted users, enabling subdomains is highly encouraged**, as it
-resolves the cross-site issues.
+domains. This means the cross-origin protections between servers has the
+desired effect, and user servers and the Hub are protected from each other.
+
+**Subdomains are the only way to reliably isolate user servers from each other.**
+
+To enable subdomains, set:
+
+```python
+c.JupyterHub.subdomain_host = "https://jupyter.example.org"
+```
+
+When subdomains are enabled, each user's single-user server will be at e.g. `https://username.jupyter.example.org`.
+This also requires all user subdomains to point to the same address,
+which is most easily accomplished with wildcard DNS, where a single A record points to your server and a wildcard CNAME record points to your A record:
+
+```
+A        jupyter.example.org  192.168.1.123
+CNAME  *.jupyter.example.org  jupyter.example.org
+```
+
+Since this spreads the service across multiple domains, you will likely need wildcard SSL as well,
+matching `*.jupyter.example.org`.
+
+Unfortunately, for many institutional domains, wildcard DNS and SSL may not be available.
+
+We also **strongly encourage** serving JupyterHub and user content on a domain that is _not_ a subdomain of any sensitive content.
+For reasoning, see [GitHub's discussion of moving user content to github.io from \*.github.com](https://github.blog/2013-04-09-yummy-cookies-across-domains/).
+
+**If you do plan to serve untrusted users, enabling subdomains is highly encouraged**,
+as it resolves many security issues, which are difficult to unavoidable when JupyterHub is on a single-domain.
+
+:::{important}
+JupyterHub makes no guarantees about protecting users from each other unless subdomains are enabled.
+
+If you want to protect users from each other, you **_must_** enable per-user domains.
+:::
 
 ### Disable user config
 
 If subdomains are unavailable or undesirable, JupyterHub provides a
-configuration option `Spawner.disable_user_config`, which can be set to prevent
+configuration option `Spawner.disable_user_config = True`, which can be set to prevent
 the user-owned configuration files from being loaded. After implementing this
 option, `PATH`s and package installation are the other things that the
 admin must enforce.
@@ -88,21 +123,24 @@ admin must enforce.
 For most Spawners, `PATH` is not something users can influence, but it's important that
 the Spawner should _not_ evaluate shell configuration files prior to launching the server.
 
-### Isolate packages using virtualenv
+### Isolate packages in a read-only environment
 
-Package isolation is most easily handled by running the single-user server in
-a virtualenv with disabled system-site-packages. The user should not have
-permission to install packages into this environment.
+The user must not have permission to install packages into the environment where the singleuser-server runs.
+On a shared system, package isolation is most easily handled by running the single-user server in
+a root-owned virtualenv with disabled system-site-packages.
+The user must not have permission to install packages into this environment.
+The same principle extends to the images used by container-based deployments.
+If users can select the images in which their servers run, they can disable all security for their own servers.
 
-It is important to note that the control over the environment only affects the
-single-user server, and not the environment(s) in which the user's kernel(s)
+It is important to note that the control over the environment is only required for the
+single-user server, and not the environment(s) in which the users' kernel(s)
 may run. Installing additional packages in the kernel environment does not
 pose additional risk to the web application's security.
 
 ### Encrypt internal connections with SSL/TLS
 
-By default, all communications on the server, between the proxy, hub, and single
--user notebooks are performed unencrypted. Setting the `internal_ssl` flag in
+By default, all communications within JupyterHub—between the proxy, hub, and single
+-user notebooks—are performed unencrypted. Setting the `internal_ssl` flag in
 `jupyterhub_config.py` secures the aforementioned routes. Turning this
 feature on does require that the enabled `Spawner` can use the certificates
 generated by the `Hub` (the default `LocalProcessSpawner` can, for instance).
@@ -116,6 +154,104 @@ Unix permissions to the communication sockets thereby restricting
 communication to the socket owner. The `internal_ssl` option will eventually
 extend to securing the `tcp` sockets as well.
 
+### Mitigating same-origin deployments
+
+While per-user domains are **required** for robust protection of users from each other,
+you can mitigate many (but not all) cross-user issues.
+First, it is critical that users cannot modify their server environments, as described above.
+Second, it is important that users do not have `access:servers` permission to any server other than their own.
+
+If users can access each others' servers, additional security measures must be enabled, some of which come with distinct user-experience costs.
+
+Without the [Same-Origin Policy] (SOP) protecting user servers from each other,
+each user server is considered a trusted origin for requests to each other user server (and the Hub itself).
+Servers _cannot_ meaningfully distinguish requests originating from other user servers,
+because SOP implies a great deal of trust, losing many restrictions applied to cross-origin requests.
+
+That means pages served from each user server can:
+
+1. arbitrarily modify the path in the Referer
+2. make fully authorized requests with cookies
+3. access full page contents served from the hub or other servers via popups
+
+JupyterHub uses distinct xsrf tokens stored in cookies on each server path to attempt to limit requests across.
+This has limitations because not all requests are protected by these XSRF tokens,
+and unless additional measures are taken, the XSRF tokens from other user prefixes may be retrieved.
+
+[Same-Origin Policy]: https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy
+
+For example:
+
+- `Content-Security-Policy` header must prohibit popups and iframes from the same origin.
+  The following Content-Security-Policy rules are _insecure_ and readily enable users to access each others' servers:
+
+  - `frame-ancestors: 'self'`
+  - `frame-ancestors: '*'`
+  - `sandbox allow-popups`
+
+- Ideally, pages should use the strictest `Content-Security-Policy: sandbox` available,
+  but this is not feasible in general for JupyterLab pages, which need at least `sandbox allow-same-origin allow-scripts` to work.
+
+The default Content-Security-Policy for single-user servers is
+
+```
+frame-ancestors: 'none'
+```
+
+which prohibits iframe embedding, but not pop-ups.
+
+A more secure Content-Security-Policy that has some costs to user experience is:
+
+```
+frame-ancestors: 'none'; sandbox allow-same-origin allow-scripts
+```
+
+`allow-popups` is not disabled by default because disabling it breaks legitimate functionality, like "Open this in a new tab", and the "JupyterHub Control Panel" menu item.
+To reiterate, the right way to avoid these issues is to enable per-user domains, where none of these concerns come up.
+
+Note: even this level of protection requires administrators maintaining full control over the user server environment.
+If users can modify their server environment, these methods are ineffective, as users can readily disable them.
+
+### Cookie tossing
+
+Cookie tossing is a technique where another server on a subdomain or peer subdomain can set a cookie
+which will be read on another domain.
+This is not relevant unless there are other user-controlled servers on a peer domain.
+
+"Domain-locked" cookies avoid this issue, but have their own restrictions:
+
+- JupyterHub must be served over HTTPS
+- All secure cookies must be set on `/`, not on sub-paths, which means they are shared by all JupyterHub components in a single-domain deployment.
+
+As a result, this option is only recommended when per-user subdomains are enabled,
+to prevent sending all jupyterhub cookies to all user servers.
+
+To enable domain-locked cookies, set:
+
+```python
+c.JupyterHub.cookie_host_prefix_enabled = True
+```
+
+```{versionadded} 4.1
+
+```
+
+### Forced-login
+
+Jupyter servers can share links with `?token=...`.
+JupyterHub prior to 5.0 will accept this request and persist the token for future requests.
+This is useful for enabling admins to create 'fully authenticated' links bypassing login.
+However, it also means users can share their own links that will log other users into their own servers,
+enabling them to serve each other notebooks and other arbitrary HTML, depending on server configuration.
+
+```{versionadded} 4.1
+Setting environment variable `JUPYTERHUB_ALLOW_TOKEN_IN_URL=0` in the single-user environment can opt out of accepting token auth in URL parameters.
+```
+
+```{versionadded} 5.0
+Accepting tokens in URLs is disabled by default, and `JUPYTERHUB_ALLOW_TOKEN_IN_URL=1` environment variable must be set to _allow_ token auth in URL parameters.
+```
+
 ## Security audits
 
 We recommend that you do periodic reviews of your deployment's security. It's
diff --git a/docs/source/reference/changelog.md b/docs/source/reference/changelog.md
index 809efed1c6..0ffc2b1e87 100644
--- a/docs/source/reference/changelog.md
+++ b/docs/source/reference/changelog.md
@@ -8,6 +8,57 @@ command line for details.
 
 ## [Unreleased]
 
+## 4.1
+
+### 4.1.0 - 2024-03
+
+JupyterHub 4.1 is a security release, fixing [CVE-2024-28233].
+All JupyterHub deployments are encouraged to upgrade,
+especially those with other user content on peer domains to JupyterHub.
+
+As always, JupyterHub deployments are especially encouraged to enable per-user domains if protecting users from each other is a concern.
+
+For more information on securely deploying JupyterHub, see the [web security documentation](web-security).
+
+[CVE-2024-28233]: https://github.com/jupyterhub/jupyterhub/security/advisories/GHSA-7r3h-4ph8-w38g
+
+([full changelog](https://github.com/jupyterhub/jupyterhub/compare/4.0.2...4.1.0))
+
+#### Enhancements made
+
+- Backport PR #4628 on branch 4.x (Include LDAP groups in local spawner gids) [#4735](https://github.com/jupyterhub/jupyterhub/pull/4735) ([@minrk](https://github.com/minrk))
+- Backport PR #4561 on branch 4.x (Improve debugging when waiting for servers) [#4714](https://github.com/jupyterhub/jupyterhub/pull/4714) ([@minrk](https://github.com/minrk))
+- Backport PR #4563 on branch 4.x (only set 'domain' field on session-id cookie) [#4707](https://github.com/jupyterhub/jupyterhub/pull/4707) ([@minrk](https://github.com/minrk))
+
+#### Bugs fixed
+
+- Backport PR #4733 on branch 4.x (Catch ValueError while waiting for server to be reachable) [#4734](https://github.com/jupyterhub/jupyterhub/pull/4734) ([@minrk](https://github.com/minrk))
+- Backport PR #4679 on branch 4.x (Unescape jinja username) [#4705](https://github.com/jupyterhub/jupyterhub/pull/4705) ([@minrk](https://github.com/minrk))
+- Backport PR #4630: avoid setting unused oauth state cookies on API requests [#4697](https://github.com/jupyterhub/jupyterhub/pull/4697) ([@minrk](https://github.com/minrk))
+- Backport PR #4632: simplify, avoid errors in parsing accept headers [#4696](https://github.com/jupyterhub/jupyterhub/pull/4696) ([@minrk](https://github.com/minrk))
+- Backport PR #4677 on branch 4.x (Improve validation, docs for token.expires_in) [#4692](https://github.com/jupyterhub/jupyterhub/pull/4692) ([@minrk](https://github.com/minrk))
+- Backport PR #4570 on branch 4.x (fix mutation of frozenset in scope intersection) [#4691](https://github.com/jupyterhub/jupyterhub/pull/4691) ([@minrk](https://github.com/minrk))
+- Backport PR #4562 on branch 4.x (Use `user.stop` to cleanup spawners that stopped while Hub was down) [#4690](https://github.com/jupyterhub/jupyterhub/pull/4690) ([@minrk](https://github.com/minrk))
+- Backport PR #4542 on branch 4.x (Fix include_stopped_servers in paginated next_url) [#4689](https://github.com/jupyterhub/jupyterhub/pull/4689) ([@minrk](https://github.com/minrk))
+- Backport PR #4651 on branch 4.x (avoid attempting to patch removed IPythonHandler with notebook v7) [#4688](https://github.com/jupyterhub/jupyterhub/pull/4688) ([@minrk](https://github.com/minrk))
+- Backport PR #4560 on branch 4.x (singleuser extension: persist token from ?token=... url in cookie) [#4687](https://github.com/jupyterhub/jupyterhub/pull/4687) ([@minrk](https://github.com/minrk))
+
+#### Maintenance and upkeep improvements
+
+- Backport quay.io publishing [#4698](https://github.com/jupyterhub/jupyterhub/pull/4698) ([@minrk](https://github.com/minrk))
+- Backport PR #4617: try to improve reliability of test_external_proxy [#4695](https://github.com/jupyterhub/jupyterhub/pull/4695) ([@minrk](https://github.com/minrk))
+- Backport PR #4618 on branch 4.x (browser test: wait for token request to finish before reloading) [#4694](https://github.com/jupyterhub/jupyterhub/pull/4694) ([@minrk](https://github.com/minrk))
+- preparing 4.x branch [#4685](https://github.com/jupyterhub/jupyterhub/pull/4685) ([@minrk](https://github.com/minrk), [@consideRatio](https://github.com/consideRatio))
+
+#### Contributors to this release
+
+The following people contributed discussions, new ideas, code and documentation contributions, and review.
+See [our definition of contributors](https://github-activity.readthedocs.io/en/latest/#how-does-this-tool-define-contributions-in-the-reports).
+
+([GitHub contributors page for this release](https://github.com/jupyterhub/jupyterhub/graphs/contributors?from=2023-08-10&to=2024-03-19&type=c))
+
+@Achele ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3AAchele+updated%3A2023-08-10..2024-03-19&type=Issues)) | @akashthedeveloper ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Aakashthedeveloper+updated%3A2023-08-10..2024-03-19&type=Issues)) | @balajialg ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Abalajialg+updated%3A2023-08-10..2024-03-19&type=Issues)) | @BhavyaT-135 ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3ABhavyaT-135+updated%3A2023-08-10..2024-03-19&type=Issues)) | @blink1073 ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Ablink1073+updated%3A2023-08-10..2024-03-19&type=Issues)) | @consideRatio ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3AconsideRatio+updated%3A2023-08-10..2024-03-19&type=Issues)) | @fcollonval ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Afcollonval+updated%3A2023-08-10..2024-03-19&type=Issues)) | @I-Am-D-B ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3AI-Am-D-B+updated%3A2023-08-10..2024-03-19&type=Issues)) | @jakirkham ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Ajakirkham+updated%3A2023-08-10..2024-03-19&type=Issues)) | @ktaletsk ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Aktaletsk+updated%3A2023-08-10..2024-03-19&type=Issues)) | @kzgrzendek ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Akzgrzendek+updated%3A2023-08-10..2024-03-19&type=Issues)) | @lumberbot-app ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Alumberbot-app+updated%3A2023-08-10..2024-03-19&type=Issues)) | @manics ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Amanics+updated%3A2023-08-10..2024-03-19&type=Issues)) | @mbiette ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Ambiette+updated%3A2023-08-10..2024-03-19&type=Issues)) | @minrk ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Aminrk+updated%3A2023-08-10..2024-03-19&type=Issues)) | @rcthomas ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Arcthomas+updated%3A2023-08-10..2024-03-19&type=Issues)) | @ryanlovett ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Aryanlovett+updated%3A2023-08-10..2024-03-19&type=Issues)) | @sgaist ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Asgaist+updated%3A2023-08-10..2024-03-19&type=Issues)) | @shubham0473 ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Ashubham0473+updated%3A2023-08-10..2024-03-19&type=Issues)) | @Temidayo32 ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3ATemidayo32+updated%3A2023-08-10..2024-03-19&type=Issues)) | @willingc ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Awillingc+updated%3A2023-08-10..2024-03-19&type=Issues)) | @yuvipanda ([activity](https://github.com/search?q=repo%3Ajupyterhub%2Fjupyterhub+involves%3Ayuvipanda+updated%3A2023-08-10..2024-03-19&type=Issues))
+
 ## 4.0
 
 ### 4.0.2 - 2023-08-10
diff --git a/jupyterhub/_xsrf_utils.py b/jupyterhub/_xsrf_utils.py
new file mode 100644
index 0000000000..05bf2b046c
--- /dev/null
+++ b/jupyterhub/_xsrf_utils.py
@@ -0,0 +1,210 @@
+"""utilities for XSRF 
+
+Extends tornado's xsrf token checks with the following:
+
+- only set xsrf cookie on navigation requests (cannot be fetched)
+
+This utility file enables the consistent reuse of these functions
+in both Hub and single-user code
+"""
+
+import base64
+import hashlib
+from datetime import datetime, timedelta, timezone
+from http.cookies import SimpleCookie
+
+from tornado import web
+from tornado.httputil import format_timestamp
+from tornado.log import app_log
+
+
+def _get_signed_value_urlsafe(handler, name, b64_value):
+    """Like get_signed_value (used in get_secure_cookie), but for urlsafe values
+
+    Decodes urlsafe_base64-encoded signed values
+
+    Returns None if any decoding failed
+    """
+    if b64_value is None:
+        return None
+
+    if isinstance(b64_value, str):
+        try:
+            b64_value = b64_value.encode("ascii")
+        except UnicodeEncodeError:
+            app_log.warning("Invalid value %r", b64_value)
+            return None
+    # re-pad, since we stripped padding in _create_signed_value
+    remainder = len(b64_value) % 4
+    if remainder:
+        b64_value = b64_value + (b'=' * (4 - remainder))
+    try:
+        value = base64.urlsafe_b64decode(b64_value)
+    except ValueError:
+        app_log.warning("Invalid base64 value %r", b64_value)
+        return None
+
+    return web.decode_signed_value(
+        handler.application.settings["cookie_secret"],
+        name,
+        value,
+        max_age_days=31,
+        min_version=2,
+    )
+
+
+def _create_signed_value_urlsafe(handler, name, value):
+    """Like tornado's create_signed_value (used in set_secure_cookie), but returns urlsafe bytes"""
+
+    signed_value = handler.create_signed_value(name, value)
+    return base64.urlsafe_b64encode(signed_value).rstrip(b"=")
+
+
+def _clear_invalid_xsrf_cookie(handler, cookie_path):
+    """
+    Clear invalid XSRF cookie
+
+    This may an old XSRF token, or one set on / by another application.
+    Because we cannot trust browsers or tornado to give us the more specific cookie,
+    try to clear _both_ on / and on our prefix,
+    then reload the page.
+    """
+
+    expired = format_timestamp(datetime.now(timezone.utc) - timedelta(days=366))
+    cookie = SimpleCookie()
+    cookie["_xsrf"] = ""
+    morsel = cookie["_xsrf"]
+    morsel["expires"] = expired
+    morsel["path"] = "/"
+    # use Set-Cookie directly,
+    # because tornado's set_cookie and clear_cookie use a single _dict_,
+    # so we can't clear a cookie on multiple paths and then set it
+    handler.add_header("Set-Cookie", morsel.OutputString(None))
+    if cookie_path != "/":
+        # clear it multiple times!
+        morsel["path"] = cookie_path
+        handler.add_header("Set-Cookie", morsel.OutputString(None))
+
+    if (
+        handler.request.method.lower() == "get"
+        and handler.request.headers.get("Sec-Fetch-Mode", "navigate") == "navigate"
+    ):
+        # reload current page because any subsequent set_cookie
+        # will cancel the clearing of the cookie
+        # this only makes sense on GET requests
+        handler.redirect(handler.request.uri)
+        # halt any other processing of the request
+        raise web.Finish()
+
+
+def get_xsrf_token(handler, cookie_path=""):
+    """Override tornado's xsrf token to add further restrictions
+
+    - only set cookie for regular pages (not API requests)
+    - include login info in xsrf token
+    - verify signature
+    """
+    # original: https://github.com/tornadoweb/tornado/blob/v6.4.0/tornado/web.py#L1455
+    if hasattr(handler, "_xsrf_token"):
+        return handler._xsrf_token
+
+    _set_cookie = False
+    # the raw cookie is the token
+    xsrf_token = xsrf_cookie = handler.get_cookie("_xsrf")
+    if xsrf_token:
+        try:
+            xsrf_token = xsrf_token.encode("ascii")
+        except UnicodeEncodeError:
+            xsrf_token = None
+
+    xsrf_id_cookie = _get_signed_value_urlsafe(handler, "_xsrf", xsrf_token)
+    if xsrf_cookie and not xsrf_id_cookie:
+        # we have a cookie, but it's invalid!
+        # handle possibility of _xsrf being set multiple times,
+        # e.g. on / and on /hub/
+        # this will reload the page if it's a GET request
+        app_log.warning(
+            "Attempting to clear invalid _xsrf cookie %r", xsrf_cookie[:4] + "..."
+        )
+        _clear_invalid_xsrf_cookie(handler, cookie_path)
+
+    # check the decoded, signed value for validity
+    xsrf_id = handler._xsrf_token_id
+    if xsrf_id_cookie != xsrf_id:
+        # this will usually happen on the first page request after login,
+        # which changes the inputs to the token id
+        if xsrf_id_cookie:
+            app_log.debug("xsrf id mismatch %r != %r", xsrf_id_cookie, xsrf_id)
+        # generate new value
+        xsrf_token = _create_signed_value_urlsafe(handler, "_xsrf", xsrf_id)
+        # only set cookie on regular navigation pages
+        # i.e. not API requests, etc.
+        # insecure URLs (public hostname/ip, no https)
+        # don't set Sec-Fetch-Mode.
+        # consequence of assuming 'navigate': setting a cookie unnecessarily
+        # consequence of assuming not 'navigate': xsrf never set, nothing works
+        _set_cookie = (
+            handler.request.headers.get("Sec-Fetch-Mode", "navigate") == "navigate"
+        )
+
+    if _set_cookie:
+        xsrf_cookie_kwargs = {}
+        xsrf_cookie_kwargs.update(handler.settings.get('xsrf_cookie_kwargs', {}))
+        xsrf_cookie_kwargs.setdefault("path", cookie_path)
+        if not handler.current_user:
+            # limit anonymous xsrf cookies to one hour
+            xsrf_cookie_kwargs.pop("expires", None)
+            xsrf_cookie_kwargs.pop("expires_days", None)
+            xsrf_cookie_kwargs["max_age"] = 3600
+        app_log.info(
+            "Setting new xsrf cookie for %r %r",
+            xsrf_id,
+            xsrf_cookie_kwargs,
+        )
+        handler.set_cookie("_xsrf", xsrf_token, **xsrf_cookie_kwargs)
+    handler._xsrf_token = xsrf_token
+    return xsrf_token
+
+
+def check_xsrf_cookie(handler):
+    """Check that xsrf cookie matches xsrf token in request"""
+    # overrides tornado's implementation
+    # because we changed what a correct value should be in xsrf_token
+
+    token = (
+        handler.get_argument("_xsrf", None)
+        or handler.request.headers.get("X-Xsrftoken")
+        or handler.request.headers.get("X-Csrftoken")
+    )
+
+    if not token:
+        raise web.HTTPError(
+            403, f"'_xsrf' argument missing from {handler.request.method}"
+        )
+
+    try:
+        token = token.encode("utf8")
+    except UnicodeEncodeError:
+        raise web.HTTPError(403, "'_xsrf' argument invalid")
+
+    if token != handler.xsrf_token:
+        raise web.HTTPError(
+            403, f"XSRF cookie does not match {handler.request.method.upper()} argument"
+        )
+
+
+def _anonymous_xsrf_id(handler):
+    """Generate an appropriate xsrf token id for an anonymous request
+
+    Currently uses hash of request ip and user-agent
+
+    These are typically used only for the initial login page,
+    so only need to be valid for a few seconds to a few minutes
+    (enough to submit a login form with MFA).
+    """
+    hasher = hashlib.sha256()
+    hasher.update(handler.request.remote_ip.encode("ascii"))
+    hasher.update(
+        handler.request.headers.get("User-Agent", "").encode("utf8", "replace")
+    )
+    return base64.urlsafe_b64encode(hasher.digest()).decode("ascii")
diff --git a/jupyterhub/apihandlers/base.py b/jupyterhub/apihandlers/base.py
index 35d9558ef5..e899d17fad 100644
--- a/jupyterhub/apihandlers/base.py
+++ b/jupyterhub/apihandlers/base.py
@@ -76,15 +76,8 @@ def check_post_content_type(self):
 
         return True
 
-    async def prepare(self):
-        await super().prepare()
-        # tornado only checks xsrf on non-GET
-        # we also check xsrf on GETs to API endpoints
-        # make sure this runs after auth, which happens in super().prepare()
-        if self.request.method not in {"HEAD", "OPTIONS"} and self.settings.get(
-            "xsrf_cookies"
-        ):
-            self.check_xsrf_cookie()
+    # we also check xsrf on GETs to API endpoints
+    _xsrf_safe_methods = {"HEAD", "OPTIONS"}
 
     def check_xsrf_cookie(self):
         if not hasattr(self, '_jupyterhub_user'):
diff --git a/jupyterhub/app.py b/jupyterhub/app.py
index 9728623957..367b6eb399 100644
--- a/jupyterhub/app.py
+++ b/jupyterhub/app.py
@@ -401,6 +401,25 @@ def _validate_config_file(self, proposal):
         Useful for daemonizing JupyterHub.
         """,
     ).tag(config=True)
+
+    cookie_host_prefix_enabled = Bool(
+        False,
+        help="""Enable `__Host-` prefix on authentication cookies.
+        
+        The `__Host-` prefix on JupyterHub cookies provides further
+        protection against cookie tossing when untrusted servers
+        may control subdomains of your jupyterhub deployment.
+        
+        _However_, it also requires that cookies be set on the path `/`,
+        which means they are shared by all JupyterHub components,
+        so a compromised server component will have access to _all_ JupyterHub-related
+        cookies of the visiting browser.
+        It is recommended to only combine `__Host-` cookies with per-user domains.
+
+        .. versionadded:: 4.1
+        """,
+    ).tag(config=True)
+
     cookie_max_age_days = Float(
         14,
         help="""Number of days for a login cookie to be valid.
@@ -1898,6 +1917,8 @@ def init_hub(self):
             hub_args['port'] = self.hub_port
 
         self.hub = Hub(**hub_args)
+        if self.cookie_host_prefix_enabled:
+            self.hub.cookie_name = "__Host-" + self.hub.cookie_name
 
         if not self.subdomain_host:
             api_prefix = url_path_join(self.hub.base_url, "api/")
@@ -2760,6 +2781,7 @@ def init_tornado_settings(self):
             base_url=self.base_url,
             default_url=self.default_url,
             cookie_secret=self.cookie_secret,
+            cookie_host_prefix_enabled=self.cookie_host_prefix_enabled,
             cookie_max_age_days=self.cookie_max_age_days,
             redirect_to_server=self.redirect_to_server,
             login_url=login_url,
diff --git a/jupyterhub/handlers/base.py b/jupyterhub/handlers/base.py
index 397e3ccf0f..03e3d7a5b9 100644
--- a/jupyterhub/handlers/base.py
+++ b/jupyterhub/handlers/base.py
@@ -24,6 +24,7 @@
 from tornado.web import RequestHandler, addslash
 
 from .. import __version__, orm, roles, scopes
+from .._xsrf_utils import _anonymous_xsrf_id, check_xsrf_cookie, get_xsrf_token
 from ..metrics import (
     PROXY_ADD_DURATION_SECONDS,
     PROXY_DELETE_DURATION_SECONDS,
@@ -99,7 +100,14 @@ async def prepare(self):
                 self.log.error("Rolling back session due to database error")
                 self.db.rollback()
         self._resolve_roles_and_scopes()
-        return await maybe_future(super().prepare())
+        await maybe_future(super().prepare())
+        # run xsrf check after prepare
+        # because our version takes auth info into account
+        if (
+            self.request.method not in self._xsrf_safe_methods
+            and self.application.settings.get("xsrf_cookies")
+        ):
+            self.check_xsrf_cookie()
 
     @property
     def log(self):
@@ -200,9 +208,13 @@ def content_security_policy(self):
         """The default Content-Security-Policy header
 
         Can be overridden by defining Content-Security-Policy in settings['headers']
+
+        ..versionchanged:: 4.1
+
+            Change default frame-ancestors from 'self' to 'none'
         """
         return '; '.join(
-            ["frame-ancestors 'self'", "report-uri " + self.csp_report_uri]
+            ["frame-ancestors 'none'", "report-uri " + self.csp_report_uri]
         )
 
     def get_content_type(self):
@@ -212,7 +224,6 @@ def set_default_headers(self):
         """
         Set any headers passed as tornado_settings['headers'].
 
-        By default sets Content-Security-Policy of frame-ancestors 'self'.
         Also responsible for setting content-type header
         """
         # wrap in HTTPHeaders for case-insensitivity
@@ -234,17 +245,63 @@ def set_default_headers(self):
     # Login and cookie-related
     # ---------------------------------------------------------------
 
+    _xsrf_safe_methods = {"GET", "HEAD", "OPTIONS"}
+
+    @property
+    def _xsrf_token_id(self):
+        """Value to be signed/encrypted for xsrf token
+
+        include login info in xsrf token
+        this means xsrf tokens are tied to logged-in users,
+        and change after a user logs in.
+
+        While the user is not yet logged in,
+        an anonymous value is used, to prevent portability.
+        These anonymous values are short-lived.
+        """
+        # cases:
+        # 1. logged in, session id (session_id:user_id)
+        # 2. logged in, no session id (anonymous_id:user_id)
+        # 3. not logged in, session id (session_id:anonymous_id)
+        # 4. no cookies at all, use single anonymous value (:anonymous_id)
+        session_id = self.get_session_cookie()
+        if self.current_user:
+            if isinstance(self.current_user, User):
+                user_id = self.current_user.cookie_id
+            else:
+                # this shouldn't happen, but may if e.g. a Service attempts to fetch a page,
+                # which usually won't work, but this method should not be what raises
+                user_id = ""
+            if not session_id:
+                # no session id, use non-portable anonymous id
+                session_id = _anonymous_xsrf_id(self)
+        else:
+            # not logged in yet, use non-portable anonymous id
+            user_id = _anonymous_xsrf_id(self)
+        xsrf_id = f"{session_id}:{user_id}".encode("utf8", "replace")
+        return xsrf_id
+
+    @property
+    def xsrf_token(self):
+        """Override tornado's xsrf token with further restrictions
+
+        - only set cookie for regular pages
+        - include login info in xsrf token
+        - verify signature
+        """
+        return get_xsrf_token(self, cookie_path=self.hub.base_url)
+
     def check_xsrf_cookie(self):
-        try:
-            return super().check_xsrf_cookie()
-        except web.HTTPError as e:
-            # ensure _jupyterhub_user is defined on rejected requests
-            if not hasattr(self, "_jupyterhub_user"):
-                self._jupyterhub_user = None
-            self._resolve_roles_and_scopes()
-            # rewrite message because we use this on methods other than POST
-            e.log_message = e.log_message.replace("POST", self.request.method)
-            raise
+        """Check that xsrf cookie matches xsrf token in request"""
+        # overrides tornado's implementation
+        # because we changed what a correct value should be in xsrf_token
+
+        if not hasattr(self, "_jupyterhub_user"):
+            # run too early to check the value
+            # tornado runs this before 'prepare',
+            # but we run it again after so auth info is available, which happens in 'prepare'
+            return None
+        return check_xsrf_cookie(self)
 
     @property
     def admin_users(self):
@@ -517,6 +574,16 @@ def user_from_username(self, username):
             user = self._user_from_orm(u)
         return user
 
+    def clear_cookie(self, cookie_name, **kwargs):
+        """Clear a cookie
+
+        overrides RequestHandler to always handle __Host- prefix correctly
+        """
+        if cookie_name.startswith("__Host-"):
+            kwargs["path"] = "/"
+            kwargs["secure"] = True
+        return super().clear_cookie(cookie_name, **kwargs)
+
     def clear_login_cookie(self, name=None):
         kwargs = {}
         user = self.get_current_user_cookie()
@@ -583,6 +650,11 @@ def _set_cookie(self, key, value, encrypted=True, **overrides):
         kwargs.update(self.settings.get('cookie_options', {}))
         kwargs.update(overrides)
 
+        if key.startswith("__Host-"):
+            # __Host- cookies must be secure and on /
+            kwargs["path"] = "/"
+            kwargs["secure"] = True
+
         if encrypted:
             set_cookie = self.set_secure_cookie
         else:
@@ -612,7 +684,9 @@ def set_session_cookie(self):
         Session id cookie is *not* encrypted,
         so other services on this domain can read it.
         """
-        session_id = uuid.uuid4().hex
+        if not hasattr(self, "_session_id"):
+            self._session_id = uuid.uuid4().hex
+        session_id = self._session_id
         # if using subdomains, set session cookie on the domain,
         # which allows it to be shared by subdomains.
         # if domain is unspecified, it is _more_ restricted to only the setting domain
diff --git a/jupyterhub/services/auth.py b/jupyterhub/services/auth.py
index bc1b61ef43..5b376ee59e 100644
--- a/jupyterhub/services/auth.py
+++ b/jupyterhub/services/auth.py
@@ -36,6 +36,7 @@
 import time
 import uuid
 import warnings
+from functools import partial
 from http import HTTPStatus
 from unittest import mock
 from urllib.parse import urlencode
@@ -46,6 +47,7 @@
 from tornado.web import HTTPError, RequestHandler
 from traitlets import (
     Any,
+    Bool,
     Dict,
     Instance,
     Integer,
@@ -57,8 +59,9 @@
 )
 from traitlets.config import SingletonConfigurable
 
+from .._xsrf_utils import _anonymous_xsrf_id, check_xsrf_cookie, get_xsrf_token
 from ..scopes import _intersect_expanded_scopes
-from ..utils import get_browser_protocol, url_path_join
+from ..utils import _bool_env, get_browser_protocol, url_path_join
 
 
 def check_scopes(required_scopes, scopes):
@@ -306,6 +309,46 @@ def _default_login_url(self):
         """,
     ).tag(config=True)
 
+    allow_token_in_url = Bool(
+        _bool_env("JUPYTERHUB_ALLOW_TOKEN_IN_URL", default=True),
+        help="""Allow requests to pages with ?token=... in the URL
+        
+        This allows starting a user session by sharing a URL with credentials,
+        bypassing authentication with the Hub.
+        
+        If False, tokens in URLs will be ignored by the server,
+        except on websocket requests.
+        
+        Has no effect on websocket requests,
+        which can only reliably authenticate via token in the URL,
+        as recommended by browser Websocket implementations.
+
+        This will default to False in JupyterHub 5.
+
+        .. versionadded:: 4.1
+
+        .. versionchanged:: 5.0
+            default changed to False
+        """,
+    ).tag(config=True)
+
+    allow_websocket_cookie_auth = Bool(
+        _bool_env("JUPYTERHUB_ALLOW_WEBSOCKET_COOKIE_AUTH", default=True),
+        help="""Allow websocket requests with only cookie for authentication
+
+        Cookie-authenticated websockets cannot be protected from other user servers unless per-user domains are used.
+        Disabling cookie auth on websockets protects user servers from each other,
+        but may break some user applications.
+        Per-user domains eliminate the need to lock this down.
+        
+        JupyterLab 4.1.2 and Notebook 6.5.6, 7.1.0 will not work
+        because they rely on cookie authentication without
+        API or XSRF tokens.
+        
+        .. versionadded:: 4.1
+        """,
+    ).tag(config=True)
+
     cookie_options = Dict(
         help="""Additional options to pass when setting cookies.
 
@@ -324,6 +367,40 @@ def _default_cookie_options(self):
         else:
             return {}
 
+    cookie_host_prefix_enabled = Bool(
+        False,
+        help="""Enable `__Host-` prefix on authentication cookies.
+        
+        The `__Host-` prefix on JupyterHub cookies provides further
+        protection against cookie tossing when untrusted servers
+        may control subdomains of your jupyterhub deployment.
+        
+        _However_, it also requires that cookies be set on the path `/`,
+        which means they are shared by all JupyterHub components,
+        so a compromised server component will have access to _all_ JupyterHub-related
+        cookies of the visiting browser.
+        It is recommended to only combine `__Host-` cookies with per-user domains.
+        
+        Set via $JUPYTERHUB_COOKIE_HOST_PREFIX_ENABLED
+        """,
+    ).tag(config=True)
+
+    @default("cookie_host_prefix_enabled")
+    def _default_cookie_host_prefix_enabled(self):
+        return _bool_env("JUPYTERHUB_COOKIE_HOST_PREFIX_ENABLED")
+
+    @property
+    def cookie_path(self):
+        """
+        Path prefix on which to set cookies
+
+        self.base_url, but '/' when cookie_host_prefix_enabled is True
+        """
+        if self.cookie_host_prefix_enabled:
+            return "/"
+        else:
+            return self.base_url
+
     cookie_cache_max_age = Integer(help="DEPRECATED. Use cache_max_age")
 
     @observe('cookie_cache_max_age')
@@ -586,6 +663,17 @@ def user_for_token(self, token, use_cache=True, session_id='', *, sync=True):
     auth_header_name = 'Authorization'
     auth_header_pat = re.compile(r'(?:token|bearer)\s+(.+)', re.IGNORECASE)
 
+    def _get_token_url(self, handler):
+        """Get the token from the URL
+
+        Always run for websockets,
+        otherwise run only if self.allow_token_in_url
+        """
+        fetch_mode = handler.request.headers.get("Sec-Fetch-Mode", "unspecified")
+        if self.allow_token_in_url or fetch_mode == "websocket":
+            return handler.get_argument("token", "")
+        return ""
+
     def get_token(self, handler, in_cookie=True):
         """Get the token authenticating a request
 
@@ -598,8 +686,7 @@ def get_token(self, handler, in_cookie=True):
         - in header: Authorization: token <token>
         - in cookie (stored after oauth), if in_cookie is True
         """
-
-        user_token = handler.get_argument('token', '')
+        user_token = self._get_token_url(handler)
         if not user_token:
             # get it from Authorization header
             m = self.auth_header_pat.match(
@@ -646,6 +733,14 @@ def get_user(self, handler, *, sync=True):
         """
         return self._call_coroutine(sync, self._get_user, handler)
 
+    def _patch_xsrf(self, handler):
+        """Overridden in HubOAuth
+
+        HubAuth base class doesn't handle xsrf,
+        which is only relevant for cookie-based auth
+        """
+        return
+
     async def _get_user(self, handler):
         # only allow this to be called once per handler
         # avoids issues if an error is raised,
@@ -653,6 +748,9 @@ async def _get_user(self, handler):
         if hasattr(handler, '_cached_hub_user'):
             return handler._cached_hub_user
 
+        # patch XSRF checks, which will apply after user check
+        self._patch_xsrf(handler)
+
         handler._cached_hub_user = user_model = None
         session_id = self.get_session_id(handler)
 
@@ -738,7 +836,10 @@ def cookie_name(self):
         because we don't want to use the same cookie name
         across OAuth clients.
         """
-        return self.oauth_client_id
+        cookie_name = self.oauth_client_id
+        if self.cookie_host_prefix_enabled:
+            cookie_name = "__Host-" + cookie_name
+        return cookie_name
 
     @property
     def state_cookie_name(self):
@@ -750,22 +851,103 @@ def state_cookie_name(self):
 
     def _get_token_cookie(self, handler):
         """Base class doesn't store tokens in cookies"""
+
+        fetch_mode = handler.request.headers.get("Sec-Fetch-Mode", "unset")
+        if fetch_mode == "websocket" and not self.allow_websocket_cookie_auth:
+            # disallow cookie auth on websockets
+            return None
+
         token = handler.get_secure_cookie(self.cookie_name)
         if token:
             # decode cookie bytes
             token = token.decode('ascii', 'replace')
         return token
 
+    def _get_xsrf_token_id(self, handler):
+        """Get contents for xsrf token for a given Handler
+
+        This is the value to be encrypted & signed in the xsrf token
+        """
+        token = self._get_token_cookie(handler)
+        session_id = self.get_session_id(handler)
+        if token:
+            token_hash = hashlib.sha256(token.encode("ascii", "replace")).hexdigest()
+            if not session_id:
+                session_id = _anonymous_xsrf_id(handler)
+        else:
+            token_hash = _anonymous_xsrf_id(handler)
+        return f"{session_id}:{token_hash}".encode("ascii", "replace")
+
+    def _patch_xsrf(self, handler):
+        """Patch handler to inject JuptyerHub xsrf token behavior"""
+        handler._xsrf_token_id = self._get_xsrf_token_id(handler)
+        # override xsrf_token property on class,
+        # so it's still a getter, not invoked immediately
+        handler.__class__.xsrf_token = property(
+            partial(get_xsrf_token, cookie_path=self.base_url)
+        )
+        handler.check_xsrf_cookie = partial(self.check_xsrf_cookie, handler)
+
+    def check_xsrf_cookie(self, handler):
+        """check_xsrf_cookie patch
+
+        Applies JupyterHub check_xsrf_cookie if not token authenticated
+        """
+        if getattr(handler, '_token_authenticated', False):
+            return
+        check_xsrf_cookie(handler)
+
+    def _clear_cookie(self, handler, cookie_name, **kwargs):
+        """Clear a cookie, handling __Host- prefix"""
+        # Set-Cookie is rejected without 'secure',
+        # this includes clearing cookies!
+        if cookie_name.startswith("__Host-"):
+            kwargs["path"] = "/"
+            kwargs["secure"] = True
+        return handler.clear_cookie(cookie_name, **kwargs)
+
+    def _needs_check_xsrf(self, handler):
+        """Does the given cookie-authenticated request need to check xsrf?"""
+        if getattr(handler, "_token_authenticated", False):
+            return False
+
+        fetch_mode = handler.request.headers.get("Sec-Fetch-Mode", "unspecified")
+        if fetch_mode in {"websocket", "no-cors"} or (
+            fetch_mode in {"navigate", "unspecified"}
+            and handler.request.method.lower() in {"get", "head", "options"}
+        ):
+            # no xsrf check needed for regular page views or no-cors
+            # or websockets after allow_websocket_cookie_auth passes
+            if fetch_mode == "unspecified":
+                self.log.warning(
+                    f"Skipping XSRF check for insecure request {handler.request.method} {handler.request.path}"
+                )
+            return False
+        else:
+            return True
+
     async def _get_user_cookie(self, handler):
+        # check xsrf if needed
         token = self._get_token_cookie(handler)
         session_id = self.get_session_id(handler)
+        if token and self._needs_check_xsrf(handler):
+            try:
+                self.check_xsrf_cookie(handler)
+            except HTTPError as e:
+                self.log.error(
+                    f"Not accepting cookie auth on {handler.request.method} {handler.request.path}: {e}"
+                )
+                # don't proceed with cookie auth unless xsrf is okay
+                # don't raise either, because that makes a mess
+                return None
+
         if token:
             user_model = await self.user_for_token(
                 token, session_id=session_id, sync=False
             )
             if user_model is None:
                 app_log.warning("Token stored in cookie may have expired")
-                handler.clear_cookie(self.cookie_name)
+                self._clear_cookie(handler, self.cookie_name, path=self.cookie_path)
             return user_model
 
     # HubOAuth API
@@ -911,7 +1093,7 @@ def set_state_cookie(self, handler, next_url=None):
             cookie_name = self.state_cookie_name
         b64_state = self.generate_state(next_url, **extra_state)
         kwargs = {
-            'path': self.base_url,
+            'path': self.cookie_path,
             'httponly': True,
             # Expire oauth state cookie in ten minutes.
             # Usually this will be cleared by completed login
@@ -919,8 +1101,12 @@ def set_state_cookie(self, handler, next_url=None):
             # OAuth that doesn't complete shouldn't linger too long.
             'max_age': 600,
         }
-        if get_browser_protocol(handler.request) == 'https':
+        if (
+            get_browser_protocol(handler.request) == 'https'
+            or self.cookie_host_prefix_enabled
+        ):
             kwargs['secure'] = True
+
         # load user cookie overrides
         kwargs.update(self.cookie_options)
         handler.set_secure_cookie(cookie_name, b64_state, **kwargs)
@@ -958,8 +1144,11 @@ def get_state_cookie_name(self, b64_state=''):
 
     def set_cookie(self, handler, access_token):
         """Set a cookie recording OAuth result"""
-        kwargs = {'path': self.base_url, 'httponly': True}
-        if get_browser_protocol(handler.request) == 'https':
+        kwargs = {'path': self.cookie_path, 'httponly': True}
+        if (
+            get_browser_protocol(handler.request) == 'https'
+            or self.cookie_host_prefix_enabled
+        ):
             kwargs['secure'] = True
         # load user cookie overrides
         kwargs.update(self.cookie_options)
@@ -973,7 +1162,7 @@ def set_cookie(self, handler, access_token):
 
     def clear_cookie(self, handler):
         """Clear the OAuth cookie"""
-        handler.clear_cookie(self.cookie_name, path=self.base_url)
+        self._clear_cookie(handler, self.cookie_name, path=self.cookie_path)
 
 
 class UserNotAllowed(Exception):
@@ -1185,7 +1374,7 @@ def get_current_user(self):
             return
         try:
             self._hub_auth_user_cache = self.check_hub_user(user_model)
-        except UserNotAllowed as e:
+        except UserNotAllowed:
             # cache None, in case get_user is called again while processing the error
             self._hub_auth_user_cache = None
 
@@ -1207,6 +1396,25 @@ def raise_on_redirect(*args, **kwargs):
         self.hub_auth._persist_url_token_if_set(self)
         return self._hub_auth_user_cache
 
+    @property
+    def _xsrf_token_id(self):
+        if hasattr(self, "__xsrf_token_id"):
+            return self.__xsrf_token_id
+        if not isinstance(self.hub_auth, HubOAuth):
+            return ""
+        return self.hub_auth._get_xsrf_token_id(self)
+
+    @_xsrf_token_id.setter
+    def _xsrf_token_id(self, value):
+        self.__xsrf_token_id = value
+
+    @property
+    def xsrf_token(self):
+        return get_xsrf_token(self, cookie_path=self.hub_auth.base_url)
+
+    def check_xsrf_cookie(self):
+        return self.hub_auth.check_xsrf_cookie(self)
+
 
 class HubOAuthenticated(HubAuthenticated):
     """Simple subclass of HubAuthenticated using OAuth instead of old shared cookies"""
@@ -1241,12 +1449,22 @@ async def get(self):
         cookie_name = self.hub_auth.get_state_cookie_name(arg_state)
         cookie_state = self.get_secure_cookie(cookie_name)
         # clear cookie state now that we've consumed it
-        self.clear_cookie(cookie_name, path=self.hub_auth.base_url)
+        clear_kwargs = {}
+        if self.hub_auth.cookie_host_prefix_enabled:
+            # Set-Cookie is rejected without 'secure',
+            # this includes clearing cookies!
+            clear_kwargs["secure"] = True
+        self.hub_auth._clear_cookie(self, cookie_name, path=self.hub_auth.cookie_path)
         if isinstance(cookie_state, bytes):
             cookie_state = cookie_state.decode('ascii', 'replace')
         # check that state matches
         if arg_state != cookie_state:
-            app_log.warning("oauth state %r != %r", arg_state, cookie_state)
+            app_log.warning(
+                "oauth state argument %r != cookie %s=%r",
+                arg_state,
+                cookie_name,
+                cookie_state,
+            )
             raise HTTPError(403, "oauth state does not match. Try logging in again.")
         next_url = self.hub_auth.get_next_url(cookie_state)
 
diff --git a/jupyterhub/singleuser/extension.py b/jupyterhub/singleuser/extension.py
index 65e20a0afa..090fd69421 100644
--- a/jupyterhub/singleuser/extension.py
+++ b/jupyterhub/singleuser/extension.py
@@ -44,6 +44,7 @@
 from jupyterhub.log import log_request
 from jupyterhub.services.auth import HubOAuth, HubOAuthCallbackHandler
 from jupyterhub.utils import (
+    _bool_env,
     exponential_backoff,
     isoformat,
     make_ssl_context,
@@ -55,17 +56,6 @@
 SINGLEUSER_TEMPLATES_DIR = str(Path(__file__).parent.resolve().joinpath("templates"))
 
 
-def _bool_env(key):
-    """Cast an environment variable to bool
-
-    0, empty, or unset is False; All other values are True.
-    """
-    if os.environ.get(key, "") in {"", "0"}:
-        return False
-    else:
-        return True
-
-
 def _exclude_home(path_list):
     """Filter out any entries in a path list that are in my home directory.
 
@@ -127,6 +117,9 @@ def _default_hub_auth(self):
         # HubAuth gets most of its config from the environment
         return HubOAuth(parent=self)
 
+    def _patch_xsrf(self, handler):
+        self.hub_auth._patch_xsrf(handler)
+
     def _patch_get_login_url(self, handler):
         original_get_login_url = handler.get_login_url
 
@@ -161,6 +154,7 @@ async def get_user(self, handler):
         if hasattr(handler, "_jupyterhub_user"):
             return handler._jupyterhub_user
         self._patch_get_login_url(handler)
+        self._patch_xsrf(handler)
         user = await self.hub_auth.get_user(handler, sync=False)
         if user is None:
             handler._jupyterhub_user = None
@@ -631,6 +625,9 @@ def initialize(self, args=None):
         app.web_app.settings["page_config_hook"] = (
             app.identity_provider.page_config_hook
         )
+        # disable xsrf_cookie checks by Tornado, which run too early
+        # checks in Jupyter Server are unconditional
+        app.web_app.settings["xsrf_cookies"] = False
         # if the user has configured a log function in the tornado settings, do not override it
         if not 'log_function' in app.config.ServerApp.get('tornado_settings', {}):
             app.web_app.settings["log_function"] = log_request
@@ -641,6 +638,9 @@ def initialize(self, args=None):
         # check jupyterhub version
         app.io_loop.run_sync(self.check_hub_version)
 
+        # set default CSP to prevent iframe embedding across jupyterhub components
+        headers.setdefault("Content-Security-Policy", "frame-ancestors 'none'")
+
         async def _start_activity():
             self._activity_task = asyncio.ensure_future(self.keep_activity_updated())
 
diff --git a/jupyterhub/singleuser/mixins.py b/jupyterhub/singleuser/mixins.py
index 5fb55c055d..19b478c5a5 100755
--- a/jupyterhub/singleuser/mixins.py
+++ b/jupyterhub/singleuser/mixins.py
@@ -44,21 +44,15 @@
 from .._version import __version__, _check_version
 from ..log import log_request
 from ..services.auth import HubOAuth, HubOAuthCallbackHandler, HubOAuthenticated
-from ..utils import exponential_backoff, isoformat, make_ssl_context, url_path_join
+from ..utils import (
+    _bool_env,
+    exponential_backoff,
+    isoformat,
+    make_ssl_context,
+    url_path_join,
+)
 from ._disable_user_config import _disable_user_config, _exclude_home
 
-
-def _bool_env(key):
-    """Cast an environment variable to bool
-
-    0, empty, or unset is False; All other values are True.
-    """
-    if os.environ.get(key, "") in {"", "0"}:
-        return False
-    else:
-        return True
-
-
 # Authenticate requests with the Hub
 
 
@@ -682,10 +676,10 @@ def init_webapp(self):
         )
         headers = s.setdefault('headers', {})
         headers['X-JupyterHub-Version'] = __version__
-        # set CSP header directly to workaround bugs in jupyter/notebook 5.0
+        # set default CSP to prevent iframe embedding across jupyterhub components
         headers.setdefault(
             'Content-Security-Policy',
-            ';'.join(["frame-ancestors 'self'", "report-uri " + csp_report_uri]),
+            ';'.join(["frame-ancestors 'none'", "report-uri " + csp_report_uri]),
         )
         super().init_webapp()
 
diff --git a/jupyterhub/spawner.py b/jupyterhub/spawner.py
index c29a0ec558..822c4e2762 100644
--- a/jupyterhub/spawner.py
+++ b/jupyterhub/spawner.py
@@ -163,6 +163,7 @@ def active(self):
     hub = Any()
     orm_spawner = Any()
     cookie_options = Dict()
+    cookie_host_prefix_enabled = Bool()
 
     db = Any()
 
@@ -970,6 +971,10 @@ def get_env(self):
         env['JUPYTERHUB_CLIENT_ID'] = self.oauth_client_id
         if self.cookie_options:
             env['JUPYTERHUB_COOKIE_OPTIONS'] = json.dumps(self.cookie_options)
+
+        env["JUPYTERHUB_COOKIE_HOST_PREFIX_ENABLED"] = str(
+            int(self.cookie_host_prefix_enabled)
+        )
         env['JUPYTERHUB_HOST'] = self.hub.public_host
         env['JUPYTERHUB_OAUTH_CALLBACK_URL'] = url_path_join(
             self.user.url, url_escape_path(self.name), 'oauth_callback'
diff --git a/jupyterhub/tests/browser/test_browser.py b/jupyterhub/tests/browser/test_browser.py
index 207a65119a..c29ffb1491 100644
--- a/jupyterhub/tests/browser/test_browser.py
+++ b/jupyterhub/tests/browser/test_browser.py
@@ -1,6 +1,8 @@
 """Tests for the Playwright Python"""
 
+import asyncio
 import json
+import pprint
 import re
 from urllib.parse import parse_qs, urlparse
 
@@ -10,7 +12,7 @@
 from tornado.httputil import url_concat
 
 from jupyterhub import orm, roles, scopes
-from jupyterhub.tests.utils import public_host, public_url, ujoin
+from jupyterhub.tests.utils import async_requests, public_host, public_url, ujoin
 from jupyterhub.utils import url_escape_path, url_path_join
 
 pytestmark = pytest.mark.browser
@@ -41,7 +43,7 @@ async def test_submit_login_form(app, browser, user_special_chars):
     login_url = url_path_join(public_host(app), app.hub.base_url, "login")
     await browser.goto(login_url)
     await login(browser, user.name, password=user.name)
-    expected_url = ujoin(public_url(app), f"/user/{user_special_chars.urlname}/")
+    expected_url = public_url(app, user)
     await expect(browser).to_have_url(expected_url)
 
 
@@ -53,7 +55,7 @@ async def test_submit_login_form(app, browser, user_special_chars):
             # will encode given parameters for an unauthenticated URL in the next url
             # the next parameter will contain the app base URL (replaces BASE_URL in tests)
             'spawn',
-            [('param', 'value')],
+            {'param': 'value'},
             '/hub/login?next={{BASE_URL}}hub%2Fspawn%3Fparam%3Dvalue',
             '/hub/login?next={{BASE_URL}}hub%2Fspawn%3Fparam%3Dvalue',
         ),
@@ -61,15 +63,15 @@ async def test_submit_login_form(app, browser, user_special_chars):
             # login?param=fromlogin&next=encoded(/hub/spawn?param=value)
             # will drop parameters given to the login page, passing only the next url
             'login',
-            [('param', 'fromlogin'), ('next', '/hub/spawn?param=value')],
-            '/hub/login?param=fromlogin&next=%2Fhub%2Fspawn%3Fparam%3Dvalue',
-            '/hub/login?next=%2Fhub%2Fspawn%3Fparam%3Dvalue',
+            {'param': 'fromlogin', 'next': '/hub/spawn?param=value'},
+            '/hub/login?param=fromlogin&next={{BASE_URL}}hub%2Fspawn%3Fparam%3Dvalue',
+            '/hub/login?next={{BASE_URL}}hub%2Fspawn%3Fparam%3Dvalue',
         ),
         (
             # login?param=value&anotherparam=anothervalue
             # will drop parameters given to the login page, and use an empty next url
             'login',
-            [('param', 'value'), ('anotherparam', 'anothervalue')],
+            {'param': 'value', 'anotherparam': 'anothervalue'},
             '/hub/login?param=value&anotherparam=anothervalue',
             '/hub/login?next=',
         ),
@@ -77,7 +79,7 @@ async def test_submit_login_form(app, browser, user_special_chars):
             # login
             # simplest case, accessing the login URL, gives an empty next url
             'login',
-            [],
+            {},
             '/hub/login',
             '/hub/login?next=',
         ),
@@ -95,6 +97,8 @@ async def test_open_url_login(
     user = user_special_chars.user
     login_url = url_path_join(public_host(app), app.hub.base_url, url)
     await browser.goto(login_url)
+    if params.get("next"):
+        params["next"] = url_path_join(app.base_url, params["next"])
     url_new = url_path_join(public_host(app), app.hub.base_url, url_concat(url, params))
     print(url_new)
     await browser.goto(url_new)
@@ -730,12 +734,15 @@ async def test_oauth_page(
     oauth_client.allowed_scopes = sorted(roles.roles_to_scopes([service_role]))
     app.db.commit()
     # open the service url in the browser
-    service_url = url_path_join(public_url(app, service) + 'owhoami/?arg=x')
+    service_url = url_path_join(public_url(app, service), 'owhoami/?arg=x')
     await browser.goto(service_url)
 
-    expected_redirect_url = url_path_join(
-        app.base_url + f"services/{service.name}/oauth_callback"
-    )
+    if app.subdomain_host:
+        expected_redirect_url = url_path_join(
+            public_url(app, service), "oauth_callback"
+        )
+    else:
+        expected_redirect_url = url_path_join(service.prefix, "oauth_callback")
     expected_client_id = f"service-{service.name}"
 
     # decode the URL
@@ -1112,3 +1119,225 @@ async def click_stop_button(browser, username):
     await expect(browser.get_by_role("button", name="Spawn Page")).to_have_count(
         len(users_list)
     )
+
+
+@pytest.mark.parametrize(
+    "case",
+    [
+        "fresh",
+        "invalid",
+        "valid-prefix-invalid-root",
+    ],
+)
+async def test_login_xsrf_initial_cookies(app, browser, case, username):
+    """Test that login works with various initial states for xsrf tokens
+
+    Page will be reloaded with correct values
+    """
+    hub_root = public_host(app)
+    hub_url = url_path_join(public_host(app), app.hub.base_url)
+    login_url = url_path_join(
+        hub_url, url_concat("login", {"next": url_path_join(app.base_url, "/hub/home")})
+    )
+    # start with all cookies cleared
+    await browser.context.clear_cookies()
+    if case == "invalid":
+        await browser.context.add_cookies(
+            [{"name": "_xsrf", "value": "invalid-hub-prefix", "url": hub_url}]
+        )
+    elif case == "valid-prefix-invalid-root":
+        await browser.goto(login_url)
+        # first visit sets valid xsrf cookie
+        cookies = await browser.context.cookies()
+        assert len(cookies) == 1
+        # second visit is also made with invalid xsrf on `/`
+        # handling of this behavior is undefined in HTTP itself!
+        # _either_ the invalid cookie on / is ignored
+        # _or_ both will be cleared
+        # currently, this test assumes the observed behavior,
+        # which is that the invalid cookie on `/` has _higher_ priority
+        await browser.context.add_cookies(
+            [{"name": "_xsrf", "value": "invalid-root", "url": hub_root}]
+        )
+        cookies = await browser.context.cookies()
+        assert len(cookies) == 2
+
+    # after visiting page, cookies get re-established
+    await browser.goto(login_url)
+    cookies = await browser.context.cookies()
+    print(cookies)
+    cookie = cookies[0]
+    assert cookie['name'] == '_xsrf'
+    assert cookie["path"] == app.hub.base_url
+
+    # next page visit, cookies don't change
+    await browser.goto(login_url)
+    cookies_2 = await browser.context.cookies()
+    assert cookies == cookies_2
+    # login is successful
+    await login(browser, username, username)
+
+
+def _cookie_dict(cookie_list):
+    """Convert list of cookies to dict of the form
+
+    { 'path': {'key': {cookie} } }
+    """
+    cookie_dict = {}
+    for cookie in cookie_list:
+        path_cookies = cookie_dict.setdefault(cookie['path'], {})
+        path_cookies[cookie['name']] = cookie
+    return cookie_dict
+
+
+async def test_singleuser_xsrf(app, browser, user, create_user_with_scopes, full_spawn):
+    # full login process, checking XSRF handling
+    # start two servers
+    target_user = user
+    target_start = asyncio.ensure_future(target_user.spawn())
+
+    browser_user = create_user_with_scopes("self", "access:servers")
+    # login browser_user
+    login_url = url_path_join(public_host(app), app.hub.base_url, "login")
+    await browser.goto(login_url)
+    await login(browser, browser_user.name, browser_user.name)
+    # end up at single-user
+    await expect(browser).to_have_url(re.compile(rf".*/user/{browser_user.name}/.*"))
+    # wait for target user to start, too
+    await target_start
+    await app.proxy.add_user(target_user)
+
+    # visit target user, sets credentials for second server
+    await browser.goto(public_url(app, target_user))
+    await expect(browser).to_have_url(re.compile(r".*/oauth2/authorize"))
+    auth_button = browser.locator('//input[@type="submit"]')
+    await expect(auth_button).to_be_enabled()
+    await auth_button.click()
+    await expect(browser).to_have_url(re.compile(rf".*/user/{target_user.name}/.*"))
+
+    # at this point, we are on a page served by target_user,
+    # logged in as browser_user
+    # basic check that xsrf isolation works
+    cookies = await browser.context.cookies()
+    cookie_dict = _cookie_dict(cookies)
+    pprint.pprint(cookie_dict)
+
+    # we should have xsrf tokens for both singleuser servers and the hub
+    target_prefix = target_user.prefix
+    user_prefix = browser_user.prefix
+    hub_prefix = app.hub.base_url
+    assert target_prefix in cookie_dict
+    assert user_prefix in cookie_dict
+    assert hub_prefix in cookie_dict
+    target_xsrf = cookie_dict[target_prefix].get("_xsrf", {}).get("value")
+    assert target_xsrf
+    user_xsrf = cookie_dict[user_prefix].get("_xsrf", {}).get("value")
+    assert user_xsrf
+    hub_xsrf = cookie_dict[hub_prefix].get("_xsrf", {}).get("value")
+    assert hub_xsrf
+    assert hub_xsrf != target_xsrf
+    assert hub_xsrf != user_xsrf
+    assert target_xsrf != user_xsrf
+
+    # we are on a page served by target_user
+    # check that we can't access
+
+    async def fetch_user_page(path, params=None):
+        url = url_path_join(public_url(app, browser_user), path)
+        if params:
+            url = url_concat(url, params)
+        status = await browser.evaluate(
+            """
+            async (user_url) => {
+              try {
+                response = await fetch(user_url);
+              } catch (e) {
+                return 'error';
+              }
+              return response.status;
+            }
+            """,
+            url,
+        )
+        return status
+
+    if app.subdomain_host:
+        expected_status = 'error'
+    else:
+        expected_status = 403
+    status = await fetch_user_page("/api/contents")
+    assert status == expected_status
+    status = await fetch_user_page("/api/contents", params={"_xsrf": target_xsrf})
+    assert status == expected_status
+
+    if not app.subdomain_host:
+        expected_status = 200
+    status = await fetch_user_page("/api/contents", params={"_xsrf": user_xsrf})
+    assert status == expected_status
+
+    # check that we can't iframe the other user's page
+    async def iframe(src):
+        return await browser.evaluate(
+            """
+            async (src) => {
+                const frame = document.createElement("iframe");
+                frame.src = src;
+                return new Promise((resolve, reject) => {
+                    frame.addEventListener("load", (event) => {
+                        if (frame.contentDocument) {
+                            resolve("got document!");
+                        } else {
+                            resolve("blocked")
+                        }
+                    });
+                    setTimeout(() => {
+                        // some browsers (firefox) never fire load event
+                        // despite spec appasrently stating it must always do so,
+                        // even for rejected frames
+                        resolve("timeout")
+                    }, 3000)
+
+                    document.body.appendChild(frame);
+                });
+            }
+            """,
+            src,
+        )
+
+    hub_iframe = await iframe(url_path_join(public_url(app), "hub/admin"))
+    assert hub_iframe in {"timeout", "blocked"}
+    user_iframe = await iframe(public_url(app, browser_user))
+    assert user_iframe in {"timeout", "blocked"}
+
+    # check that server page can still connect to its own kernels
+    token = target_user.new_api_token(scopes=["access:servers!user"])
+    url = url_path_join(public_url(app, target_user), "/api/kernels")
+    headers = {"Authorization": f"Bearer {token}"}
+    r = await async_requests.post(url, headers=headers)
+    r.raise_for_status()
+    kernel = r.json()
+    kernel_id = kernel["id"]
+    kernel_url = url_path_join(url, kernel_id)
+    kernel_ws_url = "ws" + url_path_join(kernel_url, "channels")[4:]
+    try:
+        result = await browser.evaluate(
+            """
+            async (ws_url) => {
+                ws = new WebSocket(ws_url);
+                finished = await new Promise((resolve, reject) => {
+                    ws.onerror = (err) => {
+                        reject(err);
+                    };
+                    ws.onopen = () => {
+                        resolve("ok");
+                    };
+                });
+                return finished;
+            }
+            """,
+            kernel_ws_url,
+        )
+    finally:
+        r = await async_requests.delete(kernel_url, headers=headers)
+        r.raise_for_status()
+    assert result == "ok"
diff --git a/jupyterhub/tests/mocking.py b/jupyterhub/tests/mocking.py
index 8b7857ab07..3615e9d0b7 100644
--- a/jupyterhub/tests/mocking.py
+++ b/jupyterhub/tests/mocking.py
@@ -43,8 +43,8 @@
 from ..app import JupyterHub
 from ..auth import PAMAuthenticator
 from ..spawner import SimpleLocalProcessSpawner
-from ..utils import random_port, utcnow
-from .utils import async_requests, public_url, ssl_setup
+from ..utils import random_port, url_path_join, utcnow
+from .utils import AsyncSession, public_url, ssl_setup
 
 
 def mock_authenticate(username, password, service, encoding):
@@ -356,29 +356,32 @@ def cleanup():
     async def login_user(self, name):
         """Login a user by name, returning her cookies."""
         base_url = public_url(self)
-        external_ca = None
+        s = AsyncSession()
         if self.internal_ssl:
-            external_ca = self.external_certs['files']['ca']
+            s.verify = self.external_certs['files']['ca']
         login_url = base_url + 'hub/login'
-        r = await async_requests.get(login_url)
+        r = await s.get(login_url)
         r.raise_for_status()
         xsrf = r.cookies['_xsrf']
 
-        r = await async_requests.post(
+        r = await s.post(
             url_concat(login_url, {"_xsrf": xsrf}),
-            cookies=r.cookies,
             data={'username': name, 'password': name},
             allow_redirects=False,
-            verify=external_ca,
         )
         r.raise_for_status()
-        r.cookies["_xsrf"] = xsrf
-        assert sorted(r.cookies.keys()) == [
+        # make second request to get updated xsrf cookie
+        r2 = await s.get(
+            url_path_join(base_url, "hub/home"),
+            allow_redirects=False,
+        )
+        assert r2.status_code == 200
+        assert sorted(s.cookies.keys()) == [
             '_xsrf',
             'jupyterhub-hub-login',
             'jupyterhub-session-id',
         ]
-        return r.cookies
+        return s.cookies
 
 
 class InstrumentedSpawner(MockSpawner):
diff --git a/jupyterhub/tests/test_api.py b/jupyterhub/tests/test_api.py
index e37334f438..e16933399d 100644
--- a/jupyterhub/tests/test_api.py
+++ b/jupyterhub/tests/test_api.py
@@ -96,7 +96,7 @@ async def test_post_content_type(app, content_type, status):
     assert r.status_code == status
 
 
-@mark.parametrize("xsrf_in_url", [True, False])
+@mark.parametrize("xsrf_in_url", [True, False, "invalid"])
 @mark.parametrize(
     "method, path",
     [
@@ -107,6 +107,13 @@ async def test_post_content_type(app, content_type, status):
 async def test_xsrf_check(app, username, method, path, xsrf_in_url):
     cookies = await app.login_user(username)
     xsrf = cookies['_xsrf']
+    if xsrf_in_url == "invalid":
+        cookies.pop("_xsrf")
+        # a valid old-style tornado xsrf token is no longer valid
+        xsrf = cookies['_xsrf'] = (
+            "2|7329b149|d837ced983e8aac7468bc7a61ce3d51a|1708610065"
+        )
+
     url = path.format(username=username)
     if xsrf_in_url:
         url = f"{url}?_xsrf={xsrf}"
@@ -117,7 +124,7 @@ async def test_xsrf_check(app, username, method, path, xsrf_in_url):
         noauth=True,
         cookies=cookies,
     )
-    if xsrf_in_url:
+    if xsrf_in_url is True:
         assert r.status_code == 200
     else:
         assert r.status_code == 403
diff --git a/jupyterhub/tests/test_pages.py b/jupyterhub/tests/test_pages.py
index 375e23539f..ac2490fc0b 100644
--- a/jupyterhub/tests/test_pages.py
+++ b/jupyterhub/tests/test_pages.py
@@ -683,11 +683,10 @@ async def test_other_user_url(app, username, user, group, create_temp_role, has_
     ],
 )
 async def test_page_with_token(app, user, url, token_in):
-    cookies = await app.login_user(user.name)
     token = user.new_api_token()
     if token_in == "url":
         url = url_concat(url, {"token": token})
-        headers = None
+        headers = {}
     elif token_in == "header":
         headers = {
             "Authorization": f"token {token}",
@@ -732,14 +731,13 @@ async def test_login_strip(app, form_user, auth_user, form_password):
     """Test that login form strips space form usernames, but not passwords"""
     form_data = {"username": form_user, "password": form_password}
     expected_auth = {"username": auth_user, "password": form_password}
-    base_url = public_url(app)
     called_with = []
 
     async def mock_authenticate(handler, data):
         called_with.append(data)
 
     with mock.patch.object(app.authenticator, 'authenticate', mock_authenticate):
-        r = await async_requests.get(base_url + 'hub/login')
+        r = await get_page('login', app)
         r.raise_for_status()
         cookies = r.cookies
         xsrf = cookies['_xsrf']
@@ -920,17 +918,19 @@ def get(self):
 async def test_auto_login_logout(app):
     name = 'burnham'
     cookies = await app.login_user(name)
+    s = AsyncSession()
+    s.cookies = cookies
 
     with mock.patch.dict(
         app.tornado_settings, {'authenticator': Authenticator(auto_login=True)}
     ):
-        r = await async_requests.get(
+        r = await s.get(
             public_host(app) + app.tornado_settings['logout_url'], cookies=cookies
         )
     r.raise_for_status()
     logout_url = public_host(app) + app.tornado_settings['logout_url']
     assert r.url == logout_url
-    assert r.cookies == {}
+    assert list(s.cookies.keys()) == ["_xsrf"]
     # don't include logged-out user in page:
     try:
         idx = r.text.index(name)
@@ -944,19 +944,23 @@ async def test_auto_login_logout(app):
 async def test_logout(app):
     name = 'wash'
     cookies = await app.login_user(name)
-    r = await async_requests.get(
-        public_host(app) + app.tornado_settings['logout_url'], cookies=cookies
+    s = AsyncSession()
+    s.cookies = cookies
+    r = await s.get(
+        public_host(app) + app.tornado_settings['logout_url'],
     )
     r.raise_for_status()
     login_url = public_host(app) + app.tornado_settings['login_url']
     assert r.url == login_url
-    assert r.cookies == {}
+    assert list(s.cookies.keys()) == ["_xsrf"]
 
 
 @pytest.mark.parametrize('shutdown_on_logout', [True, False])
 async def test_shutdown_on_logout(app, shutdown_on_logout):
     name = 'shutitdown'
     cookies = await app.login_user(name)
+    s = AsyncSession()
+    s.cookies = cookies
     user = app.users[name]
 
     # start the user's server
@@ -976,14 +980,14 @@ async def test_shutdown_on_logout(app, shutdown_on_logout):
     with mock.patch.dict(
         app.tornado_settings, {'shutdown_on_logout': shutdown_on_logout}
     ):
-        r = await async_requests.get(
+        r = await s.get(
             public_host(app) + app.tornado_settings['logout_url'], cookies=cookies
         )
         r.raise_for_status()
 
     login_url = public_host(app) + app.tornado_settings['login_url']
     assert r.url == login_url
-    assert r.cookies == {}
+    assert list(s.cookies.keys()) == ["_xsrf"]
 
     # wait for any pending state to resolve
     for i in range(50):
diff --git a/jupyterhub/tests/test_services_auth.py b/jupyterhub/tests/test_services_auth.py
index 3a4081e141..de72fdba0f 100644
--- a/jupyterhub/tests/test_services_auth.py
+++ b/jupyterhub/tests/test_services_auth.py
@@ -385,7 +385,7 @@ async def test_oauth_service_roles(
     # token-authenticated request to HubOAuth
     token = app.users[name].new_api_token()
     # token in ?token parameter
-    r = await async_requests.get(url_concat(url, {'token': token}))
+    r = await async_requests.get(url_concat(url, {'token': token}), headers=s.headers)
     r.raise_for_status()
     reply = r.json()
     assert reply['name'] == name
@@ -393,7 +393,9 @@ async def test_oauth_service_roles(
     # verify that ?token= requests set a cookie
     assert len(r.cookies) != 0
     # ensure cookie works in future requests
-    r = await async_requests.get(url, cookies=r.cookies, allow_redirects=False)
+    r = await async_requests.get(
+        url, cookies=r.cookies, allow_redirects=False, headers=s.headers
+    )
     r.raise_for_status()
     assert r.url == url
     reply = r.json()
diff --git a/jupyterhub/tests/test_singleuser.py b/jupyterhub/tests/test_singleuser.py
index 7b365bcdc9..5d3e8baef4 100644
--- a/jupyterhub/tests/test_singleuser.py
+++ b/jupyterhub/tests/test_singleuser.py
@@ -74,18 +74,20 @@ async def test_singleuser_auth(
     spawner = user.spawners[server_name]
     url = url_path_join(public_url(app, user), server_name)
 
+    s = AsyncSession()
+
     # no cookies, redirects to login page
-    r = await async_requests.get(url)
+    r = await s.get(url)
     r.raise_for_status()
     assert '/hub/login' in r.url
 
     # unauthenticated /api/ should 403, not redirect
     api_url = url_path_join(url, "api/status")
-    r = await async_requests.get(api_url, allow_redirects=False)
+    r = await s.get(api_url, allow_redirects=False)
     assert r.status_code == 403
 
     # with cookies, login successful
-    r = await async_requests.get(url, cookies=cookies)
+    r = await s.get(url, cookies=cookies)
     r.raise_for_status()
     assert (
         urlparse(r.url)
@@ -99,7 +101,7 @@ async def test_singleuser_auth(
     assert r.status_code == 200
 
     # logout
-    r = await async_requests.get(url_path_join(url, 'logout'), cookies=cookies)
+    r = await s.get(url_path_join(url, 'logout'))
     assert len(r.cookies) == 0
 
     # accessing another user's server hits the oauth confirmation page
@@ -145,6 +147,8 @@ async def test_singleuser_auth(
 async def test_disable_user_config(request, app, tmpdir, full_spawn):
     # login, start the server
     cookies = await app.login_user('nandy')
+    s = AsyncSession()
+    s.cookies = cookies
     user = app.users['nandy']
     # stop spawner, if running:
     if user.running:
@@ -169,16 +173,14 @@ async def test_disable_user_config(request, app, tmpdir, full_spawn):
     url = public_url(app, user)
 
     # with cookies, login successful
-    r = await async_requests.get(url, cookies=cookies)
+    r = await s.get(url)
     r.raise_for_status()
     assert r.url.rstrip('/').endswith(
         url_path_join('/user/nandy', user.spawner.default_url or "/tree")
     )
     assert r.status_code == 200
 
-    r = await async_requests.get(
-        url_path_join(public_url(app, user), 'jupyterhub-test-info'), cookies=cookies
-    )
+    r = await s.get(url_path_join(public_url(app, user), 'jupyterhub-test-info'))
     r.raise_for_status()
     info = r.json()
     pprint(info)
@@ -374,19 +376,31 @@ async def test_nbclassic_control_panel(app, user, full_spawn):
 @pytest.mark.skipif(
     IS_JUPYVERSE, reason="jupyverse doesn't implement token authentication"
 )
-async def test_token_url_cookie(app, user, full_spawn):
+@pytest.mark.parametrize("accept_token_in_url", ["1", "0", ""])
+async def test_token_url_cookie(app, user, full_spawn, accept_token_in_url):
+    if accept_token_in_url:
+        user.spawner.environment["JUPYTERHUB_ALLOW_TOKEN_IN_URL"] = accept_token_in_url
+    should_accept = accept_token_in_url != "0"
+
     await user.spawn()
+    await app.proxy.add_user(user)
+
     token = user.new_api_token(scopes=["access:servers!user"])
     url = url_path_join(public_url(app, user), user.spawner.default_url or "/tree/")
 
     # first request: auth with token in URL
-    r = await async_requests.get(url + f"?token={token}", allow_redirects=False)
+    s = AsyncSession()
+    r = await s.get(url + f"?token={token}", allow_redirects=False)
     print(r.url, r.status_code)
+    if not should_accept:
+        assert r.status_code == 302
+        return
+
     assert r.status_code == 200
-    assert r.cookies
+    assert s.cookies
     # second request, use cookies set by first response,
     # no token in URL
-    r = await async_requests.get(url, cookies=r.cookies, allow_redirects=False)
+    r = await s.get(url, allow_redirects=False)
     assert r.status_code == 200
     await user.stop()
 
@@ -396,7 +410,8 @@ async def test_api_403_no_cookie(app, user, full_spawn):
     await user.spawn()
     await app.proxy.add_user(user)
     url = url_path_join(public_url(app, user), "/api/contents/")
-    r = await async_requests.get(url, allow_redirects=False)
+    s = AsyncSession()
+    r = await s.get(url, allow_redirects=False)
     # 403, not redirect
     assert r.status_code == 403
     # no state cookie set
diff --git a/jupyterhub/tests/utils.py b/jupyterhub/tests/utils.py
index 542226583a..143b2a9a12 100644
--- a/jupyterhub/tests/utils.py
+++ b/jupyterhub/tests/utils.py
@@ -42,6 +42,13 @@ def __getattr__(self, name):
 class AsyncSession(requests.Session):
     """requests.Session object that runs in the background thread"""
 
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # session requests are for cookie authentication
+        # and should look like regular page views,
+        # so set Sec-Fetch-Mode: navigate
+        self.headers.setdefault("Sec-Fetch-Mode", "navigate")
+
     def request(self, *args, **kwargs):
         return async_requests.executor.submit(super().request, *args, **kwargs)
 
@@ -157,6 +164,7 @@ async def api_request(
     else:
         base_url = public_url(app, path='hub')
     headers = kwargs.setdefault('headers', {})
+    headers.setdefault("Sec-Fetch-Mode", "cors")
     if 'Authorization' not in headers and not noauth and 'cookies' not in kwargs:
         # make a copy to avoid modifying arg in-place
         kwargs['headers'] = h = {}
@@ -176,7 +184,7 @@ async def api_request(
         kwargs['cert'] = (app.internal_ssl_cert, app.internal_ssl_key)
         kwargs["verify"] = app.internal_ssl_ca
     resp = await f(url, **kwargs)
-    assert "frame-ancestors 'self'" in resp.headers['Content-Security-Policy']
+    assert "frame-ancestors 'none'" in resp.headers['Content-Security-Policy']
     assert (
         ujoin(app.hub.base_url, "security/csp-report")
         in resp.headers['Content-Security-Policy']
@@ -197,6 +205,9 @@ def get_page(path, app, hub=True, **kw):
     else:
         prefix = app.base_url
     base_url = ujoin(public_host(app), prefix)
+    # Sec-Fetch-Mode=navigate to look like a regular page view
+    headers = kw.setdefault("headers", {})
+    headers.setdefault("Sec-Fetch-Mode", "navigate")
     return async_requests.get(ujoin(base_url, path), **kw)
 
 
diff --git a/jupyterhub/user.py b/jupyterhub/user.py
index bee9204381..e4d13b215d 100644
--- a/jupyterhub/user.py
+++ b/jupyterhub/user.py
@@ -461,6 +461,9 @@ def _new_spawner(self, server_name, spawner_class=None, **kwargs):
             _deprecated_db_session=self.db,
             oauth_client_id=client_id,
             cookie_options=self.settings.get('cookie_options', {}),
+            cookie_host_prefix_enabled=self.settings.get(
+                "cookie_host_prefix_enabled", False
+            ),
             trusted_alt_names=trusted_alt_names,
             user_options=orm_spawner.user_options or {},
         )
diff --git a/jupyterhub/utils.py b/jupyterhub/utils.py
index 91e9c42b63..4645dde2ac 100644
--- a/jupyterhub/utils.py
+++ b/jupyterhub/utils.py
@@ -8,6 +8,7 @@
 import functools
 import hashlib
 import inspect
+import os
 import random
 import secrets
 import socket
@@ -30,6 +31,21 @@
 from tornado.log import app_log
 
 
+def _bool_env(key, default=False):
+    """Cast an environment variable to bool
+
+    If unset or empty, return `default`
+    `0` is False; all other values are True.
+    """
+    value = os.environ.get(key, "")
+    if value == "":
+        return default
+    if value.lower() in {"0", "false"}:
+        return False
+    else:
+        return True
+
+
 # Deprecated aliases: no longer needed now that we require 3.7
 def asyncio_all_tasks(loop=None):
     warnings.warn(",
"url": "https://github.com/jupyterhub/jupyterhub/commit/e2798a088f5ad45340fe79cdf1386198e664f77f.patch"
}
] |
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
CVE-2016-9288
|
In framework/modules/navigation/controllers/navigationController.php in Exponent CMS v2.4.0 or older, the parameter "target" of function "DragnDropReRank" is directly used without any filtration which caused SQL injection. The payload can be used like this: /navigation/DragnDropReRank/target/1.
|
[
{
"commit_message": "[PATCH] fix security vulnerability to reranking pages; reported by kyohpc .../modules/navigation/controllers/navigationController.php | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/exponentcms/exponent-cms/commit/2ddffb2e7eafe4830e3483a4b437873022c461ba.patch"
}
] |
n/a
|
|
GHSA-mhpq-9638-x6pw
|
Denial of service when decrypting attack controlled input in github.com/dvsekhvalnov/jose2go
| null |
[
{
"commit_message": "[PATCH] Adding min/max iteration count guards to pbes2-hmac-aeskw algorithm jose_test.go | 34 ++++++++++++++++++++++++++++++ pbse2_hmac_aeskw.go | 51 +++++++++++++++++++++++++++++++++++++++------ 2 files changed, 79 insertions(+), 6 deletions(-)",
"patch_text_b64": "From a4584e9dd7128608fedbc67892eba9697f0d5317 Mon Sep 17 00:00:00 2001
From: DV <dvsekhvalnov@gmail.com>
Date: Thu, 23 Nov 2023 20:26:26 +0300
Subject: [PATCH] Adding min/max iteration count guards to pbes2-hmac-aeskw
 algorithm

---
 jose_test.go        | 34 ++++++++++++++++++++++++++++++
 pbse2_hmac_aeskw.go | 51 +++++++++++++++++++++++++++++++++++++++------
 2 files changed, 79 insertions(+), 6 deletions(-)

diff --git a/jose_test.go b/jose_test.go
index 62cb6c6..2b67fd6 100644
--- a/jose_test.go
+++ b/jose_test.go
@@ -1634,6 +1634,40 @@ func (s *TestSuite) TestDecrypt_PBSE2_HS512_A256KW_A256CBC_HS512(c *C) {
 	c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`)
 }
 
+func (s *TestSuite) TestDecrypt_PBSE2_HS512_A256KW_A256CBC_HS512_MinIterationViolation(c *C) {
+	//given
+	pbes2Hs512 := DeregisterJwa(PBES2_HS512_A256KW)
+	RegisterJwa(NewPbse2HmacAesKWAlg(256, 300000, 10000))
+	token := "eyJhbGciOiJQQkVTMi1IUzUxMitBMjU2S1ciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIiwicDJjIjo4MTkyLCJwMnMiOiJCUlkxQ1M3VXNpaTZJNzhkIn0.ovjAL7yRnB_XdJbK8lAaUDRZ-CyVeio8f4pnqOt1FPj1PoQAdEX3S5x6DlzR8aqN_WR5LUwdqDSyUDYhSurnmq8VLfzd3AEe.YAjH6g_zekXJIlPN4Ooo5Q.tutaltxpeVyayXZ9pQovGXTWTf_GWWvtu25Jeg9jgoH0sUX9KCnL00A69e4GJR6EMxalmWsa45AItffbwjUBmwdyklC4ZbTgaovVRs-UwqsZFBO2fpEb7qLajjwra7o4OegzgXDD0jhrKrUusvRWGBvenvumb5euibUxmIfBUcVF1JbdfYxx7ztFeS-QKJpDkE00zyEkViq-QxfrMVl5p7LGmTz8hMrFL3LXLokypZSDgFBfsUzChJf3mlYzxiGaGUqhs7NksQJDoUYf6prPow.XwRVfVTTPogO74RnxZD_9Mse26fTSehna1pbWy4VHfY"
+
+	//when
+	test, headers, err := Decode(token, "top secret")
+	fmt.Printf("\np2c min iteration err= %v\n", err)
+
+	//then
+	RegisterJwa(pbes2Hs512)
+	c.Assert(err, NotNil)
+	c.Assert(test, Equals, "")
+	c.Assert(headers, IsNil)
+}
+
+func (s *TestSuite) TestDecrypt_PBSE2_HS512_A256KW_A256CBC_HS512_MaxIterationViolation(c *C) {
+	//given
+	pbes2Hs512 := DeregisterJwa(PBES2_HS512_A256KW)
+	RegisterJwa(NewPbse2HmacAesKWAlg(256, 8000, 0))
+	token := "eyJhbGciOiJQQkVTMi1IUzUxMitBMjU2S1ciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIiwicDJjIjo4MTkyLCJwMnMiOiJCUlkxQ1M3VXNpaTZJNzhkIn0.ovjAL7yRnB_XdJbK8lAaUDRZ-CyVeio8f4pnqOt1FPj1PoQAdEX3S5x6DlzR8aqN_WR5LUwdqDSyUDYhSurnmq8VLfzd3AEe.YAjH6g_zekXJIlPN4Ooo5Q.tutaltxpeVyayXZ9pQovGXTWTf_GWWvtu25Jeg9jgoH0sUX9KCnL00A69e4GJR6EMxalmWsa45AItffbwjUBmwdyklC4ZbTgaovVRs-UwqsZFBO2fpEb7qLajjwra7o4OegzgXDD0jhrKrUusvRWGBvenvumb5euibUxmIfBUcVF1JbdfYxx7ztFeS-QKJpDkE00zyEkViq-QxfrMVl5p7LGmTz8hMrFL3LXLokypZSDgFBfsUzChJf3mlYzxiGaGUqhs7NksQJDoUYf6prPow.XwRVfVTTPogO74RnxZD_9Mse26fTSehna1pbWy4VHfY"
+
+	//when
+	test, headers, err := Decode(token, "top secret")
+	fmt.Printf("\np2c max iteration err= %v\n", err)
+
+	//then
+	RegisterJwa(pbes2Hs512)
+	c.Assert(err, NotNil)
+	c.Assert(test, Equals, "")
+	c.Assert(headers, IsNil)
+}
+
 func (s *TestSuite) TestEncrypt_PBSE2_HS256_A128KW_A128GCM(c *C) {
 	//given
 	payload := `{"hello": "world"}`
diff --git a/pbse2_hmac_aeskw.go b/pbse2_hmac_aeskw.go
index baeaf9c..154c0f3 100644
--- a/pbse2_hmac_aeskw.go
+++ b/pbse2_hmac_aeskw.go
@@ -4,6 +4,7 @@ import (
 	"crypto/sha256"
 	"crypto/sha512"
 	"errors"
+	"fmt"
 	"hash"
 
 	"github.com/dvsekhvalnov/jose2go/arrays"
@@ -12,15 +13,28 @@ import (
 )
 
 func init() {
-	RegisterJwa(&Pbse2HmacAesKW{keySizeBits: 128, aesKW: &AesKW{keySizeBits: 128}})
-	RegisterJwa(&Pbse2HmacAesKW{keySizeBits: 192, aesKW: &AesKW{keySizeBits: 192}})
-	RegisterJwa(&Pbse2HmacAesKW{keySizeBits: 256, aesKW: &AesKW{keySizeBits: 256}})
+	RegisterJwa(NewPbse2HmacAesKWAlg(128, 310000, 0))
+	RegisterJwa(NewPbse2HmacAesKWAlg(192, 250000, 0))
+	RegisterJwa(NewPbse2HmacAesKWAlg(256, 120000, 0))
 }
 
 // PBSE2 with HMAC key management algorithm implementation
 type Pbse2HmacAesKW struct {
-	keySizeBits int
-	aesKW       JwaAlgorithm
+	keySizeBits   int
+	aesKW         JwaAlgorithm
+	maxIterations int64
+	minIterations int64
+}
+
+func NewPbse2HmacAesKWAlg(keySize int, maxIters int64, minIters int64) JwaAlgorithm {
+	switch keySize {
+	case 128:
+		return &Pbse2HmacAesKW{keySizeBits: 128, maxIterations: maxIters, minIterations: minIters, aesKW: &AesKW{keySizeBits: 128}}
+	case 192:
+		return &Pbse2HmacAesKW{keySizeBits: 192, maxIterations: maxIters, minIterations: minIters, aesKW: &AesKW{keySizeBits: 192}}
+	default:
+		return &Pbse2HmacAesKW{keySizeBits: 256, maxIterations: maxIters, minIterations: minIters, aesKW: &AesKW{keySizeBits: 256}}
+	}
 }
 
 func (alg *Pbse2HmacAesKW) Name() string {
@@ -46,6 +60,21 @@ func (alg *Pbse2HmacAesKW) WrapNewKey(cekSizeBits int, key interface{}, header m
 			return nil, nil, err
 		}
 
+		// use user provided iteration counts if any
+		if p2c, ok := header["p2c"].(int); ok {
+			iterationCount = p2c
+		}
+
+		if int64(iterationCount) > alg.maxIterations {
+			return nil, nil, errors.New(
+				fmt.Sprintf("Pbse2HmacAesKW.Unwrap(): expected 'p2c' to be less than %v but got %v", alg.maxIterations, iterationCount))
+		}
+
+		if int64(iterationCount) < alg.minIterations {
+			return nil, nil, errors.New(
+				fmt.Sprintf("Pbse2HmacAesKW.Unwrap(): expected 'p2c' to be higher than %v but got %v", alg.minIterations, iterationCount))
+		}
+
 		header["p2c"] = iterationCount
 		header["p2s"] = base64url.Encode(saltInput)
 
@@ -69,8 +98,18 @@ func (alg *Pbse2HmacAesKW) Unwrap(encryptedCek []byte, key interface{}, cekSizeB
 			return nil, errors.New("Pbse2HmacAesKW.Unwrap(): expected 'p2c' param in JWT header, but was not found.")
 		}
 
+		if int64(p2c) > alg.maxIterations {
+			return nil, errors.New(
+				fmt.Sprintf("Pbse2HmacAesKW.Unwrap(): expected 'p2c' to be less than %v but got %v", alg.maxIterations, p2c))
+		}
+
+		if int64(p2c) < alg.minIterations {
+			return nil, errors.New(
+				fmt.Sprintf("Pbse2HmacAesKW.Unwrap(): expected 'p2c' to be higher than %v but got %v", alg.minIterations, p2c))
+		}
+
 		if p2s, ok = header["p2s"].(string); !ok {
-			return nil, errors.New("Pbse2HmacAesKW.Unwrap(): expected 'p2s' param in JWT header, but was not found.")
+			return nil, errors.New("Pbse2HmacAesKW.Unwrap(): expected 'p2s' param in JWT header, but was not found")
 		}
 
 		var saltInput []byte",
"url": "https://github.com/dvsekhvalnov/jose2go/commit/a4584e9dd7128608fedbc67892eba9697f0d5317.patch"
}
] | null |
CVE-2021-3817
|
SQL Injection in wbce/wbce_cms
|
wbce_cms is vulnerable to Improper Neutralization of Special Elements used in an SQL Command
|
[
{
"commit_message": "[PATCH] add captcha for login forgot wbce/admin/login/forgot/index.php | 176 ++++++++++-------- .../account/form_forgot.php | 161 +++++++++------- .../templates/form_forgot.twig | 8 +- .../argos_theme_reloaded/css/login.css | 9 + wbce/templates/argos_theme_reloaded/info.php | 4 +- .../templates/login_forgot.htt | 8 +- wbce/templates/wbce_flat_theme/css/login.css | 8 +- wbce/templates/wbce_flat_theme/info.php | 4 +- .../templates/login_forgot.htt | 1 + 9 files changed, 225 insertions(+), 154 deletions(-)",
"patch_text_b64": "From 6ca63f0cad5f0cd606fdb69a372f09b7d238f1d7 Mon Sep 17 00:00:00 2001
From: Colinax <christoph.bleiweis@outlook.com>
Date: Sun, 28 Nov 2021 16:16:13 +0100
Subject: [PATCH] add captcha for login forgot

---
 wbce/admin/login/forgot/index.php             | 176 ++++++++++--------
 .../account/form_forgot.php                   | 161 +++++++++-------
 .../templates/form_forgot.twig                |   8 +-
 .../argos_theme_reloaded/css/login.css        |   9 +
 wbce/templates/argos_theme_reloaded/info.php  |   4 +-
 .../templates/login_forgot.htt                |   8 +-
 wbce/templates/wbce_flat_theme/css/login.css  |   8 +-
 wbce/templates/wbce_flat_theme/info.php       |   4 +-
 .../templates/login_forgot.htt                |   1 +
 9 files changed, 225 insertions(+), 154 deletions(-)

diff --git a/wbce/admin/login/forgot/index.php b/wbce/admin/login/forgot/index.php
index e1ca95f46..4a4a9281b 100644
--- a/wbce/admin/login/forgot/index.php
+++ b/wbce/admin/login/forgot/index.php
@@ -17,99 +17,117 @@
 // Include the database class file and initiate an object
 require WB_PATH . '/framework/class.admin.php';
 $admin = new admin('Start', 'start', false, false);
+require_once(WB_PATH.'/include/captcha/captcha.php');
 
 $oMsgBox = new MessageBox();
 $oMsgBox->closeBtn = '';
 
 // Check if the user has already submitted the form, otherwise show it
-if (isset($_POST['email']) and $_POST['email'] != "") {
+if (isset($_POST['email']) && $_POST['email'] != "" ) {
     $email = strip_tags($wb->get_post('email'));
-    if ($admin->validate_email($email) == false) {
-        $oMsgBox->error($MESSAGE['USERS_INVALID_EMAIL']);
+    if(isset($_POST['captcha']) AND $_POST['captcha'] != ''){
+        $ccheck = time(); $ccheck1 = time();
+        if(isset($_SESSION['captchaloginforgot'])) $ccheck1 = $_SESSION['captchaloginforgot'];
+        if(isset($_SESSION['captcha'])) $ccheck = $_SESSION['captcha'];
+        if($_POST['captcha'] != $ccheck && $_POST['captcha'] != $ccheck1) {
+            $oMsgBox->error($MESSAGE['MOD_FORM_INCORRECT_CAPTCHA']);
+            $email = '';
+        }
+    } else {
+        $oMsgBox->error($MESSAGE['MOD_FORM_INCORRECT_CAPTCHA']);
         $email = '';
     }
-
-    // Check if the email exists in the database
-    $sSql = "SELECT * FROM `{TP}users` WHERE `email` = '" . $email . "'";
-    $rRow = $database->query($sSql);
-    if ($rRow->numRows() > 0) {
-
-        // Get the id, username, email, and last_reset from the above db query
-        $aUser = $rRow->fetchRow();
-        if (strlen($aUser['signup_confirmcode']) > 25) {
-            header("Location: " . WB_URL . "/account/signup_continue_page.php?switch=wrong_inputs");
-            exit(0); // break up the script here
-        }
-
-
-        // Check if the password has been reset in the last 2 hours
-        if ((time() - intval($aUser['last_reset'])) < (2 * 3600)) {
-            // Tell the user that their password cannot be reset more than once per hour
-            $oMsgBox->error($MESSAGE['FORGOT_PASS_ALREADY_RESET']);
-        } else {
-            $sCurrentPw = $aUser['password'];
-
-            // Generate a random password then update the database with it
-            $sNewPw = '';
-            $salt = "abchefghjkmnpqrstuvwxyz0123456789";
-            srand((double)microtime() * 1000000);
-            $i = 0;
-            while ($i <= 7) {
-                $num = rand() % 33;
-                $tmp = substr($salt, $num, 1);
-                $sNewPw = $sNewPw . $tmp;
-                $i++;
+    
+   
+    
+    if ($email != '') {
+         
+            if ($admin->validate_email($email) == false) {
+                $oMsgBox->error($MESSAGE['USERS_INVALID_EMAIL']);
+            }
+        
+        // Check if the email exists in the database
+        $sSql = "SELECT * FROM `{TP}users` WHERE `email`='".$database->escapeString($email)."'";
+        $rRow = $database->query($sSql);
+        if ($rRow->numRows() > 0) {
+
+            // Get the id, username, email, and last_reset from the above db query
+            $aUser = $rRow->fetchRow();
+            if (strlen($aUser['signup_confirmcode']) > 25) {
+                header("Location: " . WB_URL . "/account/signup_continue_page.php?switch=wrong_inputs");
+                exit(0); // break up the script here
             }
 
-            // update the new password in the database
-            $aUpdateUser = array(
-                'user_id' => $aUser['user_id'],
-                'password' => $wb->doPasswordEncode($sNewPw),
-                'last_reset' => time(),
-            );
-            $database->updateRow('{TP}users', 'user_id', $aUpdateUser);
-
-            if ($database->is_error()) {
-                // Error updating database
-                $oMsgBox->error($database->get_error());
-            } else {
-                // Setup email to send
-                $mail_to = $email;
-                $mail_subject = $MESSAGE['SIGNUP2_SUBJECT_LOGIN_INFO'];
-
-                // Replace placeholders from language variable with values
-                $search = array('{LOGIN_DISPLAY_NAME}', '{LOGIN_WEBSITE_TITLE}', '{LOGIN_NAME}', '{LOGIN_PASSWORD}');
-                $replace = array($aUser['display_name'], WEBSITE_TITLE, $aUser['username'], $sNewPw);
-
-                $aTokenReplace = array(
-                    '{LOGIN_DISPLAY_NAME}' => $aUser['display_name'],
-                    '{LOGIN_NAME}' => $aUser['username'],
-                    '{LOGIN_WEBSITE_TITLE}' => WEBSITE_TITLE,
-                    '{LOGIN_PASSWORD}' => $sNewPw
-                );
 
+            // Check if the password has been reset in the last 2 hours
+            if ((time() - intval($aUser['last_reset'])) < (2 * 3600)) {
+                // Tell the user that their password cannot be reset more than once per hour
+                $oMsgBox->error($MESSAGE['FORGOT_PASS_ALREADY_RESET']);
+            } else {
+                $sCurrentPw = $aUser['password'];
+
+                // Generate a random password then update the database with it
+                $sNewPw = '';
+                $salt = "abchefghjkmnpqrstuvwxyz0123456789";
+                srand((double)microtime() * 1000000);
+                $i = 0;
+                while ($i <= 7) {
+                    $num = rand() % 33;
+                    $tmp = substr($salt, $num, 1);
+                    $sNewPw = $sNewPw . $tmp;
+                    $i++;
+                }
 
-                $mail_message = strtr($MESSAGE['SIGNUP2_BODY_LOGIN_FORGOT'], $aTokenReplace);
+                // update the new password in the database
+                $aUpdateUser = array(
+                    'user_id' => $aUser['user_id'],
+                    'password' => $wb->doPasswordEncode($sNewPw),
+                    'last_reset' => time(),
+                );
+                $database->updateRow('{TP}users', 'user_id', $aUpdateUser);
 
-                // Try sending the email
-                if ($admin->mail(SERVER_EMAIL, $mail_to, $mail_subject, $mail_message)) {
-                    $oMsgBox->error($MESSAGE['FORGOT_PASS_PASSWORD_RESET']);
-                    $display_form = false;
+                if ($database->is_error()) {
+                    // Error updating database
+                    $oMsgBox->error($database->get_error());
                 } else {
-                    $aUpdateUser = array(
-                        'user_id' => $aUser['user_id'],
-                        'password' => $sCurrentPw
+                    // Setup email to send
+                    $mail_to = $email;
+                    $mail_subject = $MESSAGE['SIGNUP2_SUBJECT_LOGIN_INFO'];
+
+                    // Replace placeholders from language variable with values
+                    $search = array('{LOGIN_DISPLAY_NAME}', '{LOGIN_WEBSITE_TITLE}', '{LOGIN_NAME}', '{LOGIN_PASSWORD}');
+                    $replace = array($aUser['display_name'], WEBSITE_TITLE, $aUser['username'], $sNewPw);
+
+                    $aTokenReplace = array(
+                        '{LOGIN_DISPLAY_NAME}' => $aUser['display_name'],
+                        '{LOGIN_NAME}' => $aUser['username'],
+                        '{LOGIN_WEBSITE_TITLE}' => WEBSITE_TITLE,
+                        '{LOGIN_PASSWORD}' => $sNewPw
                     );
-                    $database->updateRow('{TP}users', 'user_id', $aUpdateUser);
-                    $oMsgBox->error($MESSAGE['FORGOT_PASS_CANNOT_EMAIL']);
+
+
+                    $mail_message = strtr($MESSAGE['SIGNUP2_BODY_LOGIN_FORGOT'], $aTokenReplace);
+
+                    // Try sending the email
+                    if ($admin->mail(SERVER_EMAIL, $mail_to, $mail_subject, $mail_message)) {
+                        $oMsgBox->error($MESSAGE['FORGOT_PASS_PASSWORD_RESET']);
+                        $display_form = false;
+                    } else {
+                        $aUpdateUser = array(
+                            'user_id' => $aUser['user_id'],
+                            'password' => $sCurrentPw
+                        );
+                        $database->updateRow('{TP}users', 'user_id', $aUpdateUser);
+                        $oMsgBox->error($MESSAGE['FORGOT_PASS_CANNOT_EMAIL']);
+                    }
                 }
             }
+        } else {
+            // Email doesn't exist, so tell the user
+            $oMsgBox->error($MESSAGE['FORGOT_PASS_EMAIL_NOT_FOUND']);
+            // and delete the wrong Email
+            $email = '';
         }
-    } else {
-        // Email doesn't exist, so tell the user
-        $oMsgBox->error($MESSAGE['FORGOT_PASS_EMAIL_NOT_FOUND']);
-        // and delete the wrong Email
-        $email = '';
     }
 } else {
     $email = '';
@@ -124,6 +142,13 @@
 $template->set_file('page', 'login_forgot.htt');
 $template->set_block('page', 'main_block', 'main');
 
+ob_start();
+call_captcha("all","",'loginforgot');
+$captcha = ob_get_contents();
+ob_end_clean();
+
+
+
 $aTemplateVars = array(
     'SECTION_FORGOT' => $MENU['FORGOT'],
     'MESSAGE_COLOR' => '', //$message_color,
@@ -143,6 +168,7 @@
     'INTERFACE_URL' => ADMIN_URL . '/interface',
     'DEFAULT_CHARSET' => defined('DEFAULT_CHARSET') ? DEFAULT_CHARSET : 'utf-8',
     'CHARSET' => isset($charset) ? $charset : 'utf-8',
+    'CAPTCHA' => $captcha
 );
 $template->set_var($aTemplateVars);
 
diff --git a/wbce/modules/tool_account_settings/account/form_forgot.php b/wbce/modules/tool_account_settings/account/form_forgot.php
index d821ec915..37c630fed 100644
--- a/wbce/modules/tool_account_settings/account/form_forgot.php
+++ b/wbce/modules/tool_account_settings/account/form_forgot.php
@@ -11,6 +11,7 @@
  */
 
 defined('WB_PATH') or die("Cannot access this file directly");
+require_once(WB_PATH.'/include/captcha/captcha.php');
 
 $oAccounts = new Accounts();
 $oMsgBox   = new MessageBox();
@@ -20,87 +21,104 @@
 
 if(isset($_POST['email']) && $_POST['email'] != "" ) {
     $sEmail = strip_tags($oAccounts->get_post('email'));
-    if($admin->validate_email($sEmail) == false) {
-        $oMsgBox->error($MESSAGE['USERS_INVALID_EMAIL']);
-        $sEmail  = '';
+    
+    if(isset($_POST['captcha']) AND $_POST['captcha'] != ''){
+        $ccheck = time(); $ccheck1 = time();
+        if(isset($_SESSION['captchaaccountforgot'])) $ccheck1 = $_SESSION['captchaaccountforgot'];
+        if(isset($_SESSION['captcha'])) $ccheck = $_SESSION['captcha'];
+        if($_POST['captcha'] != $ccheck && $_POST['captcha'] != $ccheck1) {
+            $oMsgBox->error($MESSAGE['MOD_FORM_INCORRECT_CAPTCHA']);
+            $sEmail = '';
+        }
     } else {
-        // Check if the email exists in the database
-        $sSql  = "SELECT * FROM `{TP}users` WHERE `email`='".$sEmail."'";
+        $oMsgBox->error($MESSAGE['MOD_FORM_INCORRECT_CAPTCHA']);
+        $sEmail = '';
+    }
+    
+    if ($sEmail != '') {
+    
+        if($admin->validate_email($sEmail) == false) {
+            $oMsgBox->error($MESSAGE['USERS_INVALID_EMAIL']);
+            $sEmail  = '';
+        } else {
+            // Check if the email exists in the database
+            $sSql = "SELECT * FROM `{TP}users` WHERE `email`='".$database->escapeString($sEmail)."'";
 
-        if(($rRow = $database->query($sSql))){
-            if($aUser = $rRow->fetchRow(MYSQLI_ASSOC)) {
-                if(strlen($aUser['signup_confirmcode']) > 25){
-                    header("Location: ".ACCOUNT_URL."/signup_continue_page.php?switch=wrong_inputs");
-                    exit(0); // break up the script here
-                }
-                $iUserID = (int) $aUser['user_id'];
-                // Get the id, username, email, and last_reset from the above db query
+            if(($rRow = $database->query($sSql))){
+                if($aUser = $rRow->fetchRow(MYSQLI_ASSOC)) {
+                    if(strlen($aUser['signup_confirmcode']) > 25){
+                        header("Location: ".ACCOUNT_URL."/signup_continue_page.php?switch=wrong_inputs");
+                        exit(0); // break up the script here
+                    }
+                    $iUserID = (int) $aUser['user_id'];
+                    // Get the id, username, email, and last_reset from the above db query
 
-                // Check if the password has been reset in the last 2 hours
-                if( ( time() - intval($aUser['last_reset']) ) < (2 * 3600) ) {
-                    // Tell the user that their password cannot be reset more than once per hour
-                    $oMsgBox->error($MESSAGE['FORGOT_PASS_ALREADY_RESET']);
-                } else {
-                    // current password
-                    $sCurrentPw = $aUser['password'];
+                    // Check if the password has been reset in the last 2 hours
+                    if( ( time() - intval($aUser['last_reset']) ) < (2 * 3600) ) {
+                        // Tell the user that their password cannot be reset more than once per hour
+                        $oMsgBox->error($MESSAGE['FORGOT_PASS_ALREADY_RESET']);
+                    } else {
+                        // current password
+                        $sCurrentPw = $aUser['password'];
 
-                    // generate new password
-                    $sNewPasswordRaw = $oAccounts->GenerateRandomPassword();
-                    $sNewPasswordEnc = $oAccounts->doPasswordEncode($sNewPasswordRaw);
+                        // generate new password
+                        $sNewPasswordRaw = $oAccounts->GenerateRandomPassword();
+                        $sNewPasswordEnc = $oAccounts->doPasswordEncode($sNewPasswordRaw);
 
-                    // prepare E-Mail with login details to send to the user via email
-                    $aTokenReplace = array(
-                        'LOGIN_DISPLAY_NAME'  => $aUser['display_name'],
-                        'LOGIN_NAME'          => $aUser['username'],
-                        'LOGIN_WEBSITE_TITLE' => WEBSITE_TITLE,
-                        'LOGIN_PASSWORD'      => $sNewPasswordRaw,
-                        'LOGIN_URL'           => ACCOUNT_URL . '/login.php'
-                    );
+                        // prepare E-Mail with login details to send to the user via email
+                        $aTokenReplace = array(
+                            'LOGIN_DISPLAY_NAME'  => $aUser['display_name'],
+                            'LOGIN_NAME'          => $aUser['username'],
+                            'LOGIN_WEBSITE_TITLE' => WEBSITE_TITLE,
+                            'LOGIN_PASSWORD'      => $sNewPasswordRaw,
+                            'LOGIN_URL'           => ACCOUNT_URL . '/login.php'
+                        );
 
-                    $sOnScreenSwitch    = 'forgot_login_details_sent';
-                    $sEmailTemplateName = 'password_recovery_mail';
-                    $sEmailSubject      = '';
-                    $sMailTo            = $sEmail;
+                        $sOnScreenSwitch    = 'forgot_login_details_sent';
+                        $sEmailTemplateName = 'password_recovery_mail';
+                        $sEmailSubject      = '';
+                        $sMailTo            = $sEmail;
 
-                    $checkSend = $oAccounts->sendEmail($sMailTo, $aTokenReplace, $sEmailTemplateName, $sEmailSubject);
-                    if ($checkSend === true) {
-                        // update the new password in the database
-                        $aUpdateUser = array(
-                            'user_id'    => $iUserID,
-                            'password'   => $sNewPasswordEnc,
-                            'last_reset' => time(),
-                        );
+                        $checkSend = $oAccounts->sendEmail($sMailTo, $aTokenReplace, $sEmailTemplateName, $sEmailSubject);
+                        if ($checkSend === true) {
+                            // update the new password in the database
+                            $aUpdateUser = array(
+                                'user_id'    => $iUserID,
+                                'password'   => $sNewPasswordEnc,
+                                'last_reset' => time(),
+                            );
 
-                        if($database->updateRow('{TP}users', 'user_id', $aUpdateUser)){
-                            header("Location: ".ACCOUNT_URL."/signup_continue_page.php?lc=".$sLC."&switch=".$sOnScreenSwitch."&email=".$sMailTo);
-                            exit(0);
-                        } else {
-                            // Error updating database
-                            $oMsgBox->error($MESSAGE['RECORD_MODIFIED_FAILED']);
-                            if(WB_DEBUG) {
-                                $oMsgBox->error($database->get_error().'<br />'.$sSql);
+                            if($database->updateRow('{TP}users', 'user_id', $aUpdateUser)){
+                                header("Location: ".ACCOUNT_URL."/signup_continue_page.php?lc=".$sLC."&switch=".$sOnScreenSwitch."&email=".$sMailTo);
+                                exit(0);
+                            } else {
+                                // Error updating database
+                                $oMsgBox->error($MESSAGE['RECORD_MODIFIED_FAILED']);
+                                if(WB_DEBUG) {
+                                    $oMsgBox->error($database->get_error().'<br />'.$sSql);
+                                }
                             }
-                        }
 
-                    } else {
-                        // tell user: WRONG INPUTS
-                        $aUpdateUser = array(
-                            'user_id'    => $aUser['user_id'],
-                            'password'   => $sCurrentPw
-                        );
-                        $database->updateRow('{TP}users', 'user_id', $aUpdateUser);
-                        header("Location: ".ACCOUNT_URL."/signup_continue_page.php?lc=".$sLC."&switch=wrong_inputs&from=resend_forgot_pass&mail_err=".$checkSend);
-                        exit(0);
+                        } else {
+                            // tell user: WRONG INPUTS
+                            $aUpdateUser = array(
+                                'user_id'    => $aUser['user_id'],
+                                'password'   => $sCurrentPw
+                            );
+                            $database->updateRow('{TP}users', 'user_id', $aUpdateUser);
+                            header("Location: ".ACCOUNT_URL."/signup_continue_page.php?lc=".$sLC."&switch=wrong_inputs&from=resend_forgot_pass&mail_err=".$checkSend);
+                            exit(0);
+                        }
                     }
+                } else { // no record found - Email doesn't exist, so tell the user
+                    $oMsgBox->error($MESSAGE['FORGOT_PASS_EMAIL_NOT_FOUND']);
+                }
+            } else {
+                // Query failed
+                if(WB_DEBUG) {
+                    $oMsgBox->error('SystemError:: Database query failed!');
+                    $oMsgBox->error($database->get_error().'<br />'.$sSql);
                 }
-            } else { // no record found - Email doesn't exist, so tell the user
-                $oMsgBox->error($MESSAGE['FORGOT_PASS_EMAIL_NOT_FOUND']);
-            }
-        } else {
-            // Query failed
-            if(WB_DEBUG) {
-                $oMsgBox->error('SystemError:: Database query failed!');
-                $oMsgBox->error($database->get_error().'<br />'.$sSql);
             }
         }
     }
@@ -110,10 +128,15 @@
 }
 $email = $sEmail;
 $sHttpReferer = isset($_SESSION['HTTP_REFERER']) ? $_SESSION['HTTP_REFERER'] : $_SERVER['SCRIPT_NAME'];
+ob_start();
+call_captcha("all","","accountforgot");
+$captcha = ob_get_contents();
+ob_end_clean();
 
 // Get the template file for forgot_login_details
 $aToTwig = array(
     'EMAIL'         => $email,
+    'CAPTCHA'       => $captcha,
     'MESSAGE_BOX'   => $oMsgBox->fetchDisplay(),
 );
 $oAccounts->useTwigTemplate('form_forgot.twig', $aToTwig);
diff --git a/wbce/modules/tool_account_settings/templates/form_forgot.twig b/wbce/modules/tool_account_settings/templates/form_forgot.twig
index e064ef98c..170c8c045 100644
--- a/wbce/modules/tool_account_settings/templates/form_forgot.twig
+++ b/wbce/modules/tool_account_settings/templates/form_forgot.twig
@@ -1,7 +1,7 @@
 {{ insertCssFile( CURRENT_DIR ~ '/forms.css') }}
+
+<p>{{ L_('MENU:FORGOT') }}</p>
 {{ MESSAGE_BOX }}
-<h2>{{ L_('MENU:FORGOT') }}</h2>
-<br />
 
 <form  class="login-box" name="forgot_pass" action="{{ constant("FORGOT_URL") }}" method="post">
     <div class="cpForm">
@@ -11,7 +11,9 @@
                 <input type="text" maxlength="255" name="email" id="email" value="{{ EMAIL }}" />
             </div>
         </div>
-
+		<div class="formRow">
+		{{CAPTCHA}}
+		</div>
         <div class="buttonsRow">
             <button type="submit" name="submit" class="button pos-right">{{ L_('TEXT:SEND_DETAILS') }}</button>
         </div>		
diff --git a/wbce/templates/argos_theme_reloaded/css/login.css b/wbce/templates/argos_theme_reloaded/css/login.css
index 7f6c082c5..1411fd964 100644
--- a/wbce/templates/argos_theme_reloaded/css/login.css
+++ b/wbce/templates/argos_theme_reloaded/css/login.css
@@ -121,6 +121,15 @@ a:hover {
     text-align: center;
 }
 
+.captcha_table {
+	display:inline-block;
+	margin:auto;
+}
+
+.error {
+	color:firebrick;
+}
+
 @media screen and (max-width: 36.5em) {
     .label {
         text-align: left;
diff --git a/wbce/templates/argos_theme_reloaded/info.php b/wbce/templates/argos_theme_reloaded/info.php
index eea08c731..659efa2b5 100644
--- a/wbce/templates/argos_theme_reloaded/info.php
+++ b/wbce/templates/argos_theme_reloaded/info.php
@@ -14,8 +14,8 @@
 $template_directory = 'argos_theme_reloaded';
 $template_name = 'Argos Theme Reloaded';
 $template_function = 'theme';
-$template_version = '2.1.3';
-$template_platform = '1.4.0';
+$template_version = '2.1.4';
+$template_platform = '1.5.0';
 $template_author = 'Bernd Michna (BerndJM / WWnW) based on the work by Jurgen Nijhuis (Argos Media) & Ruud Eisinga';
 $template_license = '<a href="http://www.wtfpl.net/">WTFPL</a>';
 $template_license_terms = '-';
diff --git a/wbce/templates/argos_theme_reloaded/templates/login_forgot.htt b/wbce/templates/argos_theme_reloaded/templates/login_forgot.htt
index b9563271f..165c6126d 100644
--- a/wbce/templates/argos_theme_reloaded/templates/login_forgot.htt
+++ b/wbce/templates/argos_theme_reloaded/templates/login_forgot.htt
@@ -11,7 +11,7 @@
 	<link href="{THEME_URL}/css/login.css" rel="stylesheet" type="text/css">
 </head>
 
-<body onload="document.forgot_pass.email.focus();">
+<body onload="document.login.email.focus();">
 
 	<div id="container">
 		<header class="fg-center">
@@ -27,7 +27,7 @@
 						<input type="hidden" name="url" value="{URL}">
 
 						<div class="fg12 center">
-							<p>{MESSAGE}:</p>
+							<div class="error">{MESSAGE}</div>
 						</div>
 
 						<hr class="fg12" style="margin-bottom: 15px;">
@@ -37,6 +37,10 @@
 							<input type="text" name="email" value="{EMAIL}">
 						</div>
 
+						<div class="fg12 center">
+							{CAPTCHA}
+						</div>
+
 						<div class="fg12 center">
 							<button type="submit" name="submit" style="width:200px;">{TEXT_SEND_DETAILS}</button>
 						</div>
diff --git a/wbce/templates/wbce_flat_theme/css/login.css b/wbce/templates/wbce_flat_theme/css/login.css
index 448ee59f1..b8746cd4c 100644
--- a/wbce/templates/wbce_flat_theme/css/login.css
+++ b/wbce/templates/wbce_flat_theme/css/login.css
@@ -87,13 +87,19 @@ a:hover {
 }
 
 .page_login_link {
-    font-size: 13px;
+    display: block;
+    margin: 50px 0;
 }
 
 .login_license {
     font-size: 11px;
 }
 
+.captcha_table {
+    display: inline-block;
+    margin: auto;
+}
+
 @media (max-width: 550px) {
     .page_login_logo {
         background: none;
diff --git a/wbce/templates/wbce_flat_theme/info.php b/wbce/templates/wbce_flat_theme/info.php
index c739ba369..f2e774e68 100644
--- a/wbce/templates/wbce_flat_theme/info.php
+++ b/wbce/templates/wbce_flat_theme/info.php
@@ -14,8 +14,8 @@
 $template_directory = 'wbce_flat_theme';
 $template_name = 'WBCE Flat Theme';
 $template_function = 'theme';
-$template_version = '1.7.5';
-$template_platform = '1.4';
+$template_version = '1.7.6';
+$template_platform = '1.5.0';
 $template_author = 'Colinax based on the work by Yetiie, BerndJM and rjgamer';
 $template_license = 'GNU General Public License';
 $template_license_terms = '-';
diff --git a/wbce/templates/wbce_flat_theme/templates/login_forgot.htt b/wbce/templates/wbce_flat_theme/templates/login_forgot.htt
index 0cbaaa6b8..db7c4dcc4 100644
--- a/wbce/templates/wbce_flat_theme/templates/login_forgot.htt
+++ b/wbce/templates/wbce_flat_theme/templates/login_forgot.htt
@@ -28,6 +28,7 @@
         <div class="page_login-fields">
             <span class="page_login_fieldelement"><input placeholder="E-Mail" type="text" maxlength="255" name="email" value="{EMAIL}" /></span>
             <br/>
+            {CAPTCHA}
             <p><input type="submit" name="submit" value="{TEXT_SEND_DETAILS}" /></p>
             <p><a class="page_login_link" href="{LOGIN_URL}">{TEXT_NEED_TO_LOGIN}</a></p>
         </div>",
"url": "https://github.com/wbce/wbce_cms/commit/6ca63f0cad5f0cd606fdb69a372f09b7d238f1d7.patch"
}
] |
CWE-89 Improper Neutralization of Special Elements used in an SQL Command
|
CVE-2022-2284
|
Heap-based Buffer Overflow in vim/vim
|
Heap-based Buffer Overflow in GitHub repository vim/vim prior to 9.0.
|
[
{
"commit_message": "[PATCH] patch 9.0.0017: accessing memory beyond the end of the line Problem: Accessing memory beyond the end of the line. Solution: Stop Visual mode when closing a window. src/testdir/test_visual.vim | 12 ++++++++++++ src/version.c | 2 ++ src/window.c | 2 ++ 3 files changed, 16 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/vim/vim/commit/3d51ce18ab1be4f9f6061568a4e7fabf00b21794.patch"
}
] |
CWE-122 Heap-based Buffer Overflow
|
GHSA-675q-66gf-gqg8
|
OneUptime is Vulnerable to Privilege Escalation via Login Response Manipulation
| null |
[
{
"commit_message": "[PATCH] fix(admin): restrict AdminDashboard to master admins and guard index render Add ensureMasterAdminAccess in AdminDashboard/Serve.ts to decode JWT, validate isMasterAdmin and return a NotAuthorized response when access is not allowed. Wire this function into App.init as getVariablesToRenderIndexPage so the admin frontend is protected. Also add a res.headersSent guard in StartServer.ts to skip rendering the index page if a response was already sent, avoiding duplicate responses. AdminDashboard/Serve.ts | 52 +++++++++++++++++++++++++++++- Common/Server/Utils/StartServer.ts | 7 ++++ 2 files changed, 58 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/OneUptime/oneuptime/commit/3e72b2a9a4f50f98cf1f6cf13fa3e405715bb370.patch"
}
] | null |
GHSA-h7v2-cvh5-xv63
| null |
[
{
"commit_message": "[PATCH] CVE-2017-12990/Fix printing of ISAKMPv1 Notification payload data. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The closest thing to a specification for the contents of the payload data is draft-ietf-ipsec-notifymsg-04, and nothing in there says that it is ever a complete ISAKMP message, so don't dissect types we don't have specific code for as a complete ISAKMP message. While we're at it, fix a comment, and clean up printing of V1 Nonce, V2 Authentication payloads, and v2 Notice payloads. This fixes an infinite loop discovered by Forcepoint's security researchers Otto Airamo & Antti Levomäki. Add a test using the capture file supplied by the reporter(s). print-isakmp.c | 112 +++++++++++++++++++---------------- tests/TESTLIST | 1 + tests/isakmp-no-none-np.out | 78 ++++++++++++++++++++++++ tests/isakmp-no-none-np.pcap | Bin 0 -> 2344 bytes 4 files changed, 139 insertions(+), 52 deletions(-) create mode 100644 tests/isakmp-no-none-np.out create mode 100644 tests/isakmp-no-none-np.pcap",
"patch_text_b64": "From c2ef693866beae071a24b45c49f9674af1df4028 Mon Sep 17 00:00:00 2001
From: Guy Harris <guy@alum.mit.edu>
Date: Mon, 6 Feb 2017 14:33:50 -0800
Subject: [PATCH] CVE-2017-12990/Fix printing of ISAKMPv1 Notification payload
 data.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The closest thing to a specification for the contents of the payload
data is draft-ietf-ipsec-notifymsg-04, and nothing in there says that it
is ever a complete ISAKMP message, so don't dissect types we don't have
specific code for as a complete ISAKMP message.

While we're at it, fix a comment, and clean up printing of V1 Nonce,
V2 Authentication payloads, and v2 Notice payloads.

This fixes an infinite loop discovered by Forcepoint's security
researchers Otto Airamo & Antti Levomäki.

Add a test using the capture file supplied by the reporter(s).
---
 print-isakmp.c               | 112 +++++++++++++++++++----------------
 tests/TESTLIST               |   1 +
 tests/isakmp-no-none-np.out  |  78 ++++++++++++++++++++++++
 tests/isakmp-no-none-np.pcap | Bin 0 -> 2344 bytes
 4 files changed, 139 insertions(+), 52 deletions(-)
 create mode 100644 tests/isakmp-no-none-np.out
 create mode 100644 tests/isakmp-no-none-np.pcap

diff --git a/print-isakmp.c b/print-isakmp.c
index 2fa15b861..9de9b75d2 100644
--- a/print-isakmp.c
+++ b/print-isakmp.c
@@ -428,7 +428,7 @@ struct notify_messages {
 	char     *msg;
 };
 
-/* 3.8 Notification Payload */
+/* 3.8 Authentication Payload */
 struct ikev2_auth {
 	struct isakmp_gen h;
 	uint8_t  auth_method;  /* Protocol-ID */
@@ -1590,15 +1590,20 @@ ikev1_nonce_print(netdissect_options *ndo, u_char tpay _U_,
 
 	ND_TCHECK(*ext);
 	UNALIGNED_MEMCPY(&e, ext, sizeof(e));
-	ND_PRINT((ndo," n len=%d", ntohs(e.len) - 4));
-	if (2 < ndo->ndo_vflag && 4 < ntohs(e.len)) {
-		ND_PRINT((ndo," "));
-		if (!rawprint(ndo, (const uint8_t *)(ext + 1), ntohs(e.len) - 4))
-			goto trunc;
-	} else if (1 < ndo->ndo_vflag && 4 < ntohs(e.len)) {
-		ND_PRINT((ndo," "));
-		if (!ike_show_somedata(ndo, (const u_char *)(const uint8_t *)(ext + 1), ep))
-			goto trunc;
+	/*
+	 * Our caller has ensured that the length is >= 4.
+	 */
+	ND_PRINT((ndo," n len=%u", ntohs(e.len) - 4));
+	if (ntohs(e.len) > 4) {
+		if (ndo->ndo_vflag > 2) {
+			ND_PRINT((ndo, " "));
+			if (!rawprint(ndo, (const uint8_t *)(ext + 1), ntohs(e.len) - 4))
+				goto trunc;
+		} else if (ndo->ndo_vflag > 1) {
+			ND_PRINT((ndo, " "));
+			if (!ike_show_somedata(ndo, (const u_char *)(ext + 1), ep))
+				goto trunc;
+		}
 	}
 	return (const u_char *)ext + ntohs(e.len);
 trunc:
@@ -1609,8 +1614,8 @@ ikev1_nonce_print(netdissect_options *ndo, u_char tpay _U_,
 static const u_char *
 ikev1_n_print(netdissect_options *ndo, u_char tpay _U_,
 	      const struct isakmp_gen *ext, u_int item_len,
-	      const u_char *ep, uint32_t phase, uint32_t doi0 _U_,
-	      uint32_t proto0 _U_, int depth)
+	      const u_char *ep, uint32_t phase _U_, uint32_t doi0 _U_,
+	      uint32_t proto0 _U_, int depth _U_)
 {
 	const struct ikev1_pl_n *p;
 	struct ikev1_pl_n n;
@@ -1712,35 +1717,41 @@ ikev1_n_print(netdissect_options *ndo, u_char tpay _U_,
 	ep2 = (const u_char *)p + item_len;
 
 	if (cp < ep) {
-		ND_PRINT((ndo," orig=("));
 		switch (ntohs(n.type)) {
 		case IPSECDOI_NTYPE_RESPONDER_LIFETIME:
 		    {
 			const struct attrmap *map = oakley_t_map;
 			size_t nmap = sizeof(oakley_t_map)/sizeof(oakley_t_map[0]);
+			ND_PRINT((ndo," attrs=("));
 			while (cp < ep && cp < ep2) {
 				cp = ikev1_attrmap_print(ndo, cp,
 					(ep < ep2) ? ep : ep2, map, nmap);
 			}
+			ND_PRINT((ndo,")"));
 			break;
 		    }
 		case IPSECDOI_NTYPE_REPLAY_STATUS:
+			ND_PRINT((ndo," status=("));
 			ND_PRINT((ndo,"replay detection %sabled",
 				  EXTRACT_32BITS(cp) ? "en" : "dis"));
-			break;
-		case ISAKMP_NTYPE_NO_PROPOSAL_CHOSEN:
-			if (ikev1_sub_print(ndo, ISAKMP_NPTYPE_SA,
-					    (const struct isakmp_gen *)cp, ep, phase, doi, proto,
-					    depth) == NULL)
-				return NULL;
+			ND_PRINT((ndo,")"));
 			break;
 		default:
-			/* NULL is dummy */
-			isakmp_print(ndo, cp,
-				     item_len - sizeof(*p) - n.spi_size,
-				     NULL);
+			/*
+			 * XXX - fill in more types here; see, for example,
+			 * draft-ietf-ipsec-notifymsg-04.
+			 */
+			if (ndo->ndo_vflag > 3) {
+				ND_PRINT((ndo," data=("));
+				if (!rawprint(ndo, (const uint8_t *)(cp), ep - cp))
+					goto trunc;
+				ND_PRINT((ndo,")"));
+			} else {
+				if (!ike_show_somedata(ndo, cp, ep))
+					goto trunc;
+			}
+			break;
 		}
-		ND_PRINT((ndo,")"));
 	}
 	return (const u_char *)ext + item_len;
 trunc:
@@ -2264,16 +2275,21 @@ ikev2_auth_print(netdissect_options *ndo, u_char tpay,
 	ikev2_pay_print(ndo, NPSTR(tpay), a.h.critical);
 	len = ntohs(a.h.len);
 
-	ND_PRINT((ndo," len=%d method=%s", len-4,
+	/*
+	 * Our caller has ensured that the length is >= 4.
+	 */
+	ND_PRINT((ndo," len=%u method=%s", len-4,
 		  STR_OR_ID(a.auth_method, v2_auth)));
-
-	if (1 < ndo->ndo_vflag && 4 < len) {
-		ND_PRINT((ndo," authdata=("));
-		if (!rawprint(ndo, (const uint8_t *)authdata, len - sizeof(a)))
-			goto trunc;
-		ND_PRINT((ndo,") "));
-	} else if(ndo->ndo_vflag && 4 < len) {
-		if(!ike_show_somedata(ndo, authdata, ep)) goto trunc;
+	if (len > 4) {
+		if (ndo->ndo_vflag > 1) {
+			ND_PRINT((ndo, " authdata=("));
+			if (!rawprint(ndo, (const uint8_t *)authdata, len - sizeof(a)))
+				goto trunc;
+			ND_PRINT((ndo, ") "));
+		} else if (ndo->ndo_vflag) {
+			if (!ike_show_somedata(ndo, authdata, ep))
+				goto trunc;
+		}
 	}
 
 	return (const u_char *)ext + len;
@@ -2322,7 +2338,7 @@ ikev2_n_print(netdissect_options *ndo, u_char tpay _U_,
 	const struct ikev2_n *p;
 	struct ikev2_n n;
 	const u_char *cp;
-	u_char showspi, showdata, showsomedata;
+	u_char showspi, showsomedata;
 	const char *notify_name;
 	uint32_t type;
 
@@ -2332,7 +2348,6 @@ ikev2_n_print(netdissect_options *ndo, u_char tpay _U_,
 	ikev2_pay_print(ndo, NPSTR(ISAKMP_NPTYPE_N), n.h.critical);
 
 	showspi = 1;
-	showdata = 0;
 	showsomedata=0;
 	notify_name=NULL;
 
@@ -2446,7 +2461,6 @@ ikev2_n_print(netdissect_options *ndo, u_char tpay _U_,
 		notify_name = "cookie";
 		showspi = 1;
 		showsomedata= 1;
-		showdata= 0;
 		break;
 
 	case IV2_NOTIFY_USE_TRANSPORT_MODE:
@@ -2499,19 +2513,17 @@ ikev2_n_print(netdissect_options *ndo, u_char tpay _U_,
 
 	cp = (const u_char *)(p + 1) + n.spi_size;
 
-	if(3 < ndo->ndo_vflag) {
-		showdata = 1;
-	}
-
-	if ((showdata || (showsomedata && ep-cp < 30)) && cp < ep) {
-		ND_PRINT((ndo," data=("));
-		if (!rawprint(ndo, (const uint8_t *)(cp), ep - cp))
-			goto trunc;
-
-		ND_PRINT((ndo,")"));
+	if (cp < ep) {
+		if (ndo->ndo_vflag > 3 || (showsomedata && ep-cp < 30)) {
+			ND_PRINT((ndo," data=("));
+			if (!rawprint(ndo, (const uint8_t *)(cp), ep - cp))
+				goto trunc;
 
-	} else if(showsomedata && cp < ep) {
-		if(!ike_show_somedata(ndo, cp, ep)) goto trunc;
+			ND_PRINT((ndo,")"));
+		} else if (showsomedata) {
+			if (!ike_show_somedata(ndo, cp, ep))
+				goto trunc;
+		}
 	}
 
 	return (const u_char *)ext + item_len;
@@ -3091,7 +3103,3 @@ isakmp_rfc3948_print(netdissect_options *ndo,
  * c-basic-offset: 8
  * End:
  */
-
-
-
-
diff --git a/tests/TESTLIST b/tests/TESTLIST
index 1e1624013..ed5b82aa3 100644
--- a/tests/TESTLIST
+++ b/tests/TESTLIST
@@ -465,6 +465,7 @@ tok2str-oobr-2		tok2str-oobr-2.pcap		tok2str-oobr-2.out	-vvv -e
 eigrp-tlv-oobr		eigrp-tlv-oobr.pcap		eigrp-tlv-oobr.out	-vvv -e
 zephyr-oobr		zephyr-oobr.pcap		zephyr-oobr.out		-vvv -e
 bgp-as-path-oobr	bgp-as-path-oobr.pcap		bgp-as-path-oobr.out	-vvv -e
+isakmp-no-none-np	isakmp-no-none-np.pcap		isakmp-no-none-np.out	-vvv -e
 
 # RTP tests
 # fuzzed pcap
diff --git a/tests/isakmp-no-none-np.out b/tests/isakmp-no-none-np.out
new file mode 100644
index 000000000..eb91c804a
--- /dev/null
+++ b/tests/isakmp-no-none-np.out
@@ -0,0 +1,78 @@
+00:0c:29:86:c8:36 > 00:1a:4b:6a:ce:fe, ethertype IPv4 (0x0800), length 2228: (tos 0x0, ttl 128, id 28793, offset 0, flags [none], proto UDP (17), length 2214)
+    192.168.1.25.500 > 192.168.1.10.500: [udp sum ok] isakmp 1.0 msgid 5f724dc6 cookie 0000000000000000->0000000000000000: phase 2/others ? inf:
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=000000000b1005005f724dc600000054 data=(0b00001c000000010110...0100000700000000000000000000000000000000))
+    (n: doi=ipsec proto=isakmp type=INVALID-MAJOR-VERSION spi=0000000000000000000000000010ba00 data=(00ff1d00020082001101...0100000700000000000000000000000000000000)) [|n] (len mismatch: isakmp 84/ip 2186)
diff --git a/tests/isakmp-no-none-np.pcap b/tests/isakmp-no-none-np.pcap
new file mode 100644
index 0000000000000000000000000000000000000000..fd388d617e4f2937fdb1214bdcce59c8c159a90c
GIT binary patch
literal 2344
zcmd<$<>fMAU|{gI(UxKa(*L1=g@KpBH6^noIk7;&NY6me2q*^vAhjTM3Q+q0e+C9l
zpa>g~4+0863}Rp501`-G3y=@O3{u`%=l(J9Xttd&<6v-Q;8<2r$-vMcXcu*01*0So
zb1{Bl{K7Gb{}YmCFq2z=l_9>!_ZW~9!p*=S1Ed)l1sGUClB05?;WC;gM)SjHSuk2g
r0@J`~{V-ZL5^NWM$_g+L*ad9%$TBc7G%*M=0^2t1FbNn9YRdosru*ln

literal 0
HcmV?d00001",
"url": "https://github.com/the-tcpdump-group/tcpdump/commit/c2ef693866beae071a24b45c49f9674af1df4028.patch"
}
] | null |
|
GHSA-4365-fhm5-qcrx
|
Maliciously Crafted Model Archive Can Lead To Arbitrary File Write
| null |
[
{
"commit_message": "[PATCH] Swap calls to extractall for TarSafe equivalent poetry.lock | 445 +++++++++++++++++++++++++----------------- pyproject.toml | 1 + rasa/model.py | 3 +- rasa/nlu/persistor.py | 4 +- rasa/utils/io.py | 3 +- 5 files changed, 275 insertions(+), 181 deletions(-)",
"patch_text_b64": "From 1b6b502f52d73b4f8cd1959ce724b8ad0eb33989 Mon Sep 17 00:00:00 2001
From: Matthew Summers <m.summers@rasa.com>
Date: Mon, 11 Oct 2021 14:57:21 +0100
Subject: [PATCH] Swap calls to extractall for TarSafe equivalent

---
 poetry.lock           | 445 +++++++++++++++++++++++++-----------------
 pyproject.toml        |   1 +
 rasa/model.py         |   3 +-
 rasa/nlu/persistor.py |   4 +-
 rasa/utils/io.py      |   3 +-
 5 files changed, 275 insertions(+), 181 deletions(-)

diff --git a/poetry.lock b/poetry.lock
index a7197f5f28b7..78b0adedf136 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -242,14 +242,14 @@ numpy = ">=1.15.0"
 
 [[package]]
 name = "boto3"
-version = "1.18.52"
+version = "1.18.58"
 description = "The AWS SDK for Python"
 category = "main"
 optional = false
 python-versions = ">= 3.6"
 
 [package.dependencies]
-botocore = ">=1.21.52,<1.22.0"
+botocore = ">=1.21.58,<1.22.0"
 jmespath = ">=0.7.1,<1.0.0"
 s3transfer = ">=0.5.0,<0.6.0"
 
@@ -258,7 +258,7 @@ crt = ["botocore[crt] (>=1.21.0,<2.0a0)"]
 
 [[package]]
 name = "botocore"
-version = "1.21.52"
+version = "1.21.58"
 description = "Low-level, data-driven core of boto 3."
 category = "main"
 optional = false
@@ -302,7 +302,7 @@ zipp = {version = ">=0.5", markers = "python_version < \"3.8\""}
 
 [[package]]
 name = "certifi"
-version = "2021.5.30"
+version = "2021.10.8"
 description = "Python package for providing Mozilla's CA Bundle."
 category = "main"
 optional = false
@@ -440,7 +440,7 @@ yaml = ["PyYAML (>=3.10)"]
 
 [[package]]
 name = "cryptography"
-version = "3.4.8"
+version = "35.0.0"
 description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers."
 category = "main"
 optional = false
@@ -453,9 +453,9 @@ cffi = ">=1.12"
 docs = ["sphinx (>=1.6.5,!=1.8.0,!=3.1.0,!=3.1.1)", "sphinx-rtd-theme"]
 docstest = ["doc8", "pyenchant (>=1.6.11)", "twine (>=1.12.0)", "sphinxcontrib-spelling (>=4.0.1)"]
 pep8test = ["black", "flake8", "flake8-import-order", "pep8-naming"]
-sdist = ["setuptools-rust (>=0.11.4)"]
+sdist = ["setuptools_rust (>=0.11.4)"]
 ssh = ["bcrypt (>=3.1.5)"]
-test = ["pytest (>=6.0)", "pytest-cov", "pytest-subtests", "pytest-xdist", "pretend", "iso8601", "pytz", "hypothesis (>=1.11.4,!=3.79.2)"]
+test = ["pytest (>=6.2.0)", "pytest-cov", "pytest-subtests", "pytest-xdist", "pretend", "iso8601", "pytz", "hypothesis (>=1.11.4,!=3.79.2)"]
 
 [[package]]
 name = "cycler"
@@ -603,15 +603,15 @@ requests = ">=2.0"
 
 [[package]]
 name = "filelock"
-version = "3.2.0"
+version = "3.3.0"
 description = "A platform independent file lock."
 category = "main"
 optional = true
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7"
+python-versions = ">=3.6"
 
 [package.extras]
 docs = ["furo (>=2021.8.17b43)", "sphinx (>=4.1)", "sphinx-autodoc-typehints (>=1.12)"]
-testing = ["coverage (>=4)", "pytest (>=4)", "pytest-cov", "pytest-timeout (>=1.4.2)"]
+testing = ["covdefaults (>=1.2.0)", "coverage (>=4)", "pytest (>=4)", "pytest-cov", "pytest-timeout (>=1.4.2)"]
 
 [[package]]
 name = "flake8"
@@ -717,7 +717,7 @@ typing-extensions = {version = ">=3.7.4.3", markers = "python_version < \"3.10\"
 
 [[package]]
 name = "google-api-core"
-version = "2.0.1"
+version = "2.1.0"
 description = "Google API client core library"
 category = "dev"
 optional = false
@@ -770,7 +770,7 @@ tool = ["click (>=6.0.0)"]
 
 [[package]]
 name = "google-cloud-core"
-version = "2.0.0"
+version = "2.1.0"
 description = "Google Cloud API client core library"
 category = "dev"
 optional = false
@@ -802,7 +802,7 @@ six = "*"
 
 [[package]]
 name = "google-crc32c"
-version = "1.2.0"
+version = "1.3.0"
 description = "A python wrapper of the C library 'Google CRC32C'"
 category = "dev"
 optional = false
@@ -930,11 +930,11 @@ python-versions = ">=3.6"
 
 [[package]]
 name = "httplib2"
-version = "0.19.1"
+version = "0.20.1"
 description = "A comprehensive HTTP client library."
 category = "main"
 optional = false
-python-versions = "*"
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
 
 [package.dependencies]
 pyparsing = ">=2.4.2,<3"
@@ -1087,7 +1087,7 @@ python-versions = "*"
 
 [[package]]
 name = "jinja2"
-version = "3.0.1"
+version = "3.0.2"
 description = "A very fast and expressive template engine."
 category = "main"
 optional = false
@@ -1706,11 +1706,11 @@ wcwidth = "*"
 
 [[package]]
 name = "protobuf"
-version = "3.18.0"
+version = "3.18.1"
 description = "Protocol Buffers"
 category = "main"
 optional = false
-python-versions = "*"
+python-versions = ">=3.5"
 
 [[package]]
 name = "psutil"
@@ -1849,18 +1849,18 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
 
 [[package]]
 name = "pyjwt"
-version = "2.1.0"
+version = "2.2.0"
 description = "JSON Web Token implementation in Python"
 category = "main"
 optional = false
 python-versions = ">=3.6"
 
 [package.dependencies]
-cryptography = {version = ">=3.3.1,<4.0.0", optional = true, markers = "extra == \"crypto\""}
+cryptography = {version = ">=3.3.1", optional = true, markers = "extra == \"crypto\""}
 
 [package.extras]
-crypto = ["cryptography (>=3.3.1,<4.0.0)"]
-dev = ["sphinx", "sphinx-rtd-theme", "zope.interface", "cryptography (>=3.3.1,<4.0.0)", "pytest (>=6.0.0,<7.0.0)", "coverage[toml] (==5.0.4)", "mypy", "pre-commit"]
+crypto = ["cryptography (>=3.3.1)"]
+dev = ["sphinx", "sphinx-rtd-theme", "zope.interface", "cryptography (>=3.3.1)", "pytest (>=6.0.0,<7.0.0)", "coverage[toml] (==5.0.4)", "mypy", "pre-commit"]
 docs = ["sphinx", "sphinx-rtd-theme", "zope.interface"]
 tests = ["pytest (>=6.0.0,<7.0.0)", "coverage[toml] (==5.0.4)"]
 
@@ -2100,7 +2100,7 @@ client = ["requests (>=2.21.0)", "websocket-client (>=0.54.0)"]
 
 [[package]]
 name = "pytz"
-version = "2021.1"
+version = "2021.3"
 description = "World timezone definitions, modern and historical"
 category = "main"
 optional = false
@@ -2656,6 +2656,14 @@ python-versions = "*"
 [package.extras]
 widechars = ["wcwidth"]
 
+[[package]]
+name = "tarsafe"
+version = "0.0.3"
+description = "A safe subclass of the TarFile class for interacting with tar files. Can be used as a direct drop-in replacement for safe usage of extractall()"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
 [[package]]
 name = "tensorboard"
 version = "2.6.0"
@@ -2854,7 +2862,7 @@ torch = ["torch (>=1.5.0)"]
 
 [[package]]
 name = "threadpoolctl"
-version = "2.2.0"
+version = "3.0.0"
 description = "threadpoolctl"
 category = "main"
 optional = false
@@ -2970,7 +2978,7 @@ python-versions = "*"
 
 [[package]]
 name = "typeguard"
-version = "2.12.1"
+version = "2.13.0"
 description = "Run-time type checker for Python"
 category = "main"
 optional = false
@@ -3066,11 +3074,11 @@ python-versions = ">=3.6"
 
 [[package]]
 name = "uritemplate"
-version = "3.0.1"
-description = "URI templates"
+version = "4.0.0"
+description = "Implementation of RFC 6570 URI Templates"
 category = "main"
 optional = true
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+python-versions = ">=3.6"
 
 [[package]]
 name = "urllib3"
@@ -3144,7 +3152,7 @@ python-versions = ">=3.6"
 
 [[package]]
 name = "werkzeug"
-version = "2.0.1"
+version = "2.0.2"
 description = "The comprehensive WSGI web application library."
 category = "main"
 optional = false
@@ -3174,7 +3182,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
 
 [[package]]
 name = "yarl"
-version = "1.6.3"
+version = "1.7.0"
 description = "Yet another URL library"
 category = "main"
 optional = false
@@ -3207,7 +3215,7 @@ transformers = ["transformers"]
 [metadata]
 lock-version = "1.1"
 python-versions = ">=3.6,<3.9"
-content-hash = "209f285fcf47fff7c9fbcec651ed96156f03eb286f49b23c8047579fdd5adf8a"
+content-hash = "2fc451ce1e7553b33a12596867363114792c8ab2cde3148b60f57126e6cc635c"
 
 [metadata.files]
 absl-py = [
@@ -3333,12 +3341,12 @@ blis = [
     {file = "blis-0.7.4.tar.gz", hash = "sha256:7daa615a97d4f28db0f332b710bfe1900b15d0c25841c6d727965e4fd91e09cf"},
 ]
 boto3 = [
-    {file = "boto3-1.18.52-py3-none-any.whl", hash = "sha256:27824d3767c5213f0006f71e552b912bc4659241b77ca8b0be0b813cf0518a9e"},
-    {file = "boto3-1.18.52.tar.gz", hash = "sha256:5b585a279478bd6df4b07db7d6150f413ba6add1f38e68aaa533d3337efd0b22"},
+    {file = "boto3-1.18.58-py3-none-any.whl", hash = "sha256:7309552da6ef9e610f8a9712c8abe29a8d3d45b514188cc3efad47bd1774bf77"},
+    {file = "boto3-1.18.58.tar.gz", hash = "sha256:f680dee9c670d42ab4a6da5539ca3691d1ccbbcbf041e7021025029776864156"},
 ]
 botocore = [
-    {file = "botocore-1.21.52-py3-none-any.whl", hash = "sha256:e8797c0933c660e130cf2f51667f5003950d7e592f4c3944e8f04f201493d17a"},
-    {file = "botocore-1.21.52.tar.gz", hash = "sha256:04c071aec4f1981b38e3be760838b976337fd6ebd95a31ceeca9f9e4b4733c1f"},
+    {file = "botocore-1.21.58-py3-none-any.whl", hash = "sha256:9d84a97015c0565a81c0b6d55e60af5ab1a2da28039ad93976388014a14186da"},
+    {file = "botocore-1.21.58.tar.gz", hash = "sha256:87e881569c32b218a1b82ecb607a4dddb4dca3b80a5d1016571b99b51cef3158"},
 ]
 cached-property = [
     {file = "cached-property-1.5.2.tar.gz", hash = "sha256:9fa5755838eecbb2d234c3aa390bd80fbd3ac6b6869109bfc1b499f7bd89a130"},
@@ -3353,8 +3361,8 @@ catalogue = [
     {file = "catalogue-2.0.6.tar.gz", hash = "sha256:336a35603f447167042ef504114d6befa46688f03f4c14dabdc633a44587b245"},
 ]
 certifi = [
-    {file = "certifi-2021.5.30-py2.py3-none-any.whl", hash = "sha256:50b1e4f8446b06f41be7dd6338db18e0990601dce795c2b1686458aa7e8fa7d8"},
-    {file = "certifi-2021.5.30.tar.gz", hash = "sha256:2bbf76fd432960138b3ef6dda3dde0544f27cbf8546c458e60baf371917ba9ee"},
+    {file = "certifi-2021.10.8-py2.py3-none-any.whl", hash = "sha256:d62a0163eb4c2344ac042ab2bdf75399a71a2d8c7d47eac2e2ee91b9d6339569"},
+    {file = "certifi-2021.10.8.tar.gz", hash = "sha256:78884e7c1d4b00ce3cea67b44566851c4343c120abd683433ce934a68ea58872"},
 ]
 cffi = [
     {file = "cffi-1.14.6-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:22b9c3c320171c108e903d61a3723b51e37aaa8c81255b5e7ce102775bd01e2c"},
@@ -3499,23 +3507,26 @@ coveralls = [
     {file = "coveralls-3.2.0.tar.gz", hash = "sha256:15a987d9df877fff44cd81948c5806ffb6eafb757b3443f737888358e96156ee"},
 ]
 cryptography = [
-    {file = "cryptography-3.4.8-cp36-abi3-macosx_10_10_x86_64.whl", hash = "sha256:a00cf305f07b26c351d8d4e1af84ad7501eca8a342dedf24a7acb0e7b7406e14"},
-    {file = "cryptography-3.4.8-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:f44d141b8c4ea5eb4dbc9b3ad992d45580c1d22bf5e24363f2fbf50c2d7ae8a7"},
-    {file = "cryptography-3.4.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:0a7dcbcd3f1913f664aca35d47c1331fce738d44ec34b7be8b9d332151b0b01e"},
-    {file = "cryptography-3.4.8-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:34dae04a0dce5730d8eb7894eab617d8a70d0c97da76b905de9efb7128ad7085"},
-    {file = "cryptography-3.4.8-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1eb7bb0df6f6f583dd8e054689def236255161ebbcf62b226454ab9ec663746b"},
-    {file = "cryptography-3.4.8-cp36-abi3-manylinux_2_24_x86_64.whl", hash = "sha256:9965c46c674ba8cc572bc09a03f4c649292ee73e1b683adb1ce81e82e9a6a0fb"},
-    {file = "cryptography-3.4.8-cp36-abi3-win32.whl", hash = "sha256:21ca464b3a4b8d8e86ba0ee5045e103a1fcfac3b39319727bc0fc58c09c6aff7"},
-    {file = "cryptography-3.4.8-cp36-abi3-win_amd64.whl", hash = "sha256:3520667fda779eb788ea00080124875be18f2d8f0848ec00733c0ec3bb8219fc"},
-    {file = "cryptography-3.4.8-pp36-pypy36_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d2a6e5ef66503da51d2110edf6c403dc6b494cc0082f85db12f54e9c5d4c3ec5"},
-    {file = "cryptography-3.4.8-pp36-pypy36_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a305600e7a6b7b855cd798e00278161b681ad6e9b7eca94c721d5f588ab212af"},
-    {file = "cryptography-3.4.8-pp36-pypy36_pp73-manylinux_2_24_x86_64.whl", hash = "sha256:3fa3a7ccf96e826affdf1a0a9432be74dc73423125c8f96a909e3835a5ef194a"},
-    {file = "cryptography-3.4.8-pp37-pypy37_pp73-macosx_10_10_x86_64.whl", hash = "sha256:d9ec0e67a14f9d1d48dd87a2531009a9b251c02ea42851c060b25c782516ff06"},
-    {file = "cryptography-3.4.8-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5b0fbfae7ff7febdb74b574055c7466da334a5371f253732d7e2e7525d570498"},
-    {file = "cryptography-3.4.8-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:94fff993ee9bc1b2440d3b7243d488c6a3d9724cc2b09cdb297f6a886d040ef7"},
-    {file = "cryptography-3.4.8-pp37-pypy37_pp73-manylinux_2_24_x86_64.whl", hash = "sha256:8695456444f277af73a4877db9fc979849cd3ee74c198d04fc0776ebc3db52b9"},
-    {file = "cryptography-3.4.8-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:cd65b60cfe004790c795cc35f272e41a3df4631e2fb6b35aa7ac6ef2859d554e"},
-    {file = "cryptography-3.4.8.tar.gz", hash = "sha256:94cc5ed4ceaefcbe5bf38c8fba6a21fc1d365bb8fb826ea1688e3370b2e24a1c"},
+    {file = "cryptography-35.0.0-cp36-abi3-macosx_10_10_x86_64.whl", hash = "sha256:d57e0cdc1b44b6cdf8af1d01807db06886f10177469312fbde8f44ccbb284bc9"},
+    {file = "cryptography-35.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:ced40344e811d6abba00295ced98c01aecf0c2de39481792d87af4fa58b7b4d6"},
+    {file = "cryptography-35.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:54b2605e5475944e2213258e0ab8696f4f357a31371e538ef21e8d61c843c28d"},
+    {file = "cryptography-35.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:7b7ceeff114c31f285528ba8b390d3e9cfa2da17b56f11d366769a807f17cbaa"},
+    {file = "cryptography-35.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2d69645f535f4b2c722cfb07a8eab916265545b3475fdb34e0be2f4ee8b0b15e"},
+    {file = "cryptography-35.0.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a2d0e0acc20ede0f06ef7aa58546eee96d2592c00f450c9acb89c5879b61992"},
+    {file = "cryptography-35.0.0-cp36-abi3-manylinux_2_24_x86_64.whl", hash = "sha256:07bb7fbfb5de0980590ddfc7f13081520def06dc9ed214000ad4372fb4e3c7f6"},
+    {file = "cryptography-35.0.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:7eba2cebca600a7806b893cb1d541a6e910afa87e97acf2021a22b32da1df52d"},
+    {file = "cryptography-35.0.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:18d90f4711bf63e2fb21e8c8e51ed8189438e6b35a6d996201ebd98a26abbbe6"},
+    {file = "cryptography-35.0.0-cp36-abi3-win32.whl", hash = "sha256:c10c797ac89c746e488d2ee92bd4abd593615694ee17b2500578b63cad6b93a8"},
+    {file = "cryptography-35.0.0-cp36-abi3-win_amd64.whl", hash = "sha256:7075b304cd567694dc692ffc9747f3e9cb393cc4aa4fb7b9f3abd6f5c4e43588"},
+    {file = "cryptography-35.0.0-pp36-pypy36_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a688ebcd08250eab5bb5bca318cc05a8c66de5e4171a65ca51db6bd753ff8953"},
+    {file = "cryptography-35.0.0-pp36-pypy36_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d99915d6ab265c22873f1b4d6ea5ef462ef797b4140be4c9d8b179915e0985c6"},
+    {file = "cryptography-35.0.0-pp36-pypy36_pp73-manylinux_2_24_x86_64.whl", hash = "sha256:928185a6d1ccdb816e883f56ebe92e975a262d31cc536429041921f8cb5a62fd"},
+    {file = "cryptography-35.0.0-pp37-pypy37_pp73-macosx_10_10_x86_64.whl", hash = "sha256:ebeddd119f526bcf323a89f853afb12e225902a24d29b55fe18dd6fcb2838a76"},
+    {file = "cryptography-35.0.0-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:22a38e96118a4ce3b97509443feace1d1011d0571fae81fc3ad35f25ba3ea999"},
+    {file = "cryptography-35.0.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb80e8a1f91e4b7ef8b33041591e6d89b2b8e122d787e87eeb2b08da71bb16ad"},
+    {file = "cryptography-35.0.0-pp37-pypy37_pp73-manylinux_2_24_x86_64.whl", hash = "sha256:abb5a361d2585bb95012a19ed9b2c8f412c5d723a9836418fab7aaa0243e67d2"},
+    {file = "cryptography-35.0.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:1ed82abf16df40a60942a8c211251ae72858b25b7421ce2497c2eb7a1cee817c"},
+    {file = "cryptography-35.0.0.tar.gz", hash = "sha256:9933f28f70d0517686bd7de36166dda42094eac49415459d9bdf5e7df3e0086d"},
 ]
 cycler = [
     {file = "cycler-0.10.0-py2.py3-none-any.whl", hash = "sha256:1d8a5ae1ff6c5cf9b93e8811e581232ad8920aeec647c37316ceac982b08cb2d"},
@@ -3595,8 +3606,8 @@ fbmessenger = [
     {file = "fbmessenger-6.0.0.tar.gz", hash = "sha256:6e42c4588a4c942547be228886278bbc7a084e0b34799c7e6ebd786129f021e6"},
 ]
 filelock = [
-    {file = "filelock-3.2.0-py2.py3-none-any.whl", hash = "sha256:61a99e9b12b47b685d1389f4cf969c1eba0efd2348a8471f86e01e8c622267af"},
-    {file = "filelock-3.2.0.tar.gz", hash = "sha256:85ecb30757aa19d06bfcdad29cc332b9a3e4851bf59976aea1e8dadcbd9ef883"},
+    {file = "filelock-3.3.0-py3-none-any.whl", hash = "sha256:bbc6a0382fe8ec4744ecdf6683a2e07f65eb10ff1aff53fc02a202565446cde0"},
+    {file = "filelock-3.3.0.tar.gz", hash = "sha256:8c7eab13dc442dc249e95158bcc12dec724465919bdc9831fdbf0660f03d1785"},
 ]
 flake8 = [
     {file = "flake8-3.9.2-py2.py3-none-any.whl", hash = "sha256:bf8fd333346d844f616e8d47905ef3a3384edae6b4e9beb0c5101e25e3110907"},
@@ -3634,8 +3645,8 @@ gitpython = [
     {file = "GitPython-3.1.20.tar.gz", hash = "sha256:df0e072a200703a65387b0cfdf0466e3bab729c0458cf6b7349d0e9877636519"},
 ]
 google-api-core = [
-    {file = "google-api-core-2.0.1.tar.gz", hash = "sha256:d6760f21b3a064a8397916b33be7383fc169d1a3c3d7fae7b47eb92bba7892b8"},
-    {file = "google_api_core-2.0.1-py2.py3-none-any.whl", hash = "sha256:b8ad41f72a70dd709dd13a08478936172aecf5f2d34a18ab378efa6d2d6ab575"},
+    {file = "google-api-core-2.1.0.tar.gz", hash = "sha256:5ec27b942b34d04559cbf3674430bb83fc3d74e7d32b8bbd31c4466e71740b83"},
+    {file = "google_api_core-2.1.0-py2.py3-none-any.whl", hash = "sha256:c344e1aacd8330527c5130bdfe03118d8859ce798bcf0e5d23770ab6873e0615"},
 ]
 google-auth = [
     {file = "google-auth-1.35.0.tar.gz", hash = "sha256:b7033be9028c188ee30200b204ea00ed82ea1162e8ac1df4aa6ded19a191d88e"},
@@ -3646,57 +3657,57 @@ google-auth-oauthlib = [
     {file = "google_auth_oauthlib-0.4.6-py2.py3-none-any.whl", hash = "sha256:3f2a6e802eebbb6fb736a370fbf3b055edcb6b52878bf2f26330b5e041316c73"},
 ]
 google-cloud-core = [
-    {file = "google-cloud-core-2.0.0.tar.gz", hash = "sha256:90ee99648ccf9e11a16781a7fc58d13e58f662b439c737d48c24ef18662c2702"},
-    {file = "google_cloud_core-2.0.0-py2.py3-none-any.whl", hash = "sha256:31785d1e1d02f90ad3f1b020d4aed63db4865c3394ff7c128a296b6995eef31f"},
+    {file = "google-cloud-core-2.1.0.tar.gz", hash = "sha256:35a1f5f02a86e0fa2e28c669f0db4a76d928671a28fbbbb493ab59ba9d1cb9a9"},
+    {file = "google_cloud_core-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d5fed11731dae8bc8656a2c9fa8ff17bdfdfd083cba97569324e35b94e7e002"},
 ]
 google-cloud-storage = [
     {file = "google-cloud-storage-1.42.3.tar.gz", hash = "sha256:7754d4dcaa45975514b404ece0da2bb4292acbc67ca559a69e12a19d54fcdb06"},
     {file = "google_cloud_storage-1.42.3-py2.py3-none-any.whl", hash = "sha256:71ee3a0dcf2c139f034a054181cd7658f1ec8f12837d2769c450a8a00fcd4c6d"},
 ]
 google-crc32c = [
-    {file = "google-crc32c-1.2.0.tar.gz", hash = "sha256:258caf72c4ab03d91e593ed9f988c13c118754f5ce46d8bcbc40b109d14cb8b7"},
-    {file = "google_crc32c-1.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b64bd23a66410883c22c156834b73515e3f3d8c890c0407620f960b4c25cc8a3"},
-    {file = "google_crc32c-1.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:61080f164ea51e156153c601b1de35ccb574d77efb669c11ade75f8635ce2d29"},
-    {file = "google_crc32c-1.2.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f563a48074de0a4ebf1ef1d55aeb16bdaa6715c33091dad3b6a32716d2a5d4a4"},
-    {file = "google_crc32c-1.2.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:242274e127e349e6ede67d7232872bdac9f6c36da6233216e8e4f5923eef1a7c"},
-    {file = "google_crc32c-1.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93f1377269cf30b15b296e760ac3f6e13ea52556a764739410fa2e7b32a39e93"},
-    {file = "google_crc32c-1.2.0-cp310-cp310-win32.whl", hash = "sha256:60f9e93e29cbaa47f57230907733af884685dbac78d462019ffe02d514bbfddc"},
-    {file = "google_crc32c-1.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:b28e81707257802d1e07aee4a2513d1316f623a1b48b78885c1ca2a9ec47949d"},
-    {file = "google_crc32c-1.2.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:837a17d940dac5b0d0a88868a2be924bbb31578de20c250620c09ac7c3f9d1fd"},
-    {file = "google_crc32c-1.2.0-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:966186c535fec30606cb7787e3caa283631f80c50cbd7226e7db1589ede0f177"},
-    {file = "google_crc32c-1.2.0-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:617ec1f65d769e670dd35d9e8db0244d03bb09b8728262e28ebeab82de8d1341"},
-    {file = "google_crc32c-1.2.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca0f7bcb47dbd1367bb8f2d7dfc90568a7f69e4062dd70b21a365fc361c9929d"},
-    {file = "google_crc32c-1.2.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:e7b98a2dabe06a460219ecad21113d1c9d793910ceeeae8b4fb64871ef203c4c"},
-    {file = "google_crc32c-1.2.0-cp36-cp36m-win32.whl", hash = "sha256:a6307368bc04f07d3bdf554109d5ebd64b350c12e1a3604686e7a2d913585b1e"},
-    {file = "google_crc32c-1.2.0-cp36-cp36m-win_amd64.whl", hash = "sha256:4b2f3a9f61f264029ffbaf9f503340da1e72e602650eb46d34940a431e3a2676"},
-    {file = "google_crc32c-1.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:ce877f9ce49db4f465d942ea910475d79148b390e5890efb2e505df9596d5ced"},
-    {file = "google_crc32c-1.2.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c9a057c13a268c3a03d1fc8aa08358952b7ff560bb2893fe46dd5823cc0f47b7"},
-    {file = "google_crc32c-1.2.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ad1cfabad6e9d4affd03684fde2763fa47b6d5a9696a03df3bb23f197cf55af1"},
-    {file = "google_crc32c-1.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b19ee0a14107fc29a24129982f16648908363b0c43cf6a2b68ece7768c4d038b"},
-    {file = "google_crc32c-1.2.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:fd55f480bb87e1f03b08a8bff13a0689efa7bf10426f1b58f2081168a05b3463"},
-    {file = "google_crc32c-1.2.0-cp37-cp37m-win32.whl", hash = "sha256:6690bbdbfafc39f7031e19e07965b28b91cf41f3a66267e9e9f75b7bcbcd8ac6"},
-    {file = "google_crc32c-1.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:8331f0cbf8d91e868858a95c3608c26c2b8872f0ed8464c58425995aa92cb70b"},
-    {file = "google_crc32c-1.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:96e7057e29abfe763db02877b7cafff8a076145feb446106409f4fc12549d281"},
-    {file = "google_crc32c-1.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:496d7d6ac406f3a8e9f1e2fea93bc5470d5ff02c6ea34745c9aa5f22c876f30e"},
-    {file = "google_crc32c-1.2.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8a862ea73b86c3b6589847224195e1027a876c85dc1f87475509b58d2aaafcda"},
-    {file = "google_crc32c-1.2.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:eb32e021526e905500c08aa030461621e5af934bf68a910322f5ddebb8c2bbf9"},
-    {file = "google_crc32c-1.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e720b0c9df6a58d4786c299407c2561993e9abd41d37c38e09d33288a3aca0d"},
-    {file = "google_crc32c-1.2.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:8aa4de2ffad9d5521d9ba105a1a59126423389598cb4f9af9d28d4da845c0414"},
-    {file = "google_crc32c-1.2.0-cp38-cp38-win32.whl", hash = "sha256:adb721315435d8530a9eabce2cf3731db015ca0af5f8f983bf5c6e5272385c02"},
-    {file = "google_crc32c-1.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:a7920ea4770ec6b98a30e99f9ab90aacc0a447a316c165701f264234d8dbf731"},
-    {file = "google_crc32c-1.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c242c82eef7fb75ee698ecc65596e324b3273ae3dd78a8e5f05bf3cb627caa3b"},
-    {file = "google_crc32c-1.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a6694773dd45c88b2babef6b702b6233723ae4f42cca0fbc68114e81ed389188"},
-    {file = "google_crc32c-1.2.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:70670518d50babd6012de3206472aa406a41b79acb11b6e46931f842e25a356a"},
-    {file = "google_crc32c-1.2.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dc12aef85a7b8e5c52d7639cf23e27548f09fba798b8050f59fdd5bee08051f2"},
-    {file = "google_crc32c-1.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e13c8f1fbde9b543f693c42c0f82ba6c57683d66cc2c5960c6c66fccb42a736"},
-    {file = "google_crc32c-1.2.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:483694ccb1d0ceab8219afc4f20939565b09f81531bf8dd2bf3efb3ea84766fe"},
-    {file = "google_crc32c-1.2.0-cp39-cp39-win32.whl", hash = "sha256:618c304e803fb5e4b1dbe4d529e1047450d913b64dc4e49826bb3e5a0ef73a9e"},
-    {file = "google_crc32c-1.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:60c4f32d1fbd25234ff9468de24c1c8a9556e90ac94818a99c8cfc83328214d1"},
-    {file = "google_crc32c-1.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:4b8c7579269e3c64dda1d63cc9b9ba7615b51092c905b68d43c907be80fc641f"},
-    {file = "google_crc32c-1.2.0-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c24e7e78756f617ebf006adcb0edb74aaf93a31a45440266e66f5fb2b8c75512"},
-    {file = "google_crc32c-1.2.0-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:81c2e088041fb38b099b5a7fb2407deff74ee9bec3b36c38180564b4686bc1fa"},
-    {file = "google_crc32c-1.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c422331bdeb5214ecc8a98f85dcbbc5b3222d173b1348874f1087b1f938313d8"},
-    {file = "google_crc32c-1.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:9caf25a7f2551b117e063ce1e1f3959ef64d8c4e96587e4ce6ee1be7b441b3b7"},
+    {file = "google-crc32c-1.3.0.tar.gz", hash = "sha256:276de6273eb074a35bc598f8efbc00c7869c5cf2e29c90748fccc8c898c244df"},
+    {file = "google_crc32c-1.3.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cb6994fff247987c66a8a4e550ef374671c2b82e3c0d2115e689d21e511a652d"},
+    {file = "google_crc32c-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c9da0a39b53d2fab3e5467329ed50e951eb91386e9d0d5b12daf593973c3b168"},
+    {file = "google_crc32c-1.3.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:eb0b14523758e37802f27b7f8cd973f5f3d33be7613952c0df904b68c4842f0e"},
+    {file = "google_crc32c-1.3.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:95c68a4b9b7828ba0428f8f7e3109c5d476ca44996ed9a5f8aac6269296e2d59"},
+    {file = "google_crc32c-1.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c3cf890c3c0ecfe1510a452a165431b5831e24160c5fcf2071f0f85ca5a47cd"},
+    {file = "google_crc32c-1.3.0-cp310-cp310-win32.whl", hash = "sha256:3bbce1be3687bbfebe29abdb7631b83e6b25da3f4e1856a1611eb21854b689ea"},
+    {file = "google_crc32c-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:c124b8c8779bf2d35d9b721e52d4adb41c9bfbde45e6a3f25f0820caa9aba73f"},
+    {file = "google_crc32c-1.3.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:42ae4781333e331a1743445931b08ebdad73e188fd554259e772556fc4937c48"},
+    {file = "google_crc32c-1.3.0-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ff71073ebf0e42258a42a0b34f2c09ec384977e7f6808999102eedd5b49920e3"},
+    {file = "google_crc32c-1.3.0-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:fe31de3002e7b08eb20823b3735b97c86c5926dd0581c7710a680b418a8709d4"},
+    {file = "google_crc32c-1.3.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd7760a88a8d3d705ff562aa93f8445ead54f58fd482e4f9e2bafb7e177375d4"},
+    {file = "google_crc32c-1.3.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a0b9e622c3b2b8d0ce32f77eba617ab0d6768b82836391e4f8f9e2074582bf02"},
+    {file = "google_crc32c-1.3.0-cp36-cp36m-win32.whl", hash = "sha256:779cbf1ce375b96111db98fca913c1f5ec11b1d870e529b1dc7354b2681a8c3a"},
+    {file = "google_crc32c-1.3.0-cp36-cp36m-win_amd64.whl", hash = "sha256:04e7c220798a72fd0f08242bc8d7a05986b2a08a0573396187fd32c1dcdd58b3"},
+    {file = "google_crc32c-1.3.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:e7a539b9be7b9c00f11ef16b55486141bc2cdb0c54762f84e3c6fc091917436d"},
+    {file = "google_crc32c-1.3.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ca60076c388728d3b6ac3846842474f4250c91efbfe5afa872d3ffd69dd4b318"},
+    {file = "google_crc32c-1.3.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:05340b60bf05b574159e9bd940152a47d38af3fb43803ffe71f11d704b7696a6"},
+    {file = "google_crc32c-1.3.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:318f73f5484b5671f0c7f5f63741ab020a599504ed81d209b5c7129ee4667407"},
+    {file = "google_crc32c-1.3.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:9f58099ad7affc0754ae42e6d87443299f15d739b0ce03c76f515153a5cda06c"},
+    {file = "google_crc32c-1.3.0-cp37-cp37m-win32.whl", hash = "sha256:f52a4ad2568314ee713715b1e2d79ab55fab11e8b304fd1462ff5cccf4264b3e"},
+    {file = "google_crc32c-1.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:bab4aebd525218bab4ee615786c4581952eadc16b1ff031813a2fd51f0cc7b08"},
+    {file = "google_crc32c-1.3.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:dda4d8a3bb0b50f540f6ff4b6033f3a74e8bf0bd5320b70fab2c03e512a62812"},
+    {file = "google_crc32c-1.3.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:fec221a051150eeddfdfcff162e6db92c65ecf46cb0f7bb1bf812a1520ec026b"},
+    {file = "google_crc32c-1.3.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:226f2f9b8e128a6ca6a9af9b9e8384f7b53a801907425c9a292553a3a7218ce0"},
+    {file = "google_crc32c-1.3.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a7f9cbea4245ee36190f85fe1814e2d7b1e5f2186381b082f5d59f99b7f11328"},
+    {file = "google_crc32c-1.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a4db36f9721fdf391646685ecffa404eb986cbe007a3289499020daf72e88a2"},
+    {file = "google_crc32c-1.3.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:12674a4c3b56b706153a358eaa1018c4137a5a04635b92b4652440d3d7386206"},
+    {file = "google_crc32c-1.3.0-cp38-cp38-win32.whl", hash = "sha256:650e2917660e696041ab3dcd7abac160b4121cd9a484c08406f24c5964099829"},
+    {file = "google_crc32c-1.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:58be56ae0529c664cc04a9c76e68bb92b091e0194d6e3c50bea7e0f266f73713"},
+    {file = "google_crc32c-1.3.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:96a8918a78d5d64e07c8ea4ed2bc44354e3f93f46a4866a40e8db934e4c0d74b"},
+    {file = "google_crc32c-1.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:13af315c3a0eec8bb8b8d80b8b128cb3fcd17d7e4edafc39647846345a3f003a"},
+    {file = "google_crc32c-1.3.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:6311853aa2bba4064d0c28ca54e7b50c4d48e3de04f6770f6c60ebda1e975267"},
+    {file = "google_crc32c-1.3.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ed447680ff21c14aaceb6a9f99a5f639f583ccfe4ce1a5e1d48eb41c3d6b3217"},
+    {file = "google_crc32c-1.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1c1d6236feab51200272d79b3d3e0f12cf2cbb12b208c835b175a21efdb0a73"},
+    {file = "google_crc32c-1.3.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:e0f1ff55dde0ebcfbef027edc21f71c205845585fffe30d4ec4979416613e9b3"},
+    {file = "google_crc32c-1.3.0-cp39-cp39-win32.whl", hash = "sha256:fbd60c6aaa07c31d7754edbc2334aef50601b7f1ada67a96eb1eb57c7c72378f"},
+    {file = "google_crc32c-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:127f9cc3ac41b6a859bd9dc4321097b1a4f6aa7fdf71b4f9227b9e3ebffb4422"},
+    {file = "google_crc32c-1.3.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fc28e0db232c62ca0c3600884933178f0825c99be4474cdd645e378a10588125"},
+    {file = "google_crc32c-1.3.0-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1926fd8de0acb9d15ee757175ce7242e235482a783cd4ec711cc999fc103c24e"},
+    {file = "google_crc32c-1.3.0-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5da2c81575cc3ccf05d9830f9e8d3c70954819ca9a63828210498c0774fda1a3"},
+    {file = "google_crc32c-1.3.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:891f712ce54e0d631370e1f4997b3f182f3368179198efc30d477c75d1f44942"},
+    {file = "google_crc32c-1.3.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:7f6fe42536d9dcd3e2ffb9d3053f5d05221ae3bbcefbe472bdf2c71c793e3183"},
 ]
 google-pasta = [
     {file = "google-pasta-0.2.0.tar.gz", hash = "sha256:c9f2c8dfc8f96d0d5808299920721be30c9eec37f2389f28904f454565c8a16e"},
@@ -3841,8 +3852,8 @@ hstspreload = [
     {file = "hstspreload-2021.10.1.tar.gz", hash = "sha256:5bb90f438bec40faf320170ee48cf1978f40423ee1ba39a57bb686f3f9c061c7"},
 ]
 httplib2 = [
-    {file = "httplib2-0.19.1-py3-none-any.whl", hash = "sha256:2ad195faf9faf079723f6714926e9a9061f694d07724b846658ce08d40f522b4"},
-    {file = "httplib2-0.19.1.tar.gz", hash = "sha256:0b12617eeca7433d4c396a100eaecfa4b08ee99aa881e6df6e257a7aad5d533d"},
+    {file = "httplib2-0.20.1-py3-none-any.whl", hash = "sha256:8fa4dbf2fbf839b71f8c7837a831e00fcdc860feca99b8bda58ceae4bc53d185"},
+    {file = "httplib2-0.20.1.tar.gz", hash = "sha256:0efbcb8bfbfbc11578130d87d8afcc65c2274c6eb446e59fc674e4d7c972d327"},
 ]
 httptools = [
     {file = "httptools-0.3.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4137137de8976511a392e27bfdcf231bd926ac13d375e0414e927b08217d779e"},
@@ -3942,8 +3953,8 @@ jieba = [
     {file = "jieba-0.42.1.tar.gz", hash = "sha256:055ca12f62674fafed09427f176506079bc135638a14e23e25be909131928db2"},
 ]
 jinja2 = [
-    {file = "Jinja2-3.0.1-py3-none-any.whl", hash = "sha256:1f06f2da51e7b56b8f238affdd6b4e2c61e39598a378cc49345bc1bd42a978a4"},
-    {file = "Jinja2-3.0.1.tar.gz", hash = "sha256:703f484b47a6af502e743c9122595cc812b0271f661722403114f71a79d0f5a4"},
+    {file = "Jinja2-3.0.2-py3-none-any.whl", hash = "sha256:8569982d3f0889eed11dd620c706d39b60c36d6d25843961f33f77fb6bc6b20c"},
+    {file = "Jinja2-3.0.2.tar.gz", hash = "sha256:827a0e32839ab1600d4eb1c4c33ec5a8edfbc5cb42dafa13b81f182f97784b45"},
 ]
 jmespath = [
     {file = "jmespath-0.10.0-py2.py3-none-any.whl", hash = "sha256:cdf6525904cc597730141d61b36f2e4b8ecc257c420fa2f4549bac2c2d0cb72f"},
@@ -3991,14 +4002,18 @@ kiwisolver = [
     {file = "kiwisolver-1.3.1-cp37-cp37m-manylinux2014_ppc64le.whl", hash = "sha256:1e1bc12fb773a7b2ffdeb8380609f4f8064777877b2225dec3da711b421fda31"},
     {file = "kiwisolver-1.3.1-cp37-cp37m-win32.whl", hash = "sha256:72c99e39d005b793fb7d3d4e660aed6b6281b502e8c1eaf8ee8346023c8e03bc"},
     {file = "kiwisolver-1.3.1-cp37-cp37m-win_amd64.whl", hash = "sha256:8be8d84b7d4f2ba4ffff3665bcd0211318aa632395a1a41553250484a871d454"},
+    {file = "kiwisolver-1.3.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:24cc411232d14c8abafbd0dddb83e1a4f54d77770b53db72edcfe1d611b3bf11"},
     {file = "kiwisolver-1.3.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:31dfd2ac56edc0ff9ac295193eeaea1c0c923c0355bf948fbd99ed6018010b72"},
+    {file = "kiwisolver-1.3.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ef6eefcf3944e75508cdfa513c06cf80bafd7d179e14c1334ebdca9ebb8c2c66"},
     {file = "kiwisolver-1.3.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:563c649cfdef27d081c84e72a03b48ea9408c16657500c312575ae9d9f7bc1c3"},
     {file = "kiwisolver-1.3.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:78751b33595f7f9511952e7e60ce858c6d64db2e062afb325985ddbd34b5c131"},
     {file = "kiwisolver-1.3.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:a357fd4f15ee49b4a98b44ec23a34a95f1e00292a139d6015c11f55774ef10de"},
     {file = "kiwisolver-1.3.1-cp38-cp38-manylinux2014_ppc64le.whl", hash = "sha256:5989db3b3b34b76c09253deeaf7fbc2707616f130e166996606c284395da3f18"},
     {file = "kiwisolver-1.3.1-cp38-cp38-win32.whl", hash = "sha256:c08e95114951dc2090c4a630c2385bef681cacf12636fb0241accdc6b303fd81"},
     {file = "kiwisolver-1.3.1-cp38-cp38-win_amd64.whl", hash = "sha256:44a62e24d9b01ba94ae7a4a6c3fb215dc4af1dde817e7498d901e229aaf50e4e"},
+    {file = "kiwisolver-1.3.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:6d9d8d9b31aa8c2d80a690693aebd8b5e2b7a45ab065bb78f1609995d2c79240"},
     {file = "kiwisolver-1.3.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:50af681a36b2a1dee1d3c169ade9fdc59207d3c31e522519181e12f1b3ba7000"},
+    {file = "kiwisolver-1.3.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:792e69140828babe9649de583e1a03a0f2ff39918a71782c76b3c683a67c6dfd"},
     {file = "kiwisolver-1.3.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:a53d27d0c2a0ebd07e395e56a1fbdf75ffedc4a05943daf472af163413ce9598"},
     {file = "kiwisolver-1.3.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:834ee27348c4aefc20b479335fd422a2c69db55f7d9ab61721ac8cd83eb78882"},
     {file = "kiwisolver-1.3.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:5c3e6455341008a054cccee8c5d24481bcfe1acdbc9add30aa95798e95c65621"},
@@ -4008,6 +4023,7 @@ kiwisolver = [
     {file = "kiwisolver-1.3.1-pp36-pypy36_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0cd53f403202159b44528498de18f9285b04482bab2a6fc3f5dd8dbb9352e30d"},
     {file = "kiwisolver-1.3.1-pp36-pypy36_pp73-manylinux2010_x86_64.whl", hash = "sha256:33449715e0101e4d34f64990352bce4095c8bf13bed1b390773fc0a7295967b3"},
     {file = "kiwisolver-1.3.1-pp36-pypy36_pp73-win32.whl", hash = "sha256:401a2e9afa8588589775fe34fc22d918ae839aaaf0c0e96441c0fdbce6d8ebe6"},
+    {file = "kiwisolver-1.3.1-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d6563ccd46b645e966b400bb8a95d3457ca6cf3bba1e908f9e0927901dfebeb1"},
     {file = "kiwisolver-1.3.1.tar.gz", hash = "sha256:950a199911a8d94683a6b10321f9345d5a3a8433ec58b217ace979e18f16e248"},
 ]
 markdown = [
@@ -4015,12 +4031,22 @@ markdown = [
     {file = "Markdown-3.3.4.tar.gz", hash = "sha256:31b5b491868dcc87d6c24b7e3d19a0d730d59d3e46f4eea6430a321bed387a49"},
 ]
 markupsafe = [
+    {file = "MarkupSafe-2.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d8446c54dc28c01e5a2dbac5a25f071f6653e6e40f3a8818e8b45d790fe6ef53"},
+    {file = "MarkupSafe-2.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:36bc903cbb393720fad60fc28c10de6acf10dc6cc883f3e24ee4012371399a38"},
+    {file = "MarkupSafe-2.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2d7d807855b419fc2ed3e631034685db6079889a1f01d5d9dac950f764da3dad"},
+    {file = "MarkupSafe-2.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:add36cb2dbb8b736611303cd3bfcee00afd96471b09cda130da3581cbdc56a6d"},
+    {file = "MarkupSafe-2.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:168cd0a3642de83558a5153c8bd34f175a9a6e7f6dc6384b9655d2697312a646"},
+    {file = "MarkupSafe-2.0.1-cp310-cp310-win32.whl", hash = "sha256:99df47edb6bda1249d3e80fdabb1dab8c08ef3975f69aed437cb69d0a5de1e28"},
+    {file = "MarkupSafe-2.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:e0f138900af21926a02425cf736db95be9f4af72ba1bb21453432a07f6082134"},
     {file = "MarkupSafe-2.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:f9081981fe268bd86831e5c75f7de206ef275defcb82bc70740ae6dc507aee51"},
     {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:0955295dd5eec6cb6cc2fe1698f4c6d84af2e92de33fbcac4111913cd100a6ff"},
     {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:0446679737af14f45767963a1a9ef7620189912317d095f2d9ffa183a4d25d2b"},
     {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:f826e31d18b516f653fe296d967d700fddad5901ae07c622bb3705955e1faa94"},
     {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:fa130dd50c57d53368c9d59395cb5526eda596d3ffe36666cd81a44d56e48872"},
     {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:905fec760bd2fa1388bb5b489ee8ee5f7291d692638ea5f67982d968366bef9f"},
+    {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf5d821ffabf0ef3533c39c518f3357b171a1651c1ff6827325e4489b0e46c3c"},
+    {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0d4b31cc67ab36e3392bbf3862cfbadac3db12bdd8b02a2731f509ed5b829724"},
+    {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:baa1a4e8f868845af802979fcdbf0bb11f94f1cb7ced4c4b8a351bb60d108145"},
     {file = "MarkupSafe-2.0.1-cp36-cp36m-win32.whl", hash = "sha256:6c4ca60fa24e85fe25b912b01e62cb969d69a23a5d5867682dd3e80b5b02581d"},
     {file = "MarkupSafe-2.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:b2f4bf27480f5e5e8ce285a8c8fd176c0b03e93dcc6646477d4630e83440c6a9"},
     {file = "MarkupSafe-2.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0717a7390a68be14b8c793ba258e075c6f4ca819f15edfc2a3a027c823718567"},
@@ -4029,14 +4055,21 @@ markupsafe = [
     {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:d7f9850398e85aba693bb640262d3611788b1f29a79f0c93c565694658f4071f"},
     {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:6a7fae0dd14cf60ad5ff42baa2e95727c3d81ded453457771d02b7d2b3f9c0c2"},
     {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:b7f2d075102dc8c794cbde1947378051c4e5180d52d276987b8d28a3bd58c17d"},
+    {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e9936f0b261d4df76ad22f8fee3ae83b60d7c3e871292cd42f40b81b70afae85"},
+    {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:2a7d351cbd8cfeb19ca00de495e224dea7e7d919659c2841bbb7f420ad03e2d6"},
+    {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:60bf42e36abfaf9aff1f50f52644b336d4f0a3fd6d8a60ca0d054ac9f713a864"},
     {file = "MarkupSafe-2.0.1-cp37-cp37m-win32.whl", hash = "sha256:a30e67a65b53ea0a5e62fe23682cfe22712e01f453b95233b25502f7c61cb415"},
     {file = "MarkupSafe-2.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:611d1ad9a4288cf3e3c16014564df047fe08410e628f89805e475368bd304914"},
+    {file = "MarkupSafe-2.0.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5bb28c636d87e840583ee3adeb78172efc47c8b26127267f54a9c0ec251d41a9"},
     {file = "MarkupSafe-2.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:be98f628055368795d818ebf93da628541e10b75b41c559fdf36d104c5787066"},
     {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:1d609f577dc6e1aa17d746f8bd3c31aa4d258f4070d61b2aa5c4166c1539de35"},
     {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:7d91275b0245b1da4d4cfa07e0faedd5b0812efc15b702576d103293e252af1b"},
     {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:01a9b8ea66f1658938f65b93a85ebe8bc016e6769611be228d797c9d998dd298"},
     {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:47ab1e7b91c098ab893b828deafa1203de86d0bc6ab587b160f78fe6c4011f75"},
     {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:97383d78eb34da7e1fa37dd273c20ad4320929af65d156e35a5e2d89566d9dfb"},
+    {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6fcf051089389abe060c9cd7caa212c707e58153afa2c649f00346ce6d260f1b"},
+    {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5855f8438a7d1d458206a2466bf82b0f104a3724bf96a1c781ab731e4201731a"},
+    {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:3dd007d54ee88b46be476e293f48c85048603f5f516008bee124ddd891398ed6"},
     {file = "MarkupSafe-2.0.1-cp38-cp38-win32.whl", hash = "sha256:023cb26ec21ece8dc3907c0e8320058b2e0cb3c55cf9564da612bc325bed5e64"},
     {file = "MarkupSafe-2.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:984d76483eb32f1bcb536dc27e4ad56bba4baa70be32fa87152832cdd9db0833"},
     {file = "MarkupSafe-2.0.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:2ef54abee730b502252bcdf31b10dacb0a416229b72c18b19e24a4509f273d26"},
@@ -4046,6 +4079,9 @@ markupsafe = [
     {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:4efca8f86c54b22348a5467704e3fec767b2db12fc39c6d963168ab1d3fc9135"},
     {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:ab3ef638ace319fa26553db0624c4699e31a28bb2a835c5faca8f8acf6a5a902"},
     {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:f8ba0e8349a38d3001fae7eadded3f6606f0da5d748ee53cc1dab1d6527b9509"},
+    {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c47adbc92fc1bb2b3274c4b3a43ae0e4573d9fbff4f54cd484555edbf030baf1"},
+    {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:37205cac2a79194e3750b0af2a5720d95f786a55ce7df90c3af697bfa100eaac"},
+    {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:1f2ade76b9903f39aa442b4aadd2177decb66525062db244b35d71d0ee8599b6"},
     {file = "MarkupSafe-2.0.1-cp39-cp39-win32.whl", hash = "sha256:10f82115e21dc0dfec9ab5c0223652f7197feb168c940f3ef61563fc2d6beb74"},
     {file = "MarkupSafe-2.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:693ce3f9e70a6cf7d2fb9e6c9d8b204b6b39897a2c4a1aa65728d5ac97dcc1d8"},
     {file = "MarkupSafe-2.0.1.tar.gz", hash = "sha256:594c67807fb16238b30c44bdf74f36c02cdf22d1c8cda91ef8a0ed8dabf5620a"},
@@ -4369,27 +4405,27 @@ prompt-toolkit = [
     {file = "prompt_toolkit-2.0.10.tar.gz", hash = "sha256:f15af68f66e664eaa559d4ac8a928111eebd5feda0c11738b5998045224829db"},
 ]
 protobuf = [
-    {file = "protobuf-3.18.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:9072cb18fca8998b77f969fb74d25a11d7f4a39a8b1ddc3cf76cd5abda8499cb"},
-    {file = "protobuf-3.18.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f589346b5b3f702c1d30e2343c9897e6c35e7bd495c10a0e17d11ecb5ee5bd06"},
-    {file = "protobuf-3.18.0-cp36-cp36m-win32.whl", hash = "sha256:93c077fd83879cf48f327a2491c24da447a09da6a7ab3cc311a6f5a61fcb5de0"},
-    {file = "protobuf-3.18.0-cp36-cp36m-win_amd64.whl", hash = "sha256:3b5b81bb665aac548b413480f4e0d8c38a74bc4dea57835f288a3ce74f63dfe9"},
-    {file = "protobuf-3.18.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:d11465040cadcea8ecf5f0b131af5099a9696f9d0bef6f88148b372bacc1c52d"},
-    {file = "protobuf-3.18.0-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:f6138462643adce0ed6e49007a63b7fd7dc4fda1ef4e15a70fcebe76c1407a71"},
-    {file = "protobuf-3.18.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:877664b1b8d1e23553634f625e4e12aae4ff16cbbef473f8118c239d478f422a"},
-    {file = "protobuf-3.18.0-cp37-cp37m-win32.whl", hash = "sha256:5201333b7aa711965c5769b250f8565a9924e8e27f8b622bbc5e6847aeaab1b1"},
-    {file = "protobuf-3.18.0-cp37-cp37m-win_amd64.whl", hash = "sha256:1f3ecec3038c2fb4dad952d3d6cb9ca301999903a09e43794fb348da48f7577f"},
-    {file = "protobuf-3.18.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:17181fc0814655812aac108e755bd5185d71aa8d81bd241cec6e232c84097918"},
-    {file = "protobuf-3.18.0-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:7646c20605fbee57e77fdbc4a90175538281b152f46ba17019916593f8062c2a"},
-    {file = "protobuf-3.18.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80b0a5157f3a53043daf8eb7cfa1220b27a5a63dd6655dbd8e1e6f7b5dcd6347"},
-    {file = "protobuf-3.18.0-cp38-cp38-win32.whl", hash = "sha256:5730de255c95b3403eedd1a568eb28203b913b6192ff5a3fdc3ff30f37107a38"},
-    {file = "protobuf-3.18.0-cp38-cp38-win_amd64.whl", hash = "sha256:9147565f93e6699d7512747766598afe63205f226ac7b61f47954974c9aab852"},
-    {file = "protobuf-3.18.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:568c049ff002a7523ed33fb612e6b97da002bf87ffb619a1fc3eadf2257a3b31"},
-    {file = "protobuf-3.18.0-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:7e791a94db391ae22b3943fc88f6ba0e1f62b6ad58b33db7517df576c7834d23"},
-    {file = "protobuf-3.18.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42c04e66ec5a38ad2171639dc9860c2f9594668f709ea3a4a192acf7346853a7"},
-    {file = "protobuf-3.18.0-cp39-cp39-win32.whl", hash = "sha256:0a59ea8da307118372750e2fdfe0961622e675b8dd35e05c42384d618189a938"},
-    {file = "protobuf-3.18.0-cp39-cp39-win_amd64.whl", hash = "sha256:f7c8193ec805324ff6024242b00f64a24b94d56b895f62bf28a9d72a228d4fca"},
-    {file = "protobuf-3.18.0-py2.py3-none-any.whl", hash = "sha256:615099e52e9fbc9fde00177267a94ca820ecf4e80093e390753568b7d8cb3c1a"},
-    {file = "protobuf-3.18.0.tar.gz", hash = "sha256:18b308946a592e245299391e53c01b5b8efc2794f49986e80f37d7b5e60a270f"},
+    {file = "protobuf-3.18.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:fa6d1049d5315566f55c04d0b50c0033415144f96a9d25c820dc542fe2bb7f45"},
+    {file = "protobuf-3.18.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0e2790c580070cff2921b93d562539ae027064340151c50db6aaf94c33048cd"},
+    {file = "protobuf-3.18.1-cp36-cp36m-win32.whl", hash = "sha256:7e2f0677d68ecdd1cfda2abea65873f5bc7c3f5aae199404a3f5c1d1198c1a63"},
+    {file = "protobuf-3.18.1-cp36-cp36m-win_amd64.whl", hash = "sha256:6f714f5de9d40b3bec90ede4a688cce52f637ccdc5403afcda1f67598f4fdcd7"},
+    {file = "protobuf-3.18.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:7a7be937c319146cc9f2626f0181e6809062c353e1fe449ecd0df374ba1036b2"},
+    {file = "protobuf-3.18.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:10544fc7ace885a882623083c24da5b14148c77563acddc3c58d66f6153c09cd"},
+    {file = "protobuf-3.18.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2ee8b11e3eb2ed38f12137c3c132270a0b1dd509e317228ac47b67f21a583f1"},
+    {file = "protobuf-3.18.1-cp37-cp37m-win32.whl", hash = "sha256:c492c217d3f69f4d2d5619571e52ab98538edbf53caf67e53ea92bd0a3b5670f"},
+    {file = "protobuf-3.18.1-cp37-cp37m-win_amd64.whl", hash = "sha256:3c1644f8a7f19b45c7a4c32278e2a55ae9e7e2f9e5f02d960a61f04a4890d3e6"},
+    {file = "protobuf-3.18.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e9ac691f7b24e4371dcd3980e4f5d6c840a2010da37986203053fee995786ec5"},
+    {file = "protobuf-3.18.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:93bad12895d8b0ebc66b605c2ef1802311595f881aef032d9f13282b7550e6b2"},
+    {file = "protobuf-3.18.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0851b5b89191e1976d34fa2e8eb8659829dfb45252053224cf9df857fb5f6a45"},
+    {file = "protobuf-3.18.1-cp38-cp38-win32.whl", hash = "sha256:09d9268f6f9da81b7657adcf2fb397524c82f20cdf9e0db3ff4e7567977abd67"},
+    {file = "protobuf-3.18.1-cp38-cp38-win_amd64.whl", hash = "sha256:d6d927774c0ec746fed15a4faff5f44aad0b7a3421fadb6f3ae5ca1f2f8ae26e"},
+    {file = "protobuf-3.18.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4d19c9cb805fd2be1d59eee39e152367ee92a30167e77bd06c8819f8f0009a4c"},
+    {file = "protobuf-3.18.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:387f621bf7295a331f8c8a6962d097ceddeb85356792888cfa6a5c6bfc6886a4"},
+    {file = "protobuf-3.18.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c1c5d3966c856f60a9d8d62f4455d70c31026422acdd5c228edf22b65b16c38"},
+    {file = "protobuf-3.18.1-cp39-cp39-win32.whl", hash = "sha256:f20f803892f2135e8b96dc58c9a0c6a7ad8436794bf8784af229498d939b4c77"},
+    {file = "protobuf-3.18.1-cp39-cp39-win_amd64.whl", hash = "sha256:d76201380f41a2d83fb613a4683059d1fcafbe969518b3e409e279a8788fde2f"},
+    {file = "protobuf-3.18.1-py2.py3-none-any.whl", hash = "sha256:61ca58e14033ca0dfa484a31d57237c1be3b6013454c7f53876a20fc88dd69b1"},
+    {file = "protobuf-3.18.1.tar.gz", hash = "sha256:1c9bb40503751087300dd12ce2e90899d68628977905c76effc48e66d089391e"},
 ]
 psutil = [
     {file = "psutil-5.8.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:0066a82f7b1b37d334e68697faba68e5ad5e858279fd6351c8ca6024e8d6ba64"},
@@ -4535,8 +4571,8 @@ pyflakes = [
     {file = "pyflakes-2.3.1.tar.gz", hash = "sha256:f5bc8ecabc05bb9d291eb5203d6810b49040f6ff446a756326104746cc00c1db"},
 ]
 pyjwt = [
-    {file = "PyJWT-2.1.0-py3-none-any.whl", hash = "sha256:934d73fbba91b0483d3857d1aff50e96b2a892384ee2c17417ed3203f173fca1"},
-    {file = "PyJWT-2.1.0.tar.gz", hash = "sha256:fba44e7898bbca160a2b2b501f492824fc8382485d3a6f11ba5d0c1937ce6130"},
+    {file = "PyJWT-2.2.0-py3-none-any.whl", hash = "sha256:b0ed5824c8ecc5362e540c65dc6247567db130c4226670bf7699aec92fb4dae1"},
+    {file = "PyJWT-2.2.0.tar.gz", hash = "sha256:a0b9a3b4e5ca5517cac9f1a6e9cd30bf1aa80be74fcdf4e28eded582ecfcfbae"},
 ]
 pykwalify = [
     {file = "pykwalify-1.8.0-py2.py3-none-any.whl", hash = "sha256:731dfa87338cca9f559d1fca2bdea37299116e3139b73f78ca90a543722d6651"},
@@ -4713,8 +4749,8 @@ python-socketio = [
     {file = "python_socketio-5.4.0-py3-none-any.whl", hash = "sha256:7ed57f6c024abdfeb9b25c74c0c00ffc18da47d903e8d72deecb87584370d1fc"},
 ]
 pytz = [
-    {file = "pytz-2021.1-py2.py3-none-any.whl", hash = "sha256:eb10ce3e7736052ed3623d49975ce333bcd712c7bb19a58b9e2089d4057d0798"},
-    {file = "pytz-2021.1.tar.gz", hash = "sha256:83a4a90894bf38e243cf052c8b58f381bfe9a7a483f6a9cab140bc7f702ac4da"},
+    {file = "pytz-2021.3-py2.py3-none-any.whl", hash = "sha256:3672058bc3453457b622aab7a1c3bfd5ab0bdae451512f6cf25f64ed37f5b87c"},
+    {file = "pytz-2021.3.tar.gz", hash = "sha256:acad2d8b20a1af07d4e4c9d2e9285c5ed9104354062f275f3fcd88dcef4f1326"},
 ]
 pyyaml = [
     {file = "PyYAML-5.4.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:3b2b1824fe7112845700f815ff6a489360226a5609b96ec2190a45e62a9fc922"},
@@ -4768,6 +4804,10 @@ regex = [
     {file = "regex-2021.7.6-cp36-cp36m-manylinux2014_i686.whl", hash = "sha256:b85ac458354165405c8a84725de7bbd07b00d9f72c31a60ffbf96bb38d3e25fa"},
     {file = "regex-2021.7.6-cp36-cp36m-manylinux2014_x86_64.whl", hash = "sha256:3f5716923d3d0bfb27048242a6e0f14eecdb2e2a7fac47eda1d055288595f222"},
     {file = "regex-2021.7.6-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e5983c19d0beb6af88cb4d47afb92d96751fb3fa1784d8785b1cdf14c6519407"},
+    {file = "regex-2021.7.6-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf1d2d183abc7faa101ebe0b8d04fd19cb9138820abc8589083035c9440b8ca6"},
+    {file = "regex-2021.7.6-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1947e7de155063e1c495c50590229fb98720d4c383af5031bbcb413db33fa1be"},
+    {file = "regex-2021.7.6-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:17d8a3f99b18d87ac54a449b836d485cc8c195bb6f5e4379c84c8519045facc9"},
+    {file = "regex-2021.7.6-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d30895ec80cc80358392841add9dde81ea1d54a4949049269115e6b0555d0498"},
     {file = "regex-2021.7.6-cp36-cp36m-win32.whl", hash = "sha256:c92831dac113a6e0ab28bc98f33781383fe294df1a2c3dfd1e850114da35fd5b"},
     {file = "regex-2021.7.6-cp36-cp36m-win_amd64.whl", hash = "sha256:791aa1b300e5b6e5d597c37c346fb4d66422178566bbb426dd87eaae475053fb"},
     {file = "regex-2021.7.6-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:59506c6e8bd9306cd8a41511e32d16d5d1194110b8cfe5a11d102d8b63cf945d"},
@@ -4778,6 +4818,10 @@ regex = [
     {file = "regex-2021.7.6-cp37-cp37m-manylinux2014_i686.whl", hash = "sha256:173bc44ff95bc1e96398c38f3629d86fa72e539c79900283afa895694229fe6a"},
     {file = "regex-2021.7.6-cp37-cp37m-manylinux2014_x86_64.whl", hash = "sha256:15dddb19823f5147e7517bb12635b3c82e6f2a3a6b696cc3e321522e8b9308ad"},
     {file = "regex-2021.7.6-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ddeabc7652024803666ea09f32dd1ed40a0579b6fbb2a213eba590683025895"},
+    {file = "regex-2021.7.6-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8244c681018423a0d1784bc6b9af33bdf55f2ab8acb1f3cd9dd83d90e0813253"},
+    {file = "regex-2021.7.6-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8a4c742089faf0e51469c6a1ad7e3d3d21afae54a16a6cead85209dfe0a1ce65"},
+    {file = "regex-2021.7.6-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:914e626dc8e75fe4fc9b7214763f141d9f40165d00dfe680b104fa1b24063bbf"},
+    {file = "regex-2021.7.6-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:3fabb19c82ecf39832a3f5060dfea9a7ab270ef156039a1143a29a83a09a62de"},
     {file = "regex-2021.7.6-cp37-cp37m-win32.whl", hash = "sha256:f080248b3e029d052bf74a897b9d74cfb7643537fbde97fe8225a6467fb559b5"},
     {file = "regex-2021.7.6-cp37-cp37m-win_amd64.whl", hash = "sha256:d8bbce0c96462dbceaa7ac4a7dfbbee92745b801b24bce10a98d2f2b1ea9432f"},
     {file = "regex-2021.7.6-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:edd1a68f79b89b0c57339bce297ad5d5ffcc6ae7e1afdb10f1947706ed066c9c"},
@@ -4788,6 +4832,10 @@ regex = [
     {file = "regex-2021.7.6-cp38-cp38-manylinux2014_i686.whl", hash = "sha256:bc84fb254a875a9f66616ed4538542fb7965db6356f3df571d783f7c8d256edd"},
     {file = "regex-2021.7.6-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:598c0a79b4b851b922f504f9f39a863d83ebdfff787261a5ed061c21e67dd761"},
     {file = "regex-2021.7.6-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:875c355360d0f8d3d827e462b29ea7682bf52327d500a4f837e934e9e4656068"},
+    {file = "regex-2021.7.6-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dfc0957c4a4b91eff5ad036088769e600a25774256cd0e1154378591ce573f08"},
+    {file = "regex-2021.7.6-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:efb4af05fa4d2fc29766bf516f1f5098d6b5c3ed846fde980c18bf8646ad3979"},
+    {file = "regex-2021.7.6-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7423aca7cc30a6228ccdcf2ea76f12923d652c5c7c6dc1959a0b004e308f39fb"},
+    {file = "regex-2021.7.6-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:bb9834c1e77493efd7343b8e38950dee9797d2d6f2d5fd91c008dfaef64684b9"},
     {file = "regex-2021.7.6-cp38-cp38-win32.whl", hash = "sha256:e586f448df2bbc37dfadccdb7ccd125c62b4348cb90c10840d695592aa1b29e0"},
     {file = "regex-2021.7.6-cp38-cp38-win_amd64.whl", hash = "sha256:2fe5e71e11a54e3355fa272137d521a40aace5d937d08b494bed4529964c19c4"},
     {file = "regex-2021.7.6-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6110bab7eab6566492618540c70edd4d2a18f40ca1d51d704f1d81c52d245026"},
@@ -4798,6 +4846,10 @@ regex = [
     {file = "regex-2021.7.6-cp39-cp39-manylinux2014_i686.whl", hash = "sha256:2bceeb491b38225b1fee4517107b8491ba54fba77cf22a12e996d96a3c55613d"},
     {file = "regex-2021.7.6-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:f98dc35ab9a749276f1a4a38ab3e0e2ba1662ce710f6530f5b0a6656f1c32b58"},
     {file = "regex-2021.7.6-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:319eb2a8d0888fa6f1d9177705f341bc9455a2c8aca130016e52c7fe8d6c37a3"},
+    {file = "regex-2021.7.6-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:598ee917dbe961dcf827217bf2466bb86e4ee5a8559705af57cbabb3489dd37e"},
+    {file = "regex-2021.7.6-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:56fc7045a1999a8d9dd1896715bc5c802dfec5b9b60e883d2cbdecb42adedea4"},
+    {file = "regex-2021.7.6-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e8363ac90ea63c3dd0872dfdb695f38aff3334bfa5712cffb238bd3ffef300e3"},
+    {file = "regex-2021.7.6-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:716a6db91b3641f566531ffcc03ceec00b2447f0db9942b3c6ea5d2827ad6be3"},
     {file = "regex-2021.7.6-cp39-cp39-win32.whl", hash = "sha256:eaf58b9e30e0e546cdc3ac06cf9165a1ca5b3de8221e9df679416ca667972035"},
     {file = "regex-2021.7.6-cp39-cp39-win_amd64.whl", hash = "sha256:4c9c3155fe74269f61e27617529b7f09552fbb12e44b1189cebbdb24294e6e1c"},
     {file = "regex-2021.7.6.tar.gz", hash = "sha256:8394e266005f2d8c6f0bc6780001f7afa3ef81a7a2111fa35058ded6fce79e4d"},
@@ -5100,6 +5152,10 @@ tabulate = [
     {file = "tabulate-0.8.9-py3-none-any.whl", hash = "sha256:d7c013fe7abbc5e491394e10fa845f8f32fe54f8dc60c6622c6cf482d25d47e4"},
     {file = "tabulate-0.8.9.tar.gz", hash = "sha256:eb1d13f25760052e8931f2ef80aaf6045a6cceb47514db8beab24cded16f13a7"},
 ]
+tarsafe = [
+    {file = "tarsafe-0.0.3-py3-none-any.whl", hash = "sha256:f8181c5559aea70af2579a0dc0811d2e9e3eabd706dd594555b4dfa52c0be51a"},
+    {file = "tarsafe-0.0.3.tar.gz", hash = "sha256:7acf73a11b576fcbb003b52adecf4706d6c3009c6af28a01fd21949235ffd806"},
+]
 tensorboard = [
     {file = "tensorboard-2.6.0-py3-none-any.whl", hash = "sha256:f7dac4cdfb52d14c9e3f74585ce2aaf8e6203620a864e51faf84988b09f7bbdb"},
 ]
@@ -5184,8 +5240,8 @@ thinc = [
     {file = "thinc-8.0.10.tar.gz", hash = "sha256:b5e4db8d24e6be8a5f1e4a17854772b79a2b560224519f50a21f3951ca24001f"},
 ]
 threadpoolctl = [
-    {file = "threadpoolctl-2.2.0-py3-none-any.whl", hash = "sha256:e5a995e3ffae202758fa8a90082e35783b9370699627ae2733cd1c3a73553616"},
-    {file = "threadpoolctl-2.2.0.tar.gz", hash = "sha256:86d4b6801456d780e94681d155779058759eaef3c3564758b17b6c99db5f81cb"},
+    {file = "threadpoolctl-3.0.0-py3-none-any.whl", hash = "sha256:4fade5b3b48ae4b1c30f200b28f39180371104fccc642e039e0f2435ec8cc211"},
+    {file = "threadpoolctl-3.0.0.tar.gz", hash = "sha256:d03115321233d0be715f0d3a5ad1d6c065fe425ddc2d671ca8e45e9fd5d7a52a"},
 ]
 tokenizers = [
     {file = "tokenizers-0.7.0-cp35-cp35m-macosx_10_10_x86_64.whl", hash = "sha256:c9edc043bc14462faf8b261b528661718e9c4f0b8424fb25be71cae26187432a"},
@@ -5258,8 +5314,8 @@ typed-ast = [
     {file = "typed_ast-1.4.3.tar.gz", hash = "sha256:fb1bbeac803adea29cedd70781399c99138358c26d05fcbd23c13016b7f5ec65"},
 ]
 typeguard = [
-    {file = "typeguard-2.12.1-py3-none-any.whl", hash = "sha256:cc15ef2704c9909ef9c80e19c62fb8468c01f75aad12f651922acf4dbe822e02"},
-    {file = "typeguard-2.12.1.tar.gz", hash = "sha256:c2af8b9bdd7657f4bd27b45336e7930171aead796711bc4cfc99b4731bb9d051"},
+    {file = "typeguard-2.13.0-py3-none-any.whl", hash = "sha256:0bc44d1ff865b522eda969627868b0e001c8329296ce50aededbea03febc79ee"},
+    {file = "typeguard-2.13.0.tar.gz", hash = "sha256:04e38f92eb59410c9375d3be23df65e0a7643f2e8bcbd421423d808d2f9e99df"},
 ]
 typer = [
     {file = "typer-0.4.0-py3-none-any.whl", hash = "sha256:d81169725140423d072df464cad1ff25ee154ef381aaf5b8225352ea187ca338"},
@@ -5341,8 +5397,8 @@ ujson = [
     {file = "ujson-4.2.0.tar.gz", hash = "sha256:fffe509f556861c7343c6cba57ed05fe7bcf4b48a934a5b946ccb45428cf8883"},
 ]
 uritemplate = [
-    {file = "uritemplate-3.0.1-py2.py3-none-any.whl", hash = "sha256:07620c3f3f8eed1f12600845892b0e036a2420acf513c53f7de0abd911a5894f"},
-    {file = "uritemplate-3.0.1.tar.gz", hash = "sha256:5af8ad10cec94f215e3f48112de2022e1d5a37ed427fbd88652fa908f2ab7cae"},
+    {file = "uritemplate-4.0.0-py2.py3-none-any.whl", hash = "sha256:9de62e39c3f7f7584982a4159d70e6aafda5a479a91cccc18e89ae865eab4ae4"},
+    {file = "uritemplate-4.0.0.tar.gz", hash = "sha256:6f4c5b093c915d269df69f291028a72dfdcaf68c8345b92e180f31daf53c4971"},
 ]
 urllib3 = [
     {file = "urllib3-1.26.7-py2.py3-none-any.whl", hash = "sha256:c4fdf4019605b6e5423637e01bc9fe4daef873709a7973e195ceba0a62bbc844"},
@@ -5404,8 +5460,8 @@ websockets = [
     {file = "websockets-8.0.2.tar.gz", hash = "sha256:882a7266fa867a2ebb2c0baaa0f9159cabf131cf18c1b4270d79ad42f9208dc5"},
 ]
 werkzeug = [
-    {file = "Werkzeug-2.0.1-py3-none-any.whl", hash = "sha256:6c1ec500dcdba0baa27600f6a22f6333d8b662d22027ff9f6202e3367413caa8"},
-    {file = "Werkzeug-2.0.1.tar.gz", hash = "sha256:1de1db30d010ff1af14a009224ec49ab2329ad2cde454c8a708130642d579c42"},
+    {file = "Werkzeug-2.0.2-py3-none-any.whl", hash = "sha256:63d3dc1cf60e7b7e35e97fa9861f7397283b75d765afcaefd993d6046899de8f"},
+    {file = "Werkzeug-2.0.2.tar.gz", hash = "sha256:aa2bb6fc8dee8d6c504c0ac1e7f5f7dc5810a9903e793b6f715a9f015bdadb9a"},
 ]
 wrapt = [
     {file = "wrapt-1.12.1.tar.gz", hash = "sha256:b62ffa81fb85f4332a4f609cab4ac40709470da05643a082ec1eb88e6d9b97d7"},
@@ -5415,43 +5471,78 @@ xmltodict = [
     {file = "xmltodict-0.12.0.tar.gz", hash = "sha256:50d8c638ed7ecb88d90561beedbf720c9b4e851a9fa6c47ebd64e99d166d8a21"},
 ]
 yarl = [
-    {file = "yarl-1.6.3-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:0355a701b3998dcd832d0dc47cc5dedf3874f966ac7f870e0f3a6788d802d434"},
-    {file = "yarl-1.6.3-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:bafb450deef6861815ed579c7a6113a879a6ef58aed4c3a4be54400ae8871478"},
-    {file = "yarl-1.6.3-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:547f7665ad50fa8563150ed079f8e805e63dd85def6674c97efd78eed6c224a6"},
-    {file = "yarl-1.6.3-cp36-cp36m-manylinux2014_i686.whl", hash = "sha256:63f90b20ca654b3ecc7a8d62c03ffa46999595f0167d6450fa8383bab252987e"},
-    {file = "yarl-1.6.3-cp36-cp36m-manylinux2014_ppc64le.whl", hash = "sha256:97b5bdc450d63c3ba30a127d018b866ea94e65655efaf889ebeabc20f7d12406"},
-    {file = "yarl-1.6.3-cp36-cp36m-manylinux2014_s390x.whl", hash = "sha256:d8d07d102f17b68966e2de0e07bfd6e139c7c02ef06d3a0f8d2f0f055e13bb76"},
-    {file = "yarl-1.6.3-cp36-cp36m-manylinux2014_x86_64.whl", hash = "sha256:15263c3b0b47968c1d90daa89f21fcc889bb4b1aac5555580d74565de6836366"},
-    {file = "yarl-1.6.3-cp36-cp36m-win32.whl", hash = "sha256:b5dfc9a40c198334f4f3f55880ecf910adebdcb2a0b9a9c23c9345faa9185721"},
-    {file = "yarl-1.6.3-cp36-cp36m-win_amd64.whl", hash = "sha256:b2e9a456c121e26d13c29251f8267541bd75e6a1ccf9e859179701c36a078643"},
-    {file = "yarl-1.6.3-cp37-cp37m-macosx_10_14_x86_64.whl", hash = "sha256:ce3beb46a72d9f2190f9e1027886bfc513702d748047b548b05dab7dfb584d2e"},
-    {file = "yarl-1.6.3-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:2ce4c621d21326a4a5500c25031e102af589edb50c09b321049e388b3934eec3"},
-    {file = "yarl-1.6.3-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:d26608cf178efb8faa5ff0f2d2e77c208f471c5a3709e577a7b3fd0445703ac8"},
-    {file = "yarl-1.6.3-cp37-cp37m-manylinux2014_i686.whl", hash = "sha256:4c5bcfc3ed226bf6419f7a33982fb4b8ec2e45785a0561eb99274ebbf09fdd6a"},
-    {file = "yarl-1.6.3-cp37-cp37m-manylinux2014_ppc64le.whl", hash = "sha256:4736eaee5626db8d9cda9eb5282028cc834e2aeb194e0d8b50217d707e98bb5c"},
-    {file = "yarl-1.6.3-cp37-cp37m-manylinux2014_s390x.whl", hash = "sha256:68dc568889b1c13f1e4745c96b931cc94fdd0defe92a72c2b8ce01091b22e35f"},
-    {file = "yarl-1.6.3-cp37-cp37m-manylinux2014_x86_64.whl", hash = "sha256:7356644cbed76119d0b6bd32ffba704d30d747e0c217109d7979a7bc36c4d970"},
-    {file = "yarl-1.6.3-cp37-cp37m-win32.whl", hash = "sha256:00d7ad91b6583602eb9c1d085a2cf281ada267e9a197e8b7cae487dadbfa293e"},
-    {file = "yarl-1.6.3-cp37-cp37m-win_amd64.whl", hash = "sha256:69ee97c71fee1f63d04c945f56d5d726483c4762845400a6795a3b75d56b6c50"},
-    {file = "yarl-1.6.3-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:e46fba844f4895b36f4c398c5af062a9808d1f26b2999c58909517384d5deda2"},
-    {file = "yarl-1.6.3-cp38-cp38-manylinux1_i686.whl", hash = "sha256:31ede6e8c4329fb81c86706ba8f6bf661a924b53ba191b27aa5fcee5714d18ec"},
-    {file = "yarl-1.6.3-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:fcbb48a93e8699eae920f8d92f7160c03567b421bc17362a9ffbbd706a816f71"},
-    {file = "yarl-1.6.3-cp38-cp38-manylinux2014_i686.whl", hash = "sha256:72a660bdd24497e3e84f5519e57a9ee9220b6f3ac4d45056961bf22838ce20cc"},
-    {file = "yarl-1.6.3-cp38-cp38-manylinux2014_ppc64le.whl", hash = "sha256:324ba3d3c6fee56e2e0b0d09bf5c73824b9f08234339d2b788af65e60040c959"},
-    {file = "yarl-1.6.3-cp38-cp38-manylinux2014_s390x.whl", hash = "sha256:e6b5460dc5ad42ad2b36cca524491dfcaffbfd9c8df50508bddc354e787b8dc2"},
-    {file = "yarl-1.6.3-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:6d6283d8e0631b617edf0fd726353cb76630b83a089a40933043894e7f6721e2"},
-    {file = "yarl-1.6.3-cp38-cp38-win32.whl", hash = "sha256:9ede61b0854e267fd565e7527e2f2eb3ef8858b301319be0604177690e1a3896"},
-    {file = "yarl-1.6.3-cp38-cp38-win_amd64.whl", hash = "sha256:f0b059678fd549c66b89bed03efcabb009075bd131c248ecdf087bdb6faba24a"},
-    {file = "yarl-1.6.3-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:329412812ecfc94a57cd37c9d547579510a9e83c516bc069470db5f75684629e"},
-    {file = "yarl-1.6.3-cp39-cp39-manylinux1_i686.whl", hash = "sha256:c49ff66d479d38ab863c50f7bb27dee97c6627c5fe60697de15529da9c3de724"},
-    {file = "yarl-1.6.3-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:f040bcc6725c821a4c0665f3aa96a4d0805a7aaf2caf266d256b8ed71b9f041c"},
-    {file = "yarl-1.6.3-cp39-cp39-manylinux2014_i686.whl", hash = "sha256:d5c32c82990e4ac4d8150fd7652b972216b204de4e83a122546dce571c1bdf25"},
-    {file = "yarl-1.6.3-cp39-cp39-manylinux2014_ppc64le.whl", hash = "sha256:d597767fcd2c3dc49d6eea360c458b65643d1e4dbed91361cf5e36e53c1f8c96"},
-    {file = "yarl-1.6.3-cp39-cp39-manylinux2014_s390x.whl", hash = "sha256:8aa3decd5e0e852dc68335abf5478a518b41bf2ab2f330fe44916399efedfae0"},
-    {file = "yarl-1.6.3-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:73494d5b71099ae8cb8754f1df131c11d433b387efab7b51849e7e1e851f07a4"},
-    {file = "yarl-1.6.3-cp39-cp39-win32.whl", hash = "sha256:5b883e458058f8d6099e4420f0cc2567989032b5f34b271c0827de9f1079a424"},
-    {file = "yarl-1.6.3-cp39-cp39-win_amd64.whl", hash = "sha256:4953fb0b4fdb7e08b2f3b3be80a00d28c5c8a2056bb066169de00e6501b986b6"},
-    {file = "yarl-1.6.3.tar.gz", hash = "sha256:8a9066529240171b68893d60dca86a763eae2139dd42f42106b03cf4b426bf10"},
+    {file = "yarl-1.7.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e35d8230e4b08d86ea65c32450533b906a8267a87b873f2954adeaecede85169"},
+    {file = "yarl-1.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:eb4b3f277880c314e47720b4b6bb2c85114ab3c04c5442c9bc7006b3787904d8"},
+    {file = "yarl-1.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7015dcedb91d90a138eebdc7e432aec8966e0147ab2a55f2df27b1904fa7291"},
+    {file = "yarl-1.7.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb3e478175e15e00d659fb0354a6a8db71a7811a2a5052aed98048bc972e5d2b"},
+    {file = "yarl-1.7.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8b8c409aa3a7966647e7c1c524846b362a6bcbbe120bf8a176431f940d2b9a2e"},
+    {file = "yarl-1.7.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b22ea41c7e98170474a01e3eded1377d46b2dfaef45888a0005c683eaaa49285"},
+    {file = "yarl-1.7.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a7dfc46add4cfe5578013dbc4127893edc69fe19132d2836ff2f6e49edc5ecd6"},
+    {file = "yarl-1.7.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:82ff6f85f67500a4f74885d81659cd270eb24dfe692fe44e622b8a2fd57e7279"},
+    {file = "yarl-1.7.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:f3cd2158b2ed0fb25c6811adfdcc47224efe075f2d68a750071dacc03a7a66e4"},
+    {file = "yarl-1.7.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:59c0f13f9592820c51280d1cf811294d753e4a18baf90f0139d1dc93d4b6fc5f"},
+    {file = "yarl-1.7.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:7f7655ad83d1a8afa48435a449bf2f3009293da1604f5dd95b5ddcf5f673bd69"},
+    {file = "yarl-1.7.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:aa9f0d9b62d15182341b3e9816582f46182cab91c1a57b2d308b9a3c4e2c4f78"},
+    {file = "yarl-1.7.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fdd1b90c225a653b1bd1c0cae8edf1957892b9a09c8bf7ee6321eeb8208eac0f"},
+    {file = "yarl-1.7.0-cp310-cp310-win32.whl", hash = "sha256:7c8d0bb76eabc5299db203e952ec55f8f4c53f08e0df4285aac8c92bd9e12675"},
+    {file = "yarl-1.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:622a36fa779efb4ff9eff5fe52730ff17521431379851a31e040958fc251670c"},
+    {file = "yarl-1.7.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:3d461b7a8e139b9e4b41f62eb417ffa0b98d1c46d4caf14c845e6a3b349c0bb1"},
+    {file = "yarl-1.7.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81cfacdd1e40bc931b5519499342efa388d24d262c30a3d31187bfa04f4a7001"},
+    {file = "yarl-1.7.0-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:821b978f2152be7695d4331ef0621d207aedf9bbd591ba23a63412a3efc29a01"},
+    {file = "yarl-1.7.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b64bd24c8c9a487f4a12260dc26732bf41028816dbf0c458f17864fbebdb3131"},
+    {file = "yarl-1.7.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:98c9ddb92b60a83c21be42c776d3d9d5ec632a762a094c41bda37b7dfbd2cd83"},
+    {file = "yarl-1.7.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a532d75ca74431c053a88a802e161fb3d651b8bf5821a3440bc3616e38754583"},
+    {file = "yarl-1.7.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:053e09817eafb892e94e172d05406c1b3a22a93bc68f6eff5198363a3d764459"},
+    {file = "yarl-1.7.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:98c51f02d542945d306c8e934aa2c1e66ba5e9c1c86b5bf37f3a51c8a747067e"},
+    {file = "yarl-1.7.0-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:15ec41a5a5fdb7bace6d7b16701f9440007a82734f69127c0fbf6d87e10f4a1e"},
+    {file = "yarl-1.7.0-cp36-cp36m-musllinux_1_1_s390x.whl", hash = "sha256:a7f08819dba1e1255d6991ed37448a1bf4b1352c004bcd899b9da0c47958513d"},
+    {file = "yarl-1.7.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:8e3ffab21db0542ffd1887f3b9575ddd58961f2cf61429cb6458afc00c4581e0"},
+    {file = "yarl-1.7.0-cp36-cp36m-win32.whl", hash = "sha256:50127634f519b2956005891507e3aa4ac345f66a7ea7bbc2d7dcba7401f41898"},
+    {file = "yarl-1.7.0-cp36-cp36m-win_amd64.whl", hash = "sha256:36ec44f15193f6d5288d42ebb8e751b967ebdfb72d6830983838d45ab18edb4f"},
+    {file = "yarl-1.7.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:ec1b5a25a25c880c976d0bb3d107def085bb08dbb3db7f4442e0a2b980359d24"},
+    {file = "yarl-1.7.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b36f5a63c891f813c6f04ef19675b382efc190fd5ce7e10ab19386d2548bca06"},
+    {file = "yarl-1.7.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:38173b8c3a29945e7ecade9a3f6ff39581eee8201338ee6a2c8882db5df3e806"},
+    {file = "yarl-1.7.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ba402f32184f0b405fb281b93bd0d8ab7e3257735b57b62a6ed2e94cdf4fe50"},
+    {file = "yarl-1.7.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:be52bc5208d767cdd8308a9e93059b3b36d1e048fecbea0e0346d0d24a76adc0"},
+    {file = "yarl-1.7.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:08c2044a956f4ef30405f2f433ce77f1f57c2c773bf81ae43201917831044d5a"},
+    {file = "yarl-1.7.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:484d61c047c45670ef5967653a1d0783e232c54bf9dd786a7737036828fa8d54"},
+    {file = "yarl-1.7.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b7de92a4af85cfcaf4081f8aa6165b1d63ee5de150af3ee85f954145f93105a7"},
+    {file = "yarl-1.7.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:376e41775aab79c5575534924a386c8e0f1a5d91db69fc6133fd27a489bcaf10"},
+    {file = "yarl-1.7.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:8a8b10d0e7bac154f959b709fcea593cda527b234119311eb950096653816a86"},
+    {file = "yarl-1.7.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:f46cd4c43e6175030e2a56def8f1d83b64e6706eeb2bb9ab0ef4756f65eab23f"},
+    {file = "yarl-1.7.0-cp37-cp37m-win32.whl", hash = "sha256:b28cfb46140efe1a6092b8c5c4994a1fe70dc83c38fbcea4992401e0c6fb9cce"},
+    {file = "yarl-1.7.0-cp37-cp37m-win_amd64.whl", hash = "sha256:9624154ec9c02a776802da1086eed7f5034bd1971977f5146233869c2ac80297"},
+    {file = "yarl-1.7.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:69945d13e1bbf81784a9bc48824feb9cd66491e6a503d4e83f6cd7c7cc861361"},
+    {file = "yarl-1.7.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:46a742ed9e363bd01be64160ce7520e92e11989bd4cb224403cfd31c101cc83d"},
+    {file = "yarl-1.7.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cb4ff1ac7cb4500f43581b3f4cbd627d702143aa6be1fdc1fa3ebffaf4dc1be5"},
+    {file = "yarl-1.7.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ad51e17cd65ea3debb0e10f0120cf8dd987c741fe423ed2285087368090b33d"},
+    {file = "yarl-1.7.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7e37786ea89a5d3ffbbf318ea9790926f8dfda83858544f128553c347ad143c6"},
+    {file = "yarl-1.7.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c63c1e208f800daad71715786bfeb1cecdc595d87e2e9b1cd234fd6e597fd71d"},
+    {file = "yarl-1.7.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:91cbe24300c11835ef186436363352b3257db7af165e0a767f4f17aa25761388"},
+    {file = "yarl-1.7.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e510dbec7c59d32eaa61ffa48173d5e3d7170a67f4a03e8f5e2e9e3971aca622"},
+    {file = "yarl-1.7.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:3def6e681cc02397e5d8141ee97b41d02932b2bcf0fb34532ad62855eab7c60e"},
+    {file = "yarl-1.7.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:263c81b94e6431942b27f6f671fa62f430a0a5c14bb255f2ab69eeb9b2b66ff7"},
+    {file = "yarl-1.7.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:e78c91faefe88d601ddd16e3882918dbde20577a2438e2320f8239c8b7507b8f"},
+    {file = "yarl-1.7.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:22b2430c49713bfb2f0a0dd4a8d7aab218b28476ba86fd1c78ad8899462cbcf2"},
+    {file = "yarl-1.7.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2e7ad9db939082f5d0b9269cfd92c025cb8f2fbbb1f1b9dc5a393c639db5bd92"},
+    {file = "yarl-1.7.0-cp38-cp38-win32.whl", hash = "sha256:3a31e4a8dcb1beaf167b7e7af61b88cb961b220db8d3ba1c839723630e57eef7"},
+    {file = "yarl-1.7.0-cp38-cp38-win_amd64.whl", hash = "sha256:d579957439933d752358c6a300c93110f84aae67b63dd0c19dde6ecbf4056f6b"},
+    {file = "yarl-1.7.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:87721b549505a546eb003252185103b5ec8147de6d3ad3714d148a5a67b6fe53"},
+    {file = "yarl-1.7.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a1fa866fa24d9f4108f9e58ea8a2135655419885cdb443e36b39a346e1181532"},
+    {file = "yarl-1.7.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1d3b8449dfedfe94eaff2b77954258b09b24949f6818dfa444b05dbb05ae1b7e"},
+    {file = "yarl-1.7.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:db2372e350794ce8b9f810feb094c606b7e0e4aa6807141ac4fadfe5ddd75bb0"},
+    {file = "yarl-1.7.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a06d9d0b9a97fa99b84fee71d9dd11e69e21ac8a27229089f07b5e5e50e8d63c"},
+    {file = "yarl-1.7.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a3455c2456d6307bcfa80bc1157b8603f7d93573291f5bdc7144489ca0df4628"},
+    {file = "yarl-1.7.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:d30d67e3486aea61bb2cbf7cf81385364c2e4f7ce7469a76ed72af76a5cdfe6b"},
+    {file = "yarl-1.7.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c18a4b286e8d780c3a40c31d7b79836aa93b720f71d5743f20c08b7e049ca073"},
+    {file = "yarl-1.7.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d54c925396e7891666cabc0199366ca55b27d003393465acef63fd29b8b7aa92"},
+    {file = "yarl-1.7.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:64773840952de17851a1c7346ad7f71688c77e74248d1f0bc230e96680f84028"},
+    {file = "yarl-1.7.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:acbf1756d9dc7cd0ae943d883be72e84e04396f6c2ff93a6ddeca929d562039f"},
+    {file = "yarl-1.7.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:2e48f27936aa838939c798f466c851ba4ae79e347e8dfce43b009c64b930df12"},
+    {file = "yarl-1.7.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:1beef4734ca1ad40a9d8c6b20a76ab46e3a2ed09f38561f01e4aa2ea82cafcef"},
+    {file = "yarl-1.7.0-cp39-cp39-win32.whl", hash = "sha256:8ee78c9a5f3c642219d4607680a4693b59239c27a3aa608b64ef79ddc9698039"},
+    {file = "yarl-1.7.0-cp39-cp39-win_amd64.whl", hash = "sha256:d750503682605088a14d29a4701548c15c510da4f13c8b17409c4097d5b04c52"},
+    {file = "yarl-1.7.0.tar.gz", hash = "sha256:8e7ebaf62e19c2feb097ffb7c94deb0f0c9fab52590784c8cd679d30ab009162"},
 ]
 zipp = [
     {file = "zipp-3.6.0-py3-none-any.whl", hash = "sha256:9fe5ea21568a0a70e50f273397638d39b03353731e6cbbb3fd8502a33fec40bc"},
diff --git a/pyproject.toml b/pyproject.toml
index 69364c5f6e5f..0be486aa0e94 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -122,6 +122,7 @@ joblib = ">=0.15.1,<1.1.0"
 sentry-sdk = ">=0.17.0,<1.3.0"
 aio-pika = "^6.7.1"
 pyTelegramBotAPI = "^3.7.3"
+tarsafe = "^0.0.3"
 
 [tool.poetry.dev-dependencies]
 pytest-cov = "^2.10.0"
diff --git a/rasa/model.py b/rasa/model.py
index 78be4034060c..21ff2b14de02 100644
--- a/rasa/model.py
+++ b/rasa/model.py
@@ -222,13 +222,14 @@ def unpack_model(
 
     """
     import tarfile
+    from tarsafe import TarSafe
 
     if working_directory is None:
         working_directory = tempfile.mkdtemp()
 
     # All files are in a subdirectory.
     try:
-        with tarfile.open(model_file, mode="r:gz") as tar:
+        with TarSafe.open(model_file, mode="r:gz") as tar:
             tar.extractall(working_directory)
             logger.debug(f"Extracted model to '{working_directory}'.")
     except (tarfile.TarError, ValueError) as e:
diff --git a/rasa/nlu/persistor.py b/rasa/nlu/persistor.py
index 9ba50b8e0edd..9f777aeb659b 100644
--- a/rasa/nlu/persistor.py
+++ b/rasa/nlu/persistor.py
@@ -2,7 +2,7 @@
 import logging
 import os
 import shutil
-import tarfile
+from tarsafe import TarSafe
 from typing import Optional, Text, Tuple, TYPE_CHECKING
 
 import rasa.shared.utils.common
@@ -103,7 +103,7 @@ def _tar_name(model_name: Text, include_extension: bool = True) -> Text:
     @staticmethod
     def _decompress(compressed_path: Text, target_path: Text) -> None:
 
-        with tarfile.open(compressed_path, "r:gz") as tar:
+        with TarSafe.open(compressed_path, "r:gz") as tar:
             tar.extractall(target_path)  # target dir will be created if it not exists
 
 
diff --git a/rasa/utils/io.py b/rasa/utils/io.py
index 65aa20697591..c0831be91d23 100644
--- a/rasa/utils/io.py
+++ b/rasa/utils/io.py
@@ -3,6 +3,7 @@
 import os
 import pickle
 import tarfile
+from tarsafe import TarSafe
 import tempfile
 import warnings
 import zipfile
@@ -87,7 +88,7 @@ def unarchive(byte_array: bytes, directory: Text) -> Text:
     Tries to use tar first to unpack, if that fails, zip will be used."""
 
     try:
-        tar = tarfile.open(fileobj=IOReader(byte_array))
+        tar = TarSafe.open(fileobj=IOReader(byte_array))
         tar.extractall(directory)
         tar.close()
         return directory",
"url": "https://github.com/RasaHQ/rasa/commit/1b6b502f52d73b4f8cd1959ce724b8ad0eb33989.patch"
}
] | null |
PYSEC-2020-219
| null |
[
{
"commit_message": "[PATCH] Prevent unauthorized users managing others' device This adds a permissions check on the device list and delete views. When a user has the 'change_user' permission, they are allowed to view and delete other users' 2FA devices. If they don't have the permission, they are only allowed to manage their own devices. src/wagtail_2fa/views.py | 21 +++++++++++ tests/test_views.py | 75 ++++++++++++++++++++++++++++++++++++++-- 2 files changed, 94 insertions(+), 2 deletions(-)",
"patch_text_b64": "From ac23550d33b7436e90e3beea904647907eba5b74 Mon Sep 17 00:00:00 2001
From: Nicole Nisters <n.nisters@labdigital.nl>
Date: Mon, 10 Feb 2020 14:58:24 +0100
Subject: [PATCH] Prevent unauthorized users managing others' device

This adds a permissions check on the device list and delete views. When
a user has the 'change_user' permission, they are allowed to view
and delete other users' 2FA devices. If they don't have the
permission, they are only allowed to manage their own devices.
---
 src/wagtail_2fa/views.py | 21 +++++++++++
 tests/test_views.py      | 75 ++++++++++++++++++++++++++++++++++++++--
 2 files changed, 94 insertions(+), 2 deletions(-)

diff --git a/src/wagtail_2fa/views.py b/src/wagtail_2fa/views.py
index 9ec004f..463b2bb 100644
--- a/src/wagtail_2fa/views.py
+++ b/src/wagtail_2fa/views.py
@@ -1,3 +1,4 @@
+from django.core.exceptions import PermissionDenied
 import qrcode
 import qrcode.image.svg
 from django.conf import settings
@@ -75,6 +76,15 @@ def get_context_data(self, **kwargs):
         context['user_id'] = int(self.kwargs['user_id'])
         return context
 
+    def dispatch(self, request, *args, **kwargs):
+        if (int(self.kwargs["user_id"]) == request.user.pk or
+                request.user.has_perm("user.change_user")):
+            if not self.user_allowed(request.user):
+                return self.handle_no_permission(request)
+
+            return super(OtpRequiredMixin, self).dispatch(request, *args, **kwargs)
+        raise PermissionDenied
+
 
 class DeviceCreateView(OtpRequiredMixin, FormView):
     form_class = forms.DeviceForm
@@ -134,6 +144,17 @@ def get_queryset(self):
     def get_success_url(self):
         return reverse('wagtail_2fa_device_list', kwargs={'user_id': self.request.POST.get('user_id')})
 
+    def dispatch(self, request, *args, **kwargs):
+        device = TOTPDevice.objects.get(**self.kwargs)
+
+        if device.user.pk == request.user.pk or request.user.has_perm("user.change_user"):
+            if not self.user_allowed(request.user):
+                return self.handle_no_permission(request)
+
+            return super(OtpRequiredMixin, self).dispatch(request, *args, **kwargs)
+
+        raise PermissionDenied
+
 
 class DeviceQRCodeView(OtpRequiredMixin, View):
     # require OTP if configured
diff --git a/tests/test_views.py b/tests/test_views.py
index 3d8c921..af13b39 100644
--- a/tests/test_views.py
+++ b/tests/test_views.py
@@ -1,12 +1,16 @@
+import pytest
+from django.core.exceptions import PermissionDenied
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
 from django.test import override_settings
 from unittest.mock import patch
+from django.http.response import Http404
 
 from django.contrib.auth import get_user_model
 from django.urls import reverse
 from django_otp import DEVICE_ID_SESSION_KEY
 from django_otp.plugins.otp_totp.models import TOTPDevice
-from wagtail_2fa.views import DeviceListView
-
+from wagtail_2fa.views import DeviceListView, DeviceDeleteView, DeviceUpdateView
 
 def test_device_list_view(admin_client, admin_user, django_assert_num_queries):
     with override_settings(WAGTAIL_2FA_REQUIRED=True):
@@ -129,3 +133,70 @@ def test_delete_user_device_unauthorized(client, user, monkeypatch):
         })
         assert response.status_code == 302
         assert TOTPDevice.objects.all().count() == 1
+
+
+class TestViewsChangeUserPermission:
+    """Test suite which ensures that:
+        - users without the change_user permission cannot manage other users' 2FA devices
+        - users can manage their own devices
+    """
+
+    def test_verified_user_has_no_change_user_perm(self, verified_user):
+        """Sanity check."""
+        assert not verified_user.has_perm("user.change_user")
+
+    def test_device_list_view_for_own_user_returns_200(self, verified_user, rf):
+        with override_settings(WAGTAIL_2FA_REQUIRED=True):
+            request = rf.get('foo')
+            request.user = verified_user
+
+            response = DeviceListView.as_view()(request, user_id=verified_user.id)
+            assert response.status_code == 200
+
+    def test_device_list_view_for_other_user_raises_error(self, user, verified_user, rf):
+        with override_settings(WAGTAIL_2FA_REQUIRED=True):
+            request = rf.get('foo')
+            request.user = verified_user
+
+            with pytest.raises(PermissionDenied):
+                response = DeviceListView.as_view()(request, user_id=user.id)
+
+    def test_device_delete_view_for_own_user_returns_200(self, verified_user, rf):
+        with override_settings(WAGTAIL_2FA_REQUIRED=True):
+            device = TOTPDevice.objects.devices_for_user(verified_user, confirmed=True).first()
+            request = rf.get('foo')
+            request.user = verified_user
+
+            response = DeviceDeleteView.as_view()(request, pk=device.id)
+            assert response.status_code == 200
+
+    def test_device_delete_view_for_other_user_raises_error(self, user, verified_user, rf):
+        with override_settings(WAGTAIL_2FA_REQUIRED=True):
+            other_device = TOTPDevice.objects.create(name='Initial', user=user, confirmed=True)
+
+            device = TOTPDevice.objects.devices_for_user(verified_user, confirmed=True).first()
+            request = rf.get('foo')
+            request.user = verified_user
+
+            with pytest.raises(PermissionDenied):
+                response = DeviceDeleteView.as_view()(request, pk=other_device.id)
+
+    def test_device_update_view_for_own_user_returns_200(self, verified_user, rf):
+        with override_settings(WAGTAIL_2FA_REQUIRED=True):
+            device = TOTPDevice.objects.devices_for_user(verified_user, confirmed=True).first()
+            request = rf.get('foo')
+            request.user = verified_user
+
+            response = DeviceUpdateView.as_view()(request, pk=device.id)
+            assert response.status_code == 200
+
+    def test_device_update_view_for_other_user_raises_error(self, user, verified_user, rf):
+        with override_settings(WAGTAIL_2FA_REQUIRED=True):
+            other_device = TOTPDevice.objects.create(name='Initial', user=user, confirmed=True)
+
+            device = TOTPDevice.objects.devices_for_user(verified_user, confirmed=True).first()
+            request = rf.get('foo')
+            request.user = verified_user
+
+            with pytest.raises(Http404):
+                response = DeviceUpdateView.as_view()(request, pk=other_device.id)",
"url": "https://github.com/labd/wagtail-2fa/commit/ac23550d33b7436e90e3beea904647907eba5b74.patch"
}
] | null |
|
GHSA-rqg5-w7gw-xqvq
| null |
[
{
"commit_message": "[PATCH] [api] support binary package upload for the admin src/api/app/controllers/build_controller.rb | 31 +++++++++---------- .../test/functional/build_controller_test.rb | 26 ++++++++++++++++ 2 files changed, 40 insertions(+), 17 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/openSUSE/open-build-service/commit/5281e4bff9df31f1f91e22a0d1e9086b93b23d7e.patch"
}
] | null |
|
GHSA-wp68-xrfg-xvq4
|
Cockpit Arbitrary File Upload
| null |
[
{
"commit_message": "[PATCH] add additional security check for uploading files modules/Assets/bootstrap.php | 2 +- modules/Finder/Controller/Finder.php | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/Cockpit-HQ/Cockpit/commit/984ef9ad270357b843af63c81db95178eae42cae.patch"
},
{
"commit_message": "[PATCH] Prevent uploading php files in assets manager CHANGELOG.md | 4 ++++ modules/Assets/bootstrap.php | 5 +++++ 2 files changed, 9 insertions(+)",
"patch_text_b64": "RnJvbSBiZWNjYTgwNmM3MDcxZWNjNzMyNTIxYmI1YWQwYmI5YzY0Mjk5NTkyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBcnR1ciBIZWluemUgPGFydHVyQGFnZW50ZWpvLmNvbT4KRGF0ZTogRnJpLCAxMCBNYXIgMjAyMyAxMToyMzo1MSArMDEwMApTdWJqZWN0OiBbUEFUQ0hdIFByZXZlbnQgdXBsb2FkaW5nIHBocCBmaWxlcyBpbiBhc3NldHMgbWFuYWdlcgoKLS0tCiBDSEFOR0VMT0cubWQgICAgICAgICAgICAgICAgIHwgNCArKysrCiBtb2R1bGVzL0Fzc2V0cy9ib290c3RyYXAucGhwIHwgNSArKysrKwogMiBmaWxlcyBjaGFuZ2VkLCA5IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9DSEFOR0VMT0cubWQgYi9DSEFOR0VMT0cubWQKaW5kZXggM2UzNTAxOWQxLi5iZjg3ZGNmMmUgMTAwNjQ0Ci0tLSBhL0NIQU5HRUxPRy5tZAorKysgYi9DSEFOR0VMT0cubWQKQEAgLTEsNSArMSw5IEBACiAjIFJlbGVhc2UgTm90ZXMKIAorIyMgV0lQCisKKy0gUHJldmVudCB1cGxvYWRpbmcgcGhwIGZpbGVzIGluIGFzc2V0cyBtYW5hZ2VyCisKICMjIDIuNC4wICgyMDIzLTAzLTA4KQogCiAtIEFkZCBhZGRpdGlvbmFsIHNlY3VyaXR5IGNoZWNrIGVkaXRpbmcgcGhwIGZpbGVzIGluIGZpbmRlcgpkaWZmIC0tZ2l0IGEvbW9kdWxlcy9Bc3NldHMvYm9vdHN0cmFwLnBocCBiL21vZHVsZXMvQXNzZXRzL2Jvb3RzdHJhcC5waHAKaW5kZXggMTg1YjJiYTQ5Li5lMWM1MjlmNGMgMTAwNjQ0Ci0tLSBhL21vZHVsZXMvQXNzZXRzL2Jvb3RzdHJhcC5waHAKKysrIGIvbW9kdWxlcy9Bc3NldHMvYm9vdHN0cmFwLnBocApAQCAtODAsNiArODAsMTEgQEAKICAgICAgICAgICAgICAgICAkX2lzQWxsb3dlZCA9ICRhbGxvd2VkID09PSB0cnVlID8gdHJ1ZSA6IHByZWdfbWF0Y2goIi9cLih7JGFsbG93ZWR9KSQvaSIsICRfZmlsZSk7CiAgICAgICAgICAgICAgICAgJF9zaXplQWxsb3dlZCA9ICRtYXhfc2l6ZSA/IGZpbGVzaXplKCRmaWxlc1sndG1wX25hbWUnXVskaV0pIDwgJG1heF9zaXplIDogdHJ1ZTsKIAorICAgICAgICAgICAgICAgIC8vIHByZXZlbnQgdXBsb2FkaW5nIHBocCBmaWxlcworICAgICAgICAgICAgICAgIGlmICgkX2lzQWxsb3dlZCAmJiBwYXRoaW5mbygkX2ZpbGUsIFBBVEhJTkZPX0VYVEVOU0lPTikgPT09ICdwaHAnKSB7CisgICAgICAgICAgICAgICAgICAgICRfaXNBbGxvd2VkID0gZmFsc2U7CisgICAgICAgICAgICAgICAgfQorCiAgICAgICAgICAgICAgICAgaWYgKCEkZmlsZXNbJ2Vycm9yJ11bJGldICYmICRfaXNBbGxvd2VkICYmICRfc2l6ZUFsbG93ZWQgJiYgbW92ZV91cGxvYWRlZF9maWxlKCRmaWxlc1sndG1wX25hbWUnXVskaV0sICRfZmlsZSkpIHsKIAogICAgICAgICAgICAgICAgICAgICAkX2ZpbGVzW10gICA9ICRfZmlsZTs=",
"url": "https://github.com/Cockpit-HQ/Cockpit/commit/becca806c7071ecc732521bb5ad0bb9c64299592.patch"
}
] | null |
CVE-2021-30022
|
There is a integer overflow in media_tools/av_parsers.c in the gf_avc_read_pps_bs_internal in GPAC from 0.5.2 to 1.0.1. pps_id may be a negative number, so it will not return. However, avc->pps only has 255 unit, so there is an overflow, which results a crash.
|
[
{
"commit_message": "[PATCH] add safety in avc/hevc/vvc sps/pps/vps ID check - cf #1720 #1721 #1722 src/media_tools/av_parsers.c | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/gpac/gpac/commit/51cdb67ff7c5f1242ac58c5aa603ceaf1793b788.patch"
}
] |
n/a
|
|
CVE-2015-4410
|
The Moped::BSON::ObjecId.legal? method in rubygem-moped before commit dd5a7c14b5d2e466f7875d079af71ad19774609b allows remote attackers to cause a denial of service (worker resource consumption) or perform a cross-site scripting (XSS) attack via a crafted string.
|
[
{
"commit_message": "[PATCH] Merge Replica Set Refactor * Removes Server, and Socket; replaced with Node, and Connection. Replica sets are now much more robustly supported, including failover and discovery. * Refactors specs. Internal APIs are now tested with integration specs through the public APIs. * More documentation. .gitignore | 1 + README.md | 160 ++++++ lib/moped.rb | 6 +- lib/moped/bson/object_id.rb | 82 +-- lib/moped/cluster.rb | 258 ++++----- lib/moped/collection.rb | 4 +- lib/moped/connection.rb | 95 ++++ lib/moped/cursor.rb | 57 +- lib/moped/database.rb | 20 +- lib/moped/errors.rb | 42 +- lib/moped/node.rb | 334 +++++++++++ lib/moped/protocol/command.rb | 5 +- lib/moped/query.rb | 41 +- lib/moped/server.rb | 73 --- lib/moped/session.rb | 96 +--- lib/moped/session/context.rb | 105 ++++ lib/moped/socket.rb | 201 ------- lib/moped/threaded.rb | 32 ++ perf/cases.rb | 16 +- .../protocol/authentication_spec.rb | 103 ---- spec/integration/protocol/protocol_spec.rb | 58 -- spec/integration_spec.rb | 176 ------ spec/moped/bson/object_id_spec.rb | 34 +- spec/moped/cluster_spec.rb | 477 +++++++--------- spec/moped/collection_spec.rb | 91 +-- spec/moped/cursor_spec.rb | 237 -------- spec/moped/database_spec.rb | 86 --- spec/moped/errors_spec.rb | 91 --- spec/moped/indexes_spec.rb | 127 +---- spec/moped/logging_spec.rb | 83 --- spec/moped/node_spec.rb | 57 ++ spec/moped/query_spec.rb | 469 ++++++++------- spec/moped/server_spec.rb | 80 --- spec/moped/session_spec.rb | 535 +----------------- spec/moped/socket_spec.rb | 462 --------------- spec/moped_spec.rb | 1 - spec/replset_spec.rb | 106 ---- spec/spec_helper.rb | 21 +- spec/support/mock_connection.rb | 39 -- spec/support/mongohq.rb | 61 ++ spec/support/replica_set_simulator.rb | 306 ++++++++++ spec/support/stats.rb | 51 ++ 42 files changed, 2057 insertions(+), 3322 deletions(-) create mode 100644 lib/moped/connection.rb create mode 100644 lib/moped/node.rb delete mode 100644 lib/moped/server.rb create mode 100644 lib/moped/session/context.rb delete mode 100644 lib/moped/socket.rb create mode 100644 lib/moped/threaded.rb delete mode 100644 spec/integration/protocol/authentication_spec.rb delete mode 100644 spec/integration/protocol/protocol_spec.rb delete mode 100644 spec/integration_spec.rb delete mode 100644 spec/moped/cursor_spec.rb delete mode 100644 spec/moped/database_spec.rb delete mode 100644 spec/moped/errors_spec.rb delete mode 100644 spec/moped/logging_spec.rb create mode 100644 spec/moped/node_spec.rb delete mode 100644 spec/moped/server_spec.rb delete mode 100644 spec/moped/socket_spec.rb delete mode 100644 spec/moped_spec.rb delete mode 100644 spec/replset_spec.rb delete mode 100644 spec/support/mock_connection.rb create mode 100644 spec/support/mongohq.rb create mode 100644 spec/support/replica_set_simulator.rb create mode 100644 spec/support/stats.rb",
"patch_text_b64": "From dd5a7c14b5d2e466f7875d079af71ad19774609b Mon Sep 17 00:00:00 2001
From: Bernerd Schaefer <bj.schaefer@gmail.com>
Date: Tue, 17 Apr 2012 14:15:09 +0200
Subject: [PATCH] Merge Replica Set Refactor

* Removes Server, and Socket; replaced with Node, and Connection.

  Replica sets are now much more robustly supported, including failover
  and discovery.

* Refactors specs.

  Internal APIs are now tested with integration specs through the public
  APIs.

* More documentation.
---
 .gitignore                                    |   1 +
 README.md                                     | 160 ++++++
 lib/moped.rb                                  |   6 +-
 lib/moped/bson/object_id.rb                   |  82 +--
 lib/moped/cluster.rb                          | 258 ++++-----
 lib/moped/collection.rb                       |   4 +-
 lib/moped/connection.rb                       |  95 ++++
 lib/moped/cursor.rb                           |  57 +-
 lib/moped/database.rb                         |  20 +-
 lib/moped/errors.rb                           |  42 +-
 lib/moped/node.rb                             | 334 +++++++++++
 lib/moped/protocol/command.rb                 |   5 +-
 lib/moped/query.rb                            |  41 +-
 lib/moped/server.rb                           |  73 ---
 lib/moped/session.rb                          |  96 +---
 lib/moped/session/context.rb                  | 105 ++++
 lib/moped/socket.rb                           | 201 -------
 lib/moped/threaded.rb                         |  32 ++
 perf/cases.rb                                 |  16 +-
 .../protocol/authentication_spec.rb           | 103 ----
 spec/integration/protocol/protocol_spec.rb    |  58 --
 spec/integration_spec.rb                      | 176 ------
 spec/moped/bson/object_id_spec.rb             |  34 +-
 spec/moped/cluster_spec.rb                    | 477 +++++++---------
 spec/moped/collection_spec.rb                 |  91 +--
 spec/moped/cursor_spec.rb                     | 237 --------
 spec/moped/database_spec.rb                   |  86 ---
 spec/moped/errors_spec.rb                     |  91 ---
 spec/moped/indexes_spec.rb                    | 127 +----
 spec/moped/logging_spec.rb                    |  83 ---
 spec/moped/node_spec.rb                       |  57 ++
 spec/moped/query_spec.rb                      | 469 ++++++++-------
 spec/moped/server_spec.rb                     |  80 ---
 spec/moped/session_spec.rb                    | 535 +-----------------
 spec/moped/socket_spec.rb                     | 462 ---------------
 spec/moped_spec.rb                            |   1 -
 spec/replset_spec.rb                          | 106 ----
 spec/spec_helper.rb                           |  21 +-
 spec/support/mock_connection.rb               |  39 --
 spec/support/mongohq.rb                       |  61 ++
 spec/support/replica_set_simulator.rb         | 306 ++++++++++
 spec/support/stats.rb                         |  51 ++
 42 files changed, 2057 insertions(+), 3322 deletions(-)
 create mode 100644 lib/moped/connection.rb
 create mode 100644 lib/moped/node.rb
 delete mode 100644 lib/moped/server.rb
 create mode 100644 lib/moped/session/context.rb
 delete mode 100644 lib/moped/socket.rb
 create mode 100644 lib/moped/threaded.rb
 delete mode 100644 spec/integration/protocol/authentication_spec.rb
 delete mode 100644 spec/integration/protocol/protocol_spec.rb
 delete mode 100644 spec/integration_spec.rb
 delete mode 100644 spec/moped/cursor_spec.rb
 delete mode 100644 spec/moped/database_spec.rb
 delete mode 100644 spec/moped/errors_spec.rb
 delete mode 100644 spec/moped/logging_spec.rb
 create mode 100644 spec/moped/node_spec.rb
 delete mode 100644 spec/moped/server_spec.rb
 delete mode 100644 spec/moped/socket_spec.rb
 delete mode 100644 spec/moped_spec.rb
 delete mode 100644 spec/replset_spec.rb
 delete mode 100644 spec/support/mock_connection.rb
 create mode 100644 spec/support/mongohq.rb
 create mode 100644 spec/support/replica_set_simulator.rb
 create mode 100644 spec/support/stats.rb

diff --git a/.gitignore b/.gitignore
index 2113b0b..a38b29d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,5 +2,6 @@ Gemfile.lock
 doc
 .yardoc
 .rvmrc
+.env
 perf/results
 tmp/
diff --git a/README.md b/README.md
index 38aad6b..98628b3 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,21 @@ session[:artists].find(name: "Syd Vicious").
   )
 ```
 
+## Features
+
+* Automated replica set node discovery and failover.
+* No C or Java extensions
+* No external dependencies
+* Simple, stable, public API.
+
+### Unsupported Features
+
+* GridFS
+* Map/Reduce
+
+These features are possible to implement, but outside the scope of Moped's
+goals. Consider them perfect opportunities to write a companion gem!
+
 # Project Breakdown
 
 Moped is composed of three parts: an implementation of the [BSON
@@ -43,6 +58,31 @@ id.generation_time # => 2012-04-11 13:14:29 UTC
 id == Moped::BSON::ObjectId.from_string(id.to_s) # => true
 ```
 
+<table><tbody>
+
+<tr><th>new</th>
+<td>Creates a new object id.</td></tr>
+
+<tr><th>from_string</th>
+<td>Creates a new object id from an object id string.
+<br>
+<code>Moped::BSON::ObjectId.from_string("4f8d8c66e5a4e45396000009")</code>
+</td></tr>
+
+<tr><th>from_time</th>
+<td>Creates a new object id from a time.
+<br>
+<code>Moped::BSON::ObjectId.from_time(Time.new)</code>
+</td></tr>
+
+<tr><th>legal?</th>
+<td>Validates an object id string.
+<br>
+<code>Moped::BSON::ObjectId.legal?("4f8d8c66e5a4e45396000009")</code>
+</td></tr>
+
+</tbody></table>
+
 ### Moped::BSON::Code
 
 The `Code` class is used for working with javascript on the server.
@@ -299,6 +339,126 @@ scope.one # nil
 
 </tbody></table>
 
+# Exceptions
+
+Here's a list of the exceptions generated by Moped.
+
+<table><tbody>
+
+<tr><th>Moped::Errors::ConnectionFailure</th>
+<td>Raised when a node cannot be reached or a connection is lost.
+<br>
+<strong>Note:</strong> this exception is only raised if Moped could not
+reconnect, so you shouldn't attempt to rescue this.</td></tr>
+
+<tr><th>Moped::Errors::OperationFailure</th>
+<td>Raised when a command fails or is invalid, such as when an insert fails in
+safe mode.</td></tr>
+
+<tr><th>Moped::Errors::QueryFailure</th>
+<td>Raised when an invalid query was sent to the database.</td></tr>
+
+<tr><th>Moped::Errors::AuthenticationFailure</th>
+<td>Raised when invalid credentials were passed to `session.login`.</td></tr>
+
+<tr><th>Moped::Errors::SocketError</th>
+<td>Not a real exception, but a module used to tag unhandled exceptions inside
+of a node's networking code. Allows you to `rescue Moped::SocketError` which
+preserving the real exception.</td></tr>
+
+</tbody></table>
+
+Other exceptions are possible while running commands, such as IO Errors around
+failed connections. Moped tries to be smart about managing its connections,
+such as checking if they're dead before executing a command; but those checks
+aren't foolproof, and Moped is conservative about handling unexpected errors on
+its connections. Namely, Moped will *not* retry a command if an unexpected
+exception is raised. Why? Because it's impossible to know whether the command
+was actually received by the remote Mongo instance, and without domain
+knowledge it cannot be safely retried.
+
+Take for example this case:
+
+```ruby
+session.with(safe: true)["users"].insert(name: "John")
+```
+
+It's entirely possible that the insert command will be sent to Mongo, but the
+connection gets closed before we read the result for `getLastError`. In this
+case, there's no way to know whether the insert was actually successful!
+
+If, however, you want to gracefully handle this in your own application, you
+could do something like:
+
+```ruby
+document = { _id: Moped::BSON::ObjectId.new, name: "John" }
+
+begin
+  session["users"].insert(document)
+rescue Moped::Errors::SocketError
+  session["users"].find(_id: document[:_id]).upsert(document)
+end
+```
+
+# Replica Sets
+
+Moped has full support for replica sets including automatic failover and node
+discovery.
+
+## Automatic Failover
+
+Moped will automatically retry lost connections and attempt to detect dead
+connections before sending an operation. Note, that it will *not* retry
+individual operations! For example, these cases will work and not raise any
+exceptions:
+
+```ruby
+session[:users].insert(name: "John")
+# kill primary node and promote secondary
+session[:users].insert(name: "John")
+session[:users].find.count # => 2.0
+
+# primary node drops our connection
+session[:users].insert(name: "John")
+```
+
+However, you'll get an operation error in a case like:
+
+```ruby
+# primary node goes down while reading the reply
+session.with(safe: true)[:users].insert(name: "John")
+```
+
+And you'll get a connection error in a case like:
+
+```ruby
+# primary node goes down, no new primary available yet
+session[:users].insert(name: "John")
+```
+
+If your session is running with eventual consistency, read operations will
+never raise connection errors as long as any secondary or primary node is
+running. The only case where you'll see a connection failure is if a node goes
+down while attempting to retrieve more results from a cursor, because cursors
+are tied to individual nodes.
+
+When two attempts to connect to a node fail, it will be marked as down. This
+removes it from the list of available nodes for `:down_interval` (default 30
+seconds). Note that the `:down_interval` only applies to normal operations;
+that is, if you ask for a primary node and none is available, all nodes will be
+retried. Likewise, if you ask for a secondary node, and no secondary or primary
+node is available, all nodes will be retreied.
+
+## Node Discovery
+
+The addresses you pass into your session are used as seeds for setting up
+replica set connections. After connection, each seed node will return a list of
+other known nodes which will be added to the set.
+
+This information is cached according to the `:refresh_interval` option (default:
+5 minutes). That means, e.g., that if you add a new node to your replica set,
+it should be represented in Moped within 5 minutes.
+
 # Thread-Safety
 
 Moped is thread-safe -- depending on your definition of thread-safe. For Moped,
diff --git a/lib/moped.rb b/lib/moped.rb
index 6ca65e3..83645a5 100644
--- a/lib/moped.rb
+++ b/lib/moped.rb
@@ -6,14 +6,16 @@
 require "moped/bson"
 require "moped/cluster"
 require "moped/collection"
+require "moped/connection"
 require "moped/cursor"
 require "moped/database"
 require "moped/errors"
 require "moped/indexes"
 require "moped/logging"
+require "moped/node"
 require "moped/protocol"
 require "moped/query"
-require "moped/server"
 require "moped/session"
-require "moped/socket"
+require "moped/session/context"
+require "moped/threaded"
 require "moped/version"
diff --git a/lib/moped/bson/object_id.rb b/lib/moped/bson/object_id.rb
index dab72ce..6d9331a 100644
--- a/lib/moped/bson/object_id.rb
+++ b/lib/moped/bson/object_id.rb
@@ -8,31 +8,33 @@ class ObjectId
       # Formatting string for outputting an ObjectId.
       @@string_format = ("%02x" * 12).freeze
 
-      attr_reader :data
-
       class << self
         def from_string(string)
           raise Errors::InvalidObjectId.new(string) unless legal?(string)
-          data = []
+          data = ""
           12.times { |i| data << string[i*2, 2].to_i(16) }
-          new data
+          from_data data
+        end
+
+        def from_time(time)
+          from_data @@generator.generate(time.to_i)
         end
 
         def legal?(str)
-          !!str.match(/^[0-9a-f]{24}$/i)
+          !!str.match(/\A\h{24}\Z/i)
         end
-      end
 
-      def initialize(data = nil, time = nil)
-        if data
-          @data = data
-        elsif time
-          @data = @@generator.generate(time.to_i)
-        else
-          @data = @@generator.next
+        def from_data(data)
+          id = allocate
+          id.instance_variable_set :@data, data
+          id
         end
       end
 
+      def data
+        @data ||= @@generator.next
+      end
+
       def ==(other)
         BSON::ObjectId === other && data == other.data
       end
@@ -43,28 +45,27 @@ def hash
       end
 
       def to_s
-        @@string_format % data
+        @@string_format % data.unpack("C12")
       end
 
       # Return the UTC time at which this ObjectId was generated. This may
       # be used instread of a created_at timestamp since this information
       # is always encoded in the object id.
       def generation_time
-        Time.at(@data.pack("C4").unpack("N")[0]).utc
+        Time.at(data.unpack("N")[0]).utc
       end
 
       class << self
         def __bson_load__(io)
-          new io.read(12).unpack('C*')
+          from_data(io.read(12))
         end
-
       end
 
       def __bson_dump__(io, key)
         io << Types::OBJECT_ID
         io << key
         io << NULL_BYTE
-        io << data.pack('C12')
+        io << data
       end
 
       # @api private
@@ -72,49 +73,28 @@ class Generator
         def initialize
           # Generate and cache 3 bytes of identifying information from the current
           # machine.
-          @machine_id = Digest::MD5.digest(Socket.gethostname).unpack("C3")
+          @machine_id = Digest::MD5.digest(Socket.gethostname).unpack("N")[0]
 
           @mutex = Mutex.new
-          @last_timestamp = nil
           @counter = 0
         end
 
-        # Return object id data based on the current time, incrementing a
-        # counter for object ids generated in the same second.
+        # Return object id data based on the current time, incrementing the
+        # object id counter.
         def next
-          now = Time.new.to_i
-
-          counter = @mutex.synchronize do
-            last_timestamp, @last_timestamp = @last_timestamp, now
-
-            if last_timestamp == now
-              @counter += 1
-            else
-              @counter = 0
-            end
+          @mutex.lock
+          begin
+            counter = @counter = (@counter + 1) % 0xFFFFFF
+          ensure
+            @mutex.unlock rescue nil
           end
 
-          generate(now, counter)
+          generate(Time.new.to_i, counter)
         end
 
-        # Generate object id data for a given time using the provided +inc+.
-        def generate(time, inc = 0)
-          pid = Process.pid % 0xFFFF
-
-          [
-            time >> 24 & 0xFF, # 4 bytes time (network order)
-            time >> 16 & 0xFF,
-            time >> 8  & 0xFF,
-            time       & 0xFF,
-            @machine_id[0],   # 3 bytes machine
-            @machine_id[1],
-            @machine_id[2],
-            pid  >> 8  & 0xFF, # 2 bytes process id
-            pid        & 0xFF,
-            inc  >> 16 & 0xFF, # 3 bytes increment
-            inc  >> 8  & 0xFF,
-            inc        & 0xFF,
-          ]
+        # Generate object id data for a given time using the provided +counter+.
+        def generate(time, counter = 0)
+          [time, @machine_id, Process.pid, counter << 8].pack("N NX lXX NX")
         end
       end
 
diff --git a/lib/moped/cluster.rb b/lib/moped/cluster.rb
index bb24303..77295b3 100644
--- a/lib/moped/cluster.rb
+++ b/lib/moped/cluster.rb
@@ -1,173 +1,131 @@
 module Moped
 
-  # @api private
-  #
-  # The internal class managing connections to both a single node and replica
-  # sets.
-  #
-  # @note Though the socket class itself *is* threadsafe, the cluster presently
-  #   is not. This means that in the course of normal operations sessions can be
-  #   shared across threads, but in failure modes (when a resync is required),
-  #   things can possibly go wrong.
   class Cluster
 
-    # @return [Array] the user supplied seeds
+    # @return [Array<String>] the seeds the replica set was initialized with
     attr_reader :seeds
 
-    # @return [Boolean] whether this is a direct connection
-    attr_reader :direct
-
-    # @return [Array] all available nodes
-    attr_reader :servers
-
-    # @return [Array] seeds gathered from cluster discovery
-    attr_reader :dynamic_seeds
-
-    # @param [Array] seeds an array of host:port pairs
-    # @param [Boolean] direct (false) whether to connect directly to the hosts
-    # provided or to find additional available nodes.
-    def initialize(seeds, direct = false)
-      @seeds  = seeds
-      @direct = direct
-
-      @servers = []
-      @dynamic_seeds = []
-    end
-
-    # @return [Array] available secondary nodes
-    def secondaries
-      servers.select(&:secondary?)
-    end
-
-    # @return [Array] available primary nodes
-    def primaries
-      servers.select(&:primary?)
-    end
-
-    # @return [Array] all known addresses from user supplied seeds, dynamically
-    # discovered seeds, and active servers.
-    def known_addresses
-      [].tap do |addresses|
-        addresses.concat seeds
-        addresses.concat dynamic_seeds
-        addresses.concat servers.map { |server| server.address }
-      end.uniq
-    end
-
-    def remove(server)
-      servers.delete(server)
+    # @option options :down_interval number of seconds to wait before attempting
+    # to reconnect to a down node. (30)
+    #
+    # @option options :refresh_interval number of seconds to cache information
+    # about a node. (300)
+    def initialize(hosts, options)
+      @options = {
+        down_interval: 30,
+        refresh_interval: 300
+      }.merge(options)
+
+      @seeds = hosts
+      @nodes = hosts.map { |host| Node.new(host) }
     end
 
-    def reconnect
-      @servers = servers.map { |server| Server.new(server.address) }
-    end
-
-    def sync
-      known = known_addresses.shuffle
-      seen  = {}
-
-      sync_seed = ->(seed) do
-        server = Server.new seed
-
-        unless seen[server.resolved_address]
-          seen[server.resolved_address] = true
-
-          hosts = sync_server(server)
-
-          hosts.each do |host|
-            sync_seed[host]
-          end
+    # Refreshes information for each of the nodes provided. The node list
+    # defaults to the list of all known nodes.
+    #
+    # If a node is successfully refreshed, any newly discovered peers will also
+    # be refreshed.
+    #
+    # @return [Array<Node>] the available nodes
+    def refresh(nodes_to_refresh = @nodes)
+      refreshed_nodes = []
+      seen = {}
+
+      # Set up a recursive lambda function for refreshing a node and it's peers.
+      refresh_node = ->(node) do
+        return if seen[node]
+        seen[node] = true
+
+        # Add the node to the global list of known nodes.
+        @nodes << node unless @nodes.include?(node)
+
+        begin
+          node.refresh
+
+          # This node is good, so add it to the list of nodes to return.
+          refreshed_nodes << node unless refreshed_nodes.include?(node)
+
+          # Now refresh any newly discovered peer nodes.
+          (node.peers - @nodes).each &refresh_node
+        rescue Errors::ConnectionFailure
+          # We couldn't connect to the node, so don't do anything with it.
         end
       end
 
-      known.each do |seed|
-        sync_seed[seed]
-      end
-
-      unless servers.empty?
-        @dynamic_seeds = servers.map(&:address)
-      end
-
-      true
+      nodes_to_refresh.each &refresh_node
+      refreshed_nodes.to_a
     end
 
-    def sync_server(server)
-      [].tap do |hosts|
-        socket = server.socket
-
-        if socket.connect
-          info = socket.simple_query Protocol::Command.new(:admin, ismaster: 1)
-
-          if info["ismaster"]
-            server.primary = true
-          end
+    # Returns the list of available nodes, refreshing 1) any nodes which were
+    # down and ready to be checked again and 2) any nodes whose information is
+    # out of date.
+    #
+    # @return [Array<Node>] the list of available nodes.
+    def nodes
+      # Find the nodes that were down but are ready to be refreshed, or those
+      # with stale connection information.
+      needs_refresh, available = @nodes.partition do |node|
+        (node.down? && node.down_at < (Time.new - @options[:down_interval])) ||
+          node.needs_refresh?(Time.new - @options[:refresh_interval])
+      end
 
-          if info["secondary"]
-            server.secondary = true
-          end
+      # Refresh those nodes.
+      available.concat refresh(needs_refresh)
 
-          if info["primary"]
-            hosts.push info["primary"]
-          end
-
-          if info["hosts"]
-            hosts.concat info["hosts"]
-          end
+      # Now return all the nodes that are available.
+      available.reject &:down?
+    end
 
-          if info["passives"]
-            hosts.concat info["passives"]
+    # Yields the replica set's primary node to the provided block. This method
+    # will retry the block in case of connection errors or replica set
+    # reconfiguration.
+    #
+    # @raises ConnectionFailure when no primary node can be found
+    def with_primary(retry_on_failure = true, &block)
+      if node = nodes.find(&:primary?)
+        begin
+          node.ensure_primary do
+            return yield node.apply_auth(auth)
           end
-
-          merge(server)
-
+        rescue Errors::ConnectionFailure, Errors::ReplicaSetReconfigured
+          # Fall through to the code below if our connection was dropped or the
+          # node is no longer the primary.
         end
-      end.uniq
-    end
-
-    def merge(server)
-      previous = servers.find { |other| other == server }
-      primary = server.primary?
-      secondary = server.secondary?
+      end
 
-      if previous
-        previous.merge(server)
+      if retry_on_failure
+        # We couldn't find a primary node, so refresh the list and try again.
+        refresh
+        with_primary(false, &block)
       else
-        servers << server
+        raise Errors::ConnectionFailure, "Could not connect to a primary node for replica set #{inspect}"
       end
     end
 
-    # @param [:read, :write] mode the type of socket to return
-    # @return [Socket] a socket valid for +mode+ operations
-    def socket_for(mode)
-      sync unless primaries.any? || (secondaries.any? && mode == :read)
-
-      server = nil
-      while primaries.any? || (secondaries.any? && mode == :read)
-        if mode == :write || secondaries.empty?
-          server = primaries.sample
-        else
-          server = secondaries.sample
-        end
-
-        if server
-          socket = server.socket
-          socket.connect unless socket.connection
-
-          if socket.alive?
-            break server
-          else
-            remove server
-          end
+    # Yields a secondary node if available, otherwise the primary node. This
+    # method will retry the block in case of connection errors.
+    #
+    # @raises ConnectionError when no secondary or primary node can be found
+    def with_secondary(retry_on_failure = true, &block)
+      available_nodes = nodes.shuffle!.partition(&:secondary?).flatten
+
+      while node = available_nodes.shift
+        begin
+          return yield node.apply_auth(auth)
+        rescue Errors::ConnectionFailure
+          # That node's no good, so let's try the next one.
+          next
         end
       end
 
-      unless server
-        raise Errors::ConnectionFailure.new("Could not connect to any primary or secondary servers")
+      if retry_on_failure
+        # We couldn't find a secondary or primary node, so refresh the list and
+        # try again.
+        refresh
+        with_secondary(false, &block)
+      else
+        raise Errors::ConnectionFailure, "Could not connect to any secondary or primary nodes for replica set #{inspect}"
       end
-
-      socket = server.socket
-      socket.apply_auth auth
-      socket
     end
 
     # @return [Hash] the cached authentication credentials for this cluster.
@@ -175,19 +133,11 @@ def auth
       @auth ||= {}
     end
 
-    # Log in to +database+ with +username+ and +password+. Does not perform the
-    # actual log in, but saves the credentials for later authentication on a
-    # socket.
-    def login(database, username, password)
-      auth[database.to_s] = [username, password]
-    end
+    private
 
-    # Log out of +database+. Does not perform the actual log out, but will log
-    # out when the socket is used next.
-    def logout(database)
-      auth.delete(database.to_s)
+    def initialize_copy(_)
+      @nodes = @nodes.map &:dup
     end
 
   end
-
 end
diff --git a/lib/moped/collection.rb b/lib/moped/collection.rb
index eac4aaf..61645a9 100644
--- a/lib/moped/collection.rb
+++ b/lib/moped/collection.rb
@@ -56,12 +56,10 @@ def find(selector = {})
     #   @param [Array<Hash>] documents the documents to insert
     def insert(documents)
       documents = [documents] unless documents.is_a? Array
-      insert = Protocol::Insert.new(database.name, name, documents)
 
       database.session.with(consistency: :strong) do |session|
-        session.execute insert
+        session.context.insert(database.name, name, documents)
       end
-
     end
   end
 end
diff --git a/lib/moped/connection.rb b/lib/moped/connection.rb
new file mode 100644
index 0000000..d94d254
--- /dev/null
+++ b/lib/moped/connection.rb
@@ -0,0 +1,95 @@
+require "timeout"
+
+module Moped
+  class Connection
+
+    class TCPSocket < ::TCPSocket
+      def self.connect(host, port, timeout)
+        Timeout::timeout(timeout) do
+          new(host, port).tap do |sock|
+            sock.set_encoding 'binary'
+          end
+        end
+      end
+
+      def alive?
+        if Kernel::select([self], nil, nil, 0)
+          !eof? rescue false
+        else
+          true
+        end
+      end
+
+      def write(*args)
+        raise Errors::ConnectionFailure, "Socket connection was closed by remote host" unless alive?
+        super
+      end
+    end
+
+    def initialize
+      @sock = nil
+      @request_id = 0
+    end
+
+    def connect(host, port, timeout)
+      @sock = TCPSocket.connect host, port, timeout
+    end
+
+    def alive?
+      connected? ? @sock.alive? : false
+    end
+
+    def connected?
+      !!@sock
+    end
+
+    def disconnect
+      @sock.close
+    rescue
+    ensure
+      @sock = nil
+    end
+
+    def write(operations)
+      buf = ""
+
+      operations.each do |operation|
+        operation.request_id = (@request_id += 1)
+        operation.serialize(buf)
+      end
+
+      @sock.write buf
+    end
+
+    def receive_replies(operations)
+      operations.map do |operation|
+        read if operation.is_a?(Protocol::Query) || operation.is_a?(Protocol::GetMore)
+      end
+    end
+
+    def read
+      reply = Protocol::Reply.allocate
+
+      reply.length,
+        reply.request_id,
+        reply.response_to,
+        reply.op_code,
+        reply.flags,
+        reply.cursor_id,
+        reply.offset,
+        reply.count = @sock.read(36).unpack('l5<q<l2<')
+
+      if reply.count == 0
+        reply.documents = []
+      else
+        buffer = StringIO.new(@sock.read(reply.length - 36))
+
+        reply.documents = reply.count.times.map do
+          BSON::Document.deserialize(buffer)
+        end
+      end
+
+      reply
+    end
+  end
+end
diff --git a/lib/moped/cursor.rb b/lib/moped/cursor.rb
index 907ed50..359403b 100644
--- a/lib/moped/cursor.rb
+++ b/lib/moped/cursor.rb
@@ -10,50 +10,69 @@ class Cursor
 
     def initialize(session, query_operation)
       @session = session
-      @query_op = query_operation.dup
 
-      @get_more_op = Protocol::GetMore.new(
-        @query_op.database,
-        @query_op.collection,
-        0,
-        @query_op.limit
-      )
+      @database    = query_operation.database
+      @collection  = query_operation.collection
+      @selector    = query_operation.selector
 
-      @kill_cursor_op = Protocol::KillCursors.new([0])
+      @cursor_id = 0
+      @limit = query_operation.limit
+      @limited = @limit > 0
+
+      @options = {
+        request_id: query_operation.request_id,
+        flags: query_operation.flags,
+        limit: query_operation.limit,
+        skip: query_operation.skip,
+        fields: query_operation.fields
+      }
     end
 
     def each
-      documents = query @query_op
+      documents = load
       documents.each { |doc| yield doc }
 
       while more?
-        return kill if limited? && @get_more_op.limit <= 0
+        return kill if limited? && @limit <= 0
 
-        documents = query @get_more_op
+        documents = get_more
         documents.each { |doc| yield doc }
       end
     end
 
-    def query(operation)
-      reply = session.query operation
+    def load
+      consistency = session.consistency
+      @options[:flags] |= [:slave_ok] if consistency == :eventual
+
+      reply, @node = session.context.with_node do |node|
+        [node.query(@database, @collection, @selector, @options), node]
+      end
 
-      @get_more_op.limit -= reply.count if limited?
-      @get_more_op.cursor_id = reply.cursor_id
-      @kill_cursor_op.cursor_ids = [reply.cursor_id]
+      @limit -= reply.count if limited?
+      @cursor_id = reply.cursor_id
 
       reply.documents
     end
 
     def limited?
-      @query_op.limit > 0
+      @limited
     end
 
     def more?
-      @get_more_op.cursor_id != 0
+      @cursor_id != 0
+    end
+
+    def get_more
+      reply = @node.get_more @database, @collection, @cursor_id, @limit
+
+      @limit -= reply.count if limited?
+      @cursor_id = reply.cursor_id
+
+      reply.documents
     end
 
     def kill
-      session.execute kill_cursor_op
+      @node.kill_cursors [@cursor_id]
     end
   end
 
diff --git a/lib/moped/database.rb b/lib/moped/database.rb
index 6518abb..a69b0ed 100644
--- a/lib/moped/database.rb
+++ b/lib/moped/database.rb
@@ -29,7 +29,9 @@ def initialize(session, name)
 
     # Drop the database.
     def drop
-      command dropDatabase: 1
+      session.with(consistency: :strong) do |session|
+        session.context.command name, dropDatabase: 1
+      end
     end
 
     # Log in with +username+ and +password+ on the current database.
@@ -37,12 +39,12 @@ def drop
     # @param [String] username the username
     # @param [String] password the password
     def login(username, password)
-      session.cluster.login(name, username, password)
+      session.context.login(name, username, password)
     end
 
     # Log out from the current database.
     def logout
-      session.cluster.logout(name)
+      session.context.logout(name)
     end
 
     # Run +command+ on the database.
@@ -54,17 +56,7 @@ def logout
     # @param [Hash] command the command to run
     # @return [Hash] the result of the command
     def command(command)
-      operation = Protocol::Command.new(name, command)
-
-      result = session.with(consistency: :strong) do |session|
-        session.simple_query(operation)
-      end
-
-      raise Errors::OperationFailure.new(
-        operation, result
-      ) unless result["ok"] == 1.0
-
-      result
+      session.context.command name, command
     end
 
     # @param [Symbol, String] collection the collection name
diff --git a/lib/moped/errors.rb b/lib/moped/errors.rb
index 6f94984..da88514 100644
--- a/lib/moped/errors.rb
+++ b/lib/moped/errors.rb
@@ -1,6 +1,4 @@
 module Moped
-
-  # The namespace for all errors generated by Moped.
   module Errors
 
     # Mongo's exceptions are sparsely documented, but this is the most accurate
@@ -10,21 +8,12 @@ module Errors
     # Generic error class for exceptions related to connection failures.
     class ConnectionFailure < StandardError; end
 
-    # Raised when providing an invalid string from an object id.
-    class InvalidObjectId < StandardError
-      def initialize(string)
-        super("'#{string}' is not a valid object id.")
-      end
-    end
+    # Tag applied to unhandled exceptions on a node.
+    module SocketError end
 
     # Generic error class for exceptions generated on the remote MongoDB
     # server.
-    class MongoError < StandardError; end
-
-    # Exception class for exceptions generated as a direct result of an
-    # operation, such as a failed insert or an invalid command.
-    class OperationFailure < MongoError
-
+    class MongoError < StandardError
       # @return the command that generated the error
       attr_reader :command
 
@@ -60,9 +49,28 @@ def error_message
       end
     end
 
-    # A special kind of OperationFailure, raised when Mongo sets the
-    # :query_failure flag on a query response.
-    class QueryFailure < OperationFailure; end
+    # Exception class for exceptions generated as a direct result of an
+    # operation, such as a failed insert or an invalid command.
+    class OperationFailure < MongoError; end
+
+    # Exception raised on invalid queries.
+    class QueryFailure < MongoError; end
+
+    # Exception raised when authentication fails.
+    class AuthenticationFailure < MongoError; end
+
+    # Raised when providing an invalid string from an object id.
+    class InvalidObjectId < StandardError
+      def initialize(string)
+        super("'#{string}' is not a valid object id.")
+      end
+    end
+
+    # @api private
+    #
+    # Internal exception raised by Node#ensure_primary and captured by
+    # Cluster#with_primary.
+    class ReplicaSetReconfigured < StandardError; end
 
   end
 end
diff --git a/lib/moped/node.rb b/lib/moped/node.rb
new file mode 100644
index 0000000..e9a8d57
--- /dev/null
+++ b/lib/moped/node.rb
@@ -0,0 +1,334 @@
+module Moped
+  class Node
+
+    attr_reader :address
+    attr_reader :resolved_address
+    attr_reader :ip_address
+    attr_reader :port
+
+    attr_reader :peers
+    attr_reader :timeout
+
+    def initialize(address)
+      @address = address
+
+      host, port = address.split(":")
+      @ip_address = ::Socket.getaddrinfo(host, nil, ::Socket::AF_INET, ::Socket::SOCK_STREAM).first[3]
+      @port = port.to_i
+      @resolved_address = "#{@ip_address}:#{@port}"
+
+      @timeout = 5
+    end
+
+    def command(database, cmd, options = {})
+      operation = Protocol::Command.new(database, cmd, options)
+
+      process(operation) do |reply|
+        result = reply.documents[0]
+
+        raise Errors::OperationFailure.new(
+          operation, result
+        ) if result["ok"] != 1 || result["err"] || result["errmsg"]
+
+        result
+      end
+    end
+
+    def kill_cursors(cursor_ids)
+      process Protocol::KillCursors.new(cursor_ids)
+    end
+
+    def get_more(database, collection, cursor_id, limit)
+      process Protocol::GetMore.new(database, collection, cursor_id, limit)
+    end
+
+    def remove(database, collection, selector, options = {})
+      process Protocol::Delete.new(database, collection, selector, options)
+    end
+
+    def update(database, collection, selector, change, options = {})
+      process Protocol::Update.new(database, collection, selector, change, options)
+    end
+
+    def insert(database, collection, documents)
+      process Protocol::Insert.new(database, collection, documents)
+    end
+
+    def query(database, collection, selector, options = {})
+      operation = Protocol::Query.new(database, collection, selector, options)
+
+      process operation do |reply|
+        if reply.flags.include? :query_failure
+          raise Errors::QueryFailure.new(operation, reply.documents.first)
+        end
+
+        reply
+      end
+    end
+
+    # @return [true/false] whether the node needs to be refreshed.
+    def needs_refresh?(time)
+      !@refreshed_at || @refreshed_at < time
+    end
+
+    def primary?
+      @primary
+    end
+
+    def secondary?
+      @secondary
+    end
+
+    # Refresh information about the node, such as it's status in the replica
+    # set and it's known peers.
+    #
+    # Returns nothing.
+    # Raises Errors::ConnectionFailure if the node cannot be reached
+    # Raises Errors::ReplicaSetReconfigured if the node is no longer a primary node and
+    #   refresh was called within an +#ensure_primary+ block.
+    def refresh
+      info = command "admin", ismaster: 1
+
+      @refreshed_at = Time.now
+      primary = true if info["ismaster"]
+      secondary = true if info["secondary"]
+
+      peers = []
+      peers.push info["primary"] if info["primary"]
+      peers.concat info["hosts"] if info["hosts"]
+      peers.concat info["passives"] if info["passives"]
+      peers.concat info["arbiters"] if info["arbiters"]
+
+      @peers = peers.map { |peer| Node.new(peer) }
+      @primary, @secondary = primary, secondary
+
+      if !primary && Threaded.executing?(:ensure_primary)
+        raise Errors::ReplicaSetReconfigured, "#{inspect} is no longer the primary node."
+      end
+    end
+
+    attr_reader :down_at
+
+    def down?
+      @down_at
+    end
+
+    # Set a flag on the node for the duration of provided block so that an
+    # exception is raised if the node is no longer the primary node.
+    #
+    # Returns nothing.
+    def ensure_primary
+      Threaded.begin :ensure_primary
+      yield
+    ensure
+      Threaded.end :ensure_primary
+    end
+
+    # Yields the block if a connection can be established, retrying when a
+    # connection error is raised.
+    #
+    # @raises ConnectionFailure when a connection cannot be established.
+    def ensure_connected
+      # Don't run the reconnection login if we're already inside an
+      # +ensure_connected+ block.
+      return yield if Threaded.executing? :connection
+      Threaded.begin :connection
+
+      retry_on_failure = true
+
+      begin
+        connect unless connected?
+        yield
+      rescue Errors::ReplicaSetReconfigured
+        # Someone else wrapped this in an #ensure_primary block, so let the
+        # reconfiguration exception bubble up.
+        raise
+      rescue Errors::OperationFailure, Errors::AuthenticationFailure, Errors::QueryFailure
+        # These exceptions are "expected" in the normal course of events, and
+        # don't necessitate disconnecting.
+        raise
+      rescue Errors::ConnectionFailure
+        disconnect
+
+        if retry_on_failure
+          # Maybe there was a hiccup -- try reconnecting one more time
+          retry_on_failure = false
+          retry
+        else
+          # Nope, we failed to connect twice. Flag the node as down and re-raise
+          # the exception.
+          down!
+          raise
+        end
+      rescue
+        # Looks like we got an unexpected error, so we'll clean up the connection
+        # and re-raise the exception.
+        disconnect
+        raise $!.extend(Errors::SocketError)
+      end
+    ensure
+      Threaded.end :connection
+    end
+
+    def pipeline
+      Threaded.begin :pipeline
+
+      begin
+        yield
+      ensure
+        Threaded.end :pipeline
+      end
+
+      flush unless Threaded.executing? :pipeline
+    end
+
+    def apply_auth(credentials)
+      unless auth == credentials
+        logouts = auth.keys - credentials.keys
+
+        logouts.each do |database|
+          logout database
+        end
+
+        credentials.each do |database, (username, password)|
+          login(database, username, password) unless auth[database] == [username, password]
+        end
+      end
+
+      self
+    end
+
+    def ==(other)
+      resolved_address == other.resolved_address
+    end
+    alias eql? ==
+
+    def hash
+      [ip_address, port].hash
+    end
+
+    private
+
+    def auth
+      @auth ||= {}
+    end
+
+    def login(database, username, password)
+      getnonce = Protocol::Command.new(database, getnonce: 1)
+      connection.write [getnonce]
+      result = connection.read.documents.first
+      raise Errors::OperationFailure.new(getnonce, result) unless result["ok"] == 1
+
+      authenticate = Protocol::Commands::Authenticate.new(database, username, password, result["nonce"])
+      connection.write [authenticate]
+      result = connection.read.documents.first
+      raise Errors::AuthenticationFailure.new(authenticate, result) unless result["ok"] == 1
+
+      auth[database] = [username, password]
+    end
+
+    def logout(database)
+      command = Protocol::Command.new(database, logout: 1)
+      connection.write [command]
+      result = connection.read.documents.first
+      raise Errors::OperationFailure.new(command, result) unless result["ok"] == 1
+
+      auth.delete(database)
+    end
+
+    def initialize_copy(_)
+      @connection = nil
+    end
+
+    def connection
+      @connection ||= Connection.new
+    end
+
+    def disconnect
+      auth.clear
+      connection.disconnect
+    end
+
+    def connected?
+      connection.connected?
+    end
+
+    # Mark the node as down.
+    #
+    # Returns nothing.
+    def down!
+      @down_at = Time.new
+
+      disconnect
+    end
+
+    # Connect to the node.
+    #
+    # Returns nothing.
+    # Raises Moped::ConnectionError if the connection times out.
+    # Raises Moped::ConnectionError if the server is unavailable.
+    def connect
+      connection.connect ip_address, port, timeout
+      @down_at = nil
+
+      refresh
+    rescue Timeout::Error
+      raise Errors::ConnectionFailure, "Timed out connection to Mongo on #{address}"
+    rescue Errno::ECONNREFUSED
+      raise Errors::ConnectionFailure, "Could not connect to Mongo on #{address}"
+    end
+
+    def process(operation, &callback)
+      if Threaded.executing? :pipeline
+        queue.push [operation, callback]
+      else
+        flush([[operation, callback]])
+      end
+    end
+
+    def queue
+      Threaded.stack(:pipelined_operations)
+    end
+
+    def flush(ops = queue)
+      operations, callbacks = ops.transpose
+
+      logging(operations) do
+        ensure_connected do
+          connection.write operations
+          replies = connection.receive_replies(operations)
+
+          replies.zip(callbacks).map do |reply, callback|
+            callback ? callback[reply] : reply
+          end.last
+        end
+      end
+    ensure
+      ops.clear
+    end
+
+    def logging(operations)
+      instrument_start = (logger = Moped.logger) && logger.debug? && Time.new
+      yield
+    ensure
+      log_operations(logger, operations, Time.new - instrument_start) if instrument_start && !$!
+    end
+
+    def log_operations(logger, ops, duration)
+      prefix  = "  MOPED: #{address} "
+      indent  = " "*prefix.length
+      runtime = (" (%.1fms)" % duration)
+
+      if ops.length == 1
+        logger.debug prefix + ops.first.log_inspect + runtime
+      else
+        first, *middle, last = ops
+
+        logger.debug prefix + first.log_inspect
+        middle.each { |m| logger.debug indent + m.log_inspect }
+        logger.debug indent + last.log_inspect + runtime
+      end
+    end
+
+  end
+end
diff --git a/lib/moped/protocol/command.rb b/lib/moped/protocol/command.rb
index aeaf0c4..4723b60 100644
--- a/lib/moped/protocol/command.rb
+++ b/lib/moped/protocol/command.rb
@@ -11,8 +11,9 @@ class Command < Query
 
       # @param [String, Symbol] database the database to run this command on
       # @param [Hash] command the command to run
-      def initialize(database, command)
-        super database, :$cmd, command, limit: -1
+      # @param [Hash] additional query options
+      def initialize(database, command, options = {})
+        super database, :$cmd, command, options.merge(limit: -1)
       end
 
       def log_inspect
diff --git a/lib/moped/query.rb b/lib/moped/query.rb
index b2e676a..e347e94 100644
--- a/lib/moped/query.rb
+++ b/lib/moped/query.rb
@@ -99,7 +99,7 @@ def select(select)
 
     # @return [Hash] the first document that matches the selector.
     def first
-      session.simple_query(operation)
+      limit(-1).each.first
     end
     alias one first
 
@@ -107,7 +107,7 @@ def first
     #
     # @yieldparam [Hash] document each matching document
     def each
-      cursor = Cursor.new(session.with(retain_socket: true), operation)
+      cursor = Cursor.new(session, operation)
       cursor.to_enum.tap do |enum|
         enum.each do |document|
           yield document
@@ -129,6 +129,7 @@ def distinct(key)
         key: key.to_s,
         query: selector
       )
+
       result["values"]
     end
 
@@ -151,16 +152,12 @@ def count
     # @param [Array] flags an array of operation flags. Valid values are:
     #   +:multi+ and +:upsert+
     def update(change, flags = nil)
-      update = Protocol::Update.new(
-        operation.database,
-        operation.collection,
-        operation.selector,
-        change,
-        flags: flags
-      )
-
       session.with(consistency: :strong) do |session|
-        session.execute update
+        session.context.update operation.database,
+          operation.collection,
+          operation.selector,
+          change,
+          flags: flags
       end
     end
 
@@ -193,15 +190,11 @@ def upsert(change)
     # @example
     #   db[:people].find(name: "John").remove
     def remove
-      delete = Protocol::Delete.new(
-        operation.database,
-        operation.collection,
-        operation.selector,
-        flags: [:remove_first]
-      )
-
       session.with(consistency: :strong) do |session|
-        session.execute delete
+        session.context.remove operation.database,
+          operation.collection,
+          operation.selector,
+          flags: [:remove_first]
       end
     end
 
@@ -210,14 +203,10 @@ def remove
     # @example
     #   db[:people].find(name: "John").remove_all
     def remove_all
-      delete = Protocol::Delete.new(
-        operation.database,
-        operation.collection,
-        operation.selector
-      )
-
       session.with(consistency: :strong) do |session|
-        session.execute delete
+        session.context.remove operation.database,
+          operation.collection,
+          operation.selector
       end
     end
 
diff --git a/lib/moped/server.rb b/lib/moped/server.rb
deleted file mode 100644
index 3bdfcab..0000000
--- a/lib/moped/server.rb
+++ /dev/null
@@ -1,73 +0,0 @@
-module Moped
-
-  # @api private
-  #
-  # The internal class for storing information about a server.
-  class Server
-
-    # @return [String] the original host:port address provided
-    attr_reader :address
-
-    # @return [String] the resolved host:port address
-    attr_reader :resolved_address
-
-    # @return [String] the resolved ip address
-    attr_reader :ip_address
-
-    # @return [Integer] the resolved port
-    attr_reader :port
-
-    attr_writer :primary
-    attr_writer :secondary
-
-    def initialize(address)
-      @address = address
-
-      host, port = address.split(":")
-      port = port ? port.to_i : 27017
-
-      ip_address = ::Socket.getaddrinfo(host, nil, ::Socket::AF_INET, ::Socket::SOCK_STREAM).first[3]
-
-      @primary = @secondary = false
-      @ip_address = ip_address
-      @port = port
-      @resolved_address = "#{ip_address}:#{port}"
-    end
-
-    def primary?
-      !!@primary
-    end
-
-    def secondary?
-      !!@secondary
-    end
-
-    def merge(other)
-      @primary = other.primary?
-      @secondary = other.secondary?
-
-      other.close
-    end
-
-    def close
-      if @socket
-        @socket.close
-        @socket = nil
-      end
-    end
-
-    def socket
-      @socket ||= Socket.new(ip_address, port)
-    end
-
-    def ==(other)
-      self.class === other && hash == other.hash
-    end
-    alias eql? ==
-
-    def hash
-      [ip_address, port].hash
-    end
-
-  end
-end
diff --git a/lib/moped/session.rb b/lib/moped/session.rb
index 2b505bb..a4e9e46 100644
--- a/lib/moped/session.rb
+++ b/lib/moped/session.rb
@@ -37,6 +37,10 @@ class Session
     # @return [Cluster] this session's cluster
     attr_reader :cluster
 
+    # @private
+    # @return [Context] this session's context
+    attr_reader :context
+
     # @param [Array] seeds an of host:port pairs
     # @param [Hash] options
     # @option options [Boolean] :safe (false) ensure writes are persisted
@@ -45,7 +49,8 @@ class Session
     # @option options [Symbol, String] :database the database to use
     # @option options [:strong, :eventual] :consistency (:eventual)
     def initialize(seeds, options = {})
-      @cluster = Cluster.new(seeds)
+      @cluster = Cluster.new(seeds, {})
+      @context = Context.new(self)
       @options = options
       @options[:consistency] ||= :eventual
     end
@@ -55,11 +60,16 @@ def safe?
       !!safety
     end
 
+    # @return [:strong, :eventual] the session's consistency
+    def consistency
+      options[:consistency]
+    end
+
     # Switch the session's current database.
     #
     # @example
     #   session.use :moped
-    #   session[:people].     john, mary = session[:people].find.one # => { :name => "John" }
+    #   session[:people].find.one # => { :name => "John" }
     #
     # @param [String] database the database to use
     def use(database)
@@ -111,7 +121,7 @@ def with(options = {})
     # @return [Moped::Session] the new session
     def new(options = {})
       session = with(options)
-      session.cluster.reconnect
+      session.instance_variable_set(:@cluster, cluster.dup)
 
       if block_given?
         yield session
@@ -155,64 +165,6 @@ def new(options = {})
     # @raise (see Moped::Database#login)
     delegate :logout => :current_database
 
-    # @private
-    def current_database
-      return @current_database if defined? @current_database
-
-      if database = options[:database]
-        set_current_database(database)
-      else
-        raise "No database set for session. Call #use or #with before accessing the database"
-      end
-    end
-
-    # @private
-    def simple_query(query)
-      query.limit = -1
-
-      query(query).documents.first
-    end
-
-    # @private
-    def query(query)
-      if options[:consistency] == :eventual
-        query.flags |= [:slave_ok] if query.respond_to? :flags
-        mode = :read
-      else
-        mode = :write
-      end
-
-      reply = socket_for(mode).execute(query)
-
-      reply.tap do |reply|
-        if reply.flags.include?(:query_failure)
-          raise Errors::QueryFailure.new(query, reply.documents.first)
-        end
-      end
-    end
-
-    # @private
-    def execute(op)
-      mode = options[:consistency] == :eventual ? :read : :write
-      socket = socket_for(mode)
-
-      if safe?
-        last_error = Protocol::Command.new(
-          "admin", { getlasterror: 1 }.merge(safety)
-        )
-
-        socket.execute(op, last_error).documents.first.tap do |result|
-          raise Errors::OperationFailure.new(
-            op, result
-          ) if result["err"] || result["errmsg"]
-        end
-      else
-        socket.execute(op)
-      end
-    end
-
-    private
-
     # @return [Boolean, Hash] the safety level for this session
     def safety
       safe = options[:safe]
@@ -227,11 +179,15 @@ def safety
       end
     end
 
-    def socket_for(mode)
-      if options[:retain_socket]
-        @socket ||= cluster.socket_for(mode)
+    private
+
+    def current_database
+      return @current_database if defined? @current_database
+
+      if database = options[:database]
+        set_current_database(database)
       else
-        cluster.socket_for(mode)
+        raise "No database set for session. Call #use or #with before accessing the database"
       end
     end
 
@@ -239,15 +195,13 @@ def set_current_database(database)
       @current_database = Database.new(self, database)
     end
 
-    def dup
-      session = super
-      session.instance_variable_set :@options, options.dup
+    def initialize_copy(_)
+      @context = Context.new(self)
+      @options = @options.dup
 
       if defined? @current_database
-        session.send(:remove_instance_variable, :@current_database)
+        remove_instance_variable :@current_database
       end
-
-      session
     end
   end
 end
diff --git a/lib/moped/session/context.rb b/lib/moped/session/context.rb
new file mode 100644
index 0000000..759769d
--- /dev/null
+++ b/lib/moped/session/context.rb
@@ -0,0 +1,105 @@
+module Moped
+  class Session
+
+    # @api private
+    class Context
+      extend Forwardable
+
+      def initialize(session)
+        @session = session
+      end
+
+      delegate :safety => :@session
+      delegate :safe?  => :@session
+      delegate :consistency  => :@session
+      delegate :cluster  => :@session
+
+      def login(database, username, password)
+        cluster.auth[database.to_s] = [username, password]
+      end
+
+      def logout(database)
+        cluster.auth.delete database.to_s
+      end
+
+      def query(database, collection, selector, options = {})
+        if consistency == :eventual
+          options[:flags] ||= []
+          options[:flags] |= [:slave_ok]
+        end
+
+        with_node do |node|
+          node.query(database, collection, selector, options)
+        end
+      end
+
+      def command(database, command)
+        options = consistency == :eventual ? { :flags => [:slave_ok] } : {}
+        with_node do |node|
+          node.command(database, command, options)
+        end
+      end
+
+      def insert(database, collection, documents)
+        with_node do |node|
+          if safe?
+            node.pipeline do
+              node.insert(database, collection, documents)
+              node.command("admin", { getlasterror: 1 }.merge(safety))
+            end
+          else
+            node.insert(database, collection, documents)
+          end
+        end
+      end
+
+      def update(database, collection, selector, change, options = {})
+        with_node do |node|
+          if safe?
+            node.pipeline do
+              node.update(database, collection, selector, change, options)
+              node.command("admin", { getlasterror: 1 }.merge(safety))
+            end
+          else
+            node.update(database, collection, selector, change, options)
+          end
+        end
+      end
+
+      def remove(database, collection, selector, options = {})
+        with_node do |node|
+          if safe?
+            node.pipeline do
+              node.remove(database, collection, selector, options)
+              node.command("admin", { getlasterror: 1 }.merge(safety))
+            end
+          else
+            node.remove(database, collection, selector, options)
+          end
+        end
+      end
+
+      def get_more(*args)
+        raise NotImplementedError, "#get_more cannot be called on Context; it must be called directly on a node"
+      end
+
+      def kill_cursors(*args)
+        raise NotImplementedError, "#kill_cursors cannot be called on Context; it must be called directly on a node"
+      end
+
+      def with_node
+        if consistency == :eventual
+          cluster.with_secondary do |node|
+            yield node
+          end
+        else
+          cluster.with_primary do |node|
+            yield node
+          end
+        end
+      end
+
+    end
+
+  end
+end
diff --git a/lib/moped/socket.rb b/lib/moped/socket.rb
deleted file mode 100644
index abb239a..0000000
--- a/lib/moped/socket.rb
+++ /dev/null
@@ -1,201 +0,0 @@
-require "timeout"
-
-module Moped
-
-  # @api private
-  #
-  # The internal class wrapping a socket connection.
-  class Socket
-
-    # Thread-safe atomic integer.
-    class RequestId
-      def initialize
-        @mutex = Mutex.new
-        @id = 0
-      end
-
-      def next
-        @mutex.synchronize { @id += 1 }
-      end
-    end
-
-    attr_reader :connection
-
-    attr_reader :host
-    attr_reader :port
-
-    def initialize(host, port)
-      @host = host
-      @port = port
-
-      @mutex = Mutex.new
-      @request_id = RequestId.new
-    end
-
-    # @return [true, false] whether the connection was successful
-    # @note The connection timeout is currently just 0.5 seconds, which should
-    #   be sufficient, but may need to be raised or made configurable for
-    #   high-latency situations. That said, if connecting to the remote server
-    #   takes that long, we may not want to use the node any way.
-    def connect
-      return true if connection
-
-      Timeout::timeout 0.5 do
-        @connection = TCPSocket.new(host, port)
-      end
-    rescue Errno::ECONNREFUSED, Timeout::Error
-      return false
-    end
-
-    # @return [true, false] whether this socket connection is alive
-    def alive?
-      if connection
-        return false if connection.closed?
-
-        @mutex.synchronize do
-          if select([connection], nil, nil, 0)
-            !connection.eof? rescue false
-          else
-            true
-          end
-        end
-      else
-        false
-      end
-    end
-
-    # Execute the operations on the connection.
-    def execute(*ops)
-      instrument(ops) do
-        buf = ""
-
-        last = ops.each do |op|
-          op.request_id = @request_id.next
-          op.serialize buf
-        end.last
-
-        if Protocol::Query === last || Protocol::GetMore === last
-          length = nil
-
-          @mutex.synchronize do
-            connection.write buf
-
-            length, = connection.read(4).unpack('l<')
-
-            # Re-use the already allocated buffer used for writing the command.
-            connection.read(length - 4, buf)
-          end
-
-          parse_reply length, buf
-        else
-          @mutex.synchronize do
-            connection.write buf
-          end
-
-          nil
-        end
-      end
-    end
-
-    def parse_reply(length, data)
-      buffer = StringIO.new data
-
-      reply = Protocol::Reply.allocate
-
-      reply.length = length
-
-      reply.request_id,
-        reply.response_to,
-        reply.op_code,
-        reply.flags,
-        reply.cursor_id,
-        reply.offset,
-        reply.count = buffer.read(32).unpack('l4<q<l2<')
-
-      reply.documents = reply.count.times.map do
-        BSON::Document.deserialize(buffer)
-      end
-
-      reply
-    end
-
-    # Executes a simple (one result) query and returns the first document.
-    #
-    # @return [Hash] the first document in a result set.
-    def simple_query(query)
-      query = query.dup
-      query.limit = -1
-
-      execute(query).documents.first
-    end
-
-    # Manually closes the connection
-    def close
-      @mutex.synchronize do
-        connection.close if connection && !connection.closed?
-        @connection = nil
-      end
-    end
-
-    def auth
-      @auth ||= {}
-    end
-
-    def apply_auth(credentials)
-      return if auth == credentials
-      logouts = auth.keys - credentials.keys
-
-      logouts.each do |database|
-        logout database
-      end
-
-      credentials.each do |database, (username, password)|
-        login(database, username, password) unless auth[database] == [username, password]
-      end
-    end
-
-    def login(database, username, password)
-      getnonce = Protocol::Command.new(database, getnonce: 1)
-      result = simple_query getnonce
-
-      raise Errors::OperationFailure.new(getnonce, result) unless result["ok"] == 1
-
-      authenticate = Protocol::Commands::Authenticate.new(database, username, password, result["nonce"])
-      result = simple_query authenticate
-      raise Errors::OperationFailure.new(authenticate, result) unless result["ok"] == 1
-
-      auth[database.to_s] = [username, password]
-    end
-
-    def logout(database)
-      command = Protocol::Command.new(database, logout: 1)
-      result = simple_query command
-      raise Errors::OperationFailure.new(command, result) unless result["ok"] == 1
-      auth.delete(database.to_s)
-    end
-
-    def instrument(ops)
-      instrument_start = (logger = Moped.logger) && logger.debug? && Time.now
-      yield
-    ensure
-      log_operations(logger, ops, Time.now - instrument_start) if instrument_start && !$!
-    end
-
-    def log_operations(logger, ops, duration)
-      prefix  = "  MOPED: #{host}:#{port} "
-      indent  = " "*prefix.length
-      runtime = (" (%.1fms)" % duration)
-
-      if ops.length == 1
-        logger.debug prefix + ops.first.log_inspect + runtime
-      else
-        first, *middle, last = ops
-
-        logger.debug prefix + first.log_inspect
-        middle.each { |m| logger.debug indent + m.log_inspect }
-        logger.debug indent + last.log_inspect + runtime
-      end
-    end
-
-  end
-end
diff --git a/lib/moped/threaded.rb b/lib/moped/threaded.rb
new file mode 100644
index 0000000..9576f38
--- /dev/null
+++ b/lib/moped/threaded.rb
@@ -0,0 +1,32 @@
+module Moped
+
+  # This module contains logic for easy access to objects that have a lifecycle
+  # on the current thread.
+  #
+  # Extracted from Mongoid's +Threaded+ module.
+  #
+  # @api private
+  module Threaded
+    extend self
+
+    # Begin a thread-local stack for +name+.
+    def begin(name)
+      stack(name).push true
+    end
+
+    # @return [Boolean] whether the stack is being executed
+    def executing?(name)
+      !stack(name).empty?
+    end
+
+    # End the thread-local stack for +name+.
+    def end(name)
+      stack(name).pop
+    end
+
+    # @return [Array] a named, thread-local stack.
+    def stack(name)
+      Thread.current["[moped]:#{name}-stack"] ||= []
+    end
+  end
+end
diff --git a/perf/cases.rb b/perf/cases.rb
index 8d81d3c..02c1c9f 100644
--- a/perf/cases.rb
+++ b/perf/cases.rb
@@ -57,9 +57,11 @@
 profile "Insert and find one (1000x, 2 threads)" do
   2.times.map do
     Thread.new do
-      1000.times do
-        session[:people].insert(name: "John")
-        session[:people].find.one
+      session.new do |session|
+        1000.times do
+          session[:people].insert(name: "John")
+          session[:people].find.one
+        end
       end
     end
   end.each &:join
@@ -68,9 +70,11 @@
 profile "Insert and find one (1000x, 5 threads)" do
   5.times.map do |i|
     Thread.new do
-      1000.times do
-        session[:people].insert(name: "John")
-        session[:people].find.one
+      session.new do |session|
+        1000.times do
+          session[:people].insert(name: "John")
+          session[:people].find.one
+        end
       end
     end
   end.each &:join
diff --git a/spec/integration/protocol/authentication_spec.rb b/spec/integration/protocol/authentication_spec.rb
deleted file mode 100644
index ed10cc3..0000000
--- a/spec/integration/protocol/authentication_spec.rb
+++ /dev/null
@@ -1,103 +0,0 @@
-require "spec_helper"
-
-describe Moped::Protocol do
-  Protocol = Moped::Protocol
-
-  let(:connection) do
-    TCPSocket.new("localhost", 27017)
-  end
-
-  after do
-    connection.close unless connection.closed?
-  end
-
-  describe "authentication" do
-    context "when nonce is invalid" do
-      let(:auth) do
-        Protocol::Commands::Authenticate.new :admin, "user", "pass", "fakenonce"
-      end
-
-      it "fails" do
-        connection.write auth
-        reply = Protocol::Reply.deserialize(connection).documents[0]
-        reply["ok"].should eq 0.0
-      end
-    end
-
-    context "when nonce is valid but user doesn't exist" do
-      let(:nonce) do
-        command = Protocol::Command.new :admin, getnonce: 1
-        connection.write command
-        Protocol::Reply.deserialize(connection).documents[0]["nonce"]
-      end
-
-      let(:auth) do
-        Protocol::Commands::Authenticate.new :admin, "user", "pass", nonce
-      end
-
-      it "fails" do
-        connection.write auth
-        reply = Protocol::Reply.deserialize(connection).documents[0]
-        reply["ok"].should eq 0.0
-      end
-    end
-
-    context "when nonce is valid but password is wrong" do
-      let(:nonce) do
-        command = Protocol::Command.new "moped-protocol-spec", getnonce: 1
-        connection.write command
-        Protocol::Reply.deserialize(connection).documents[0]["nonce"]
-      end
-
-      let(:auth) do
-        Protocol::Commands::Authenticate.new "moped-protocol-spec",
-          "moped",
-          "pass",
-          nonce
-      end
-
-      before do
-        connection.write Protocol::Insert.new(
-          "moped-protocol-spec",
-          "system.users",
-          [{ user: "moped", pwd: Digest::MD5.hexdigest("moped:mongo:password") }]
-        )
-      end
-
-      it "fails" do
-        connection.write auth
-        reply = Protocol::Reply.deserialize(connection).documents[0]
-        reply["ok"].should eq 0.0
-      end
-    end
-
-    context "when authentication is valid" do
-      let(:nonce) do
-        command = Protocol::Command.new "moped-protocol-spec", getnonce: 1
-        connection.write command
-        Protocol::Reply.deserialize(connection).documents[0]["nonce"]
-      end
-
-      let(:auth) do
-        Protocol::Commands::Authenticate.new "moped-protocol-spec",
-          "moped",
-          "password",
-          nonce
-      end
-
-      before do
-        connection.write Protocol::Insert.new(
-          "moped-protocol-spec",
-          "system.users",
-          [{ user: "moped", pwd: Digest::MD5.hexdigest("moped:mongo:password") }]
-        )
-      end
-
-      it "succeeds" do
-        connection.write auth
-        reply = Protocol::Reply.deserialize(connection).documents[0]
-        reply["ok"].should eq 1.0
-      end
-    end
-  end
-end
diff --git a/spec/integration/protocol/protocol_spec.rb b/spec/integration/protocol/protocol_spec.rb
deleted file mode 100644
index 1be93b7..0000000
--- a/spec/integration/protocol/protocol_spec.rb
+++ /dev/null
@@ -1,58 +0,0 @@
-require "spec_helper"
-
-describe Moped::Protocol do
-  let(:Protocol) { Moped::Protocol }
-
-  let(:connection) do
-    TCPSocket.new("localhost", 27017)
-  end
-
-  after do
-    connection.close unless connection.closed?
-  end
-
-  describe "reply response flags" do
-    let(:reply) do
-      Protocol::Reply.deserialize(connection)
-    end
-
-    context "when get more is called with an invalid cursor" do
-      let(:get_more) do
-        Protocol::GetMore.new("moped-protocol", "suite", 0, 0)
-      end
-
-      specify "the cursor not found flag is set" do
-        connection.write get_more
-        reply.flags.should include :cursor_not_found
-      end
-    end
-
-    context "when query generates an error" do
-      let(:query) do
-        Protocol::Query.new "moped-protocol", "people", { '$in' => 1 }, limit: -1
-      end
-
-      specify "the query failure flag is set" do
-        connection.write query
-        reply.flags.should eq [:query_failure]
-      end
-    end
-
-    context "when mongod supports await data query option" do
-      let(:query) do
-        Protocol::Query.new "admin", "$cmd", { buildinfo: 1 }, limit: -1
-      end
-
-      specify "the await capable flag is set" do
-        connection.write query
-
-        if reply.documents[0]["version"] >= "1.6"
-          reply.flags.should eq [:await_capable]
-        else
-          reply.flags.should eq []
-        end
-      end
-    end
-
-  end
-end
diff --git a/spec/integration_spec.rb b/spec/integration_spec.rb
deleted file mode 100644
index 8abc6ec..0000000
--- a/spec/integration_spec.rb
+++ /dev/null
@@ -1,176 +0,0 @@
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Moped::Session do
-  context "with a single master node" do
-    let(:session) { Moped::Session.new ["127.0.0.1:27017"], database: "moped_test" }
-
-    after do
-      session[:people].drop if session[:people].find.count > 0
-      session.cluster.servers.each(&:close)
-    end
-
-    it "inserts and queries a single document" do
-      id = Moped::BSON::ObjectId.new
-      session[:people].insert(_id: id, name: "John")
-      john = session[:people].find(_id: id).one
-      john["_id"].should eq id
-      john["name"].should eq "John"
-    end
-
-    it "inserts and queries on utf-8 data" do
-      id = Moped::BSON::ObjectId.new
-      doc = {
-        "_id" => id,
-        "gültig" => "1",
-        "1" => "gültig",
-        "2" => :"gültig",
-        "3" => ["gültig"],
-        "4" => /gültig/
-      }
-      session[:people].insert(doc)
-      session[:people].find(_id: id).one.should eq doc
-    end
-
-    it "can explain a query" do
-      id = Moped::BSON::ObjectId.new
-      session[:people].find(_id: id).explain["cursor"].should eq("BasicCursor")
-    end
-
-    it "can explain a query with a sort" do
-      id = Moped::BSON::ObjectId.new
-      query = session[:people].find(_id: id)
-      query.sort(_id: 1).explain["cursor"].should eq("BasicCursor")
-    end
-
-    it "drops a collection" do
-      session.command(count: :people)["n"].should eq 0
-      session[:people].insert(name: "John")
-      session.command(count: :people)["n"].should eq 1
-      session[:people].drop
-      session.command(count: :people)["n"].should eq 0
-    end
-
-    it "can be inserted into safely" do
-      session.with(safe: true) do |session|
-        session[:people].insert(name: "John")["ok"].should eq 1
-      end
-    end
-
-    it "raises an error on a failed insert in safe mode" do
-      session.with(safe: true) do |session|
-        lambda do
-          session[:people].insert("$invalid" => nil)
-        end.should raise_exception(Moped::Errors::OperationFailure)
-      end
-    end
-
-    it "can sort documents" do
-      session[:people].insert([{name: "John"}, {name: "Mary"}])
-      session[:people].find.sort(_id: -1).first["name"].should eq "Mary"
-    end
-
-    it "can update documents" do
-      id = Moped::BSON::ObjectId.new
-      session[:people].insert(_id: id, name: "John")
-      mary = session[:people].find(_id: id).one
-      mary["name"].should eq "John"
-      session[:people].find(_id: id).update(name: "Mary")
-      mary = session[:people].find(_id: id).one
-      mary["_id"].should eq id
-      mary["name"].should eq "Mary"
-    end
-
-    it "can update documents safely" do
-      id = Moped::BSON::ObjectId.new
-      session[:people].insert(_id: id, name: "John")
-      mary = session[:people].find(_id: id).one
-      mary["name"].should eq "John"
-      session.with(safe: true) do |session|
-        session[:people].find(_id: id).update(name: "Mary")["ok"].should eq 1
-      end
-    end
-
-    it "can update multiple documents" do
-      session[:people].insert([{name: "John"}, {name: "Mary"}])
-      session[:people].find.update_all("$set" => { "last_name" => "Unknown" })
-
-      session[:people].find.sort(_id: -1).first["last_name"].should eq "Unknown"
-      session[:people].find.sort(_id: 1).first["last_name"].should eq "Unknown"
-    end
-
-    it "can upsert documents" do
-      session[:people].find.upsert(name: "Mary")
-      mary = session[:people].find(name: "Mary").one
-      mary["name"].should eq "Mary"
-    end
-
-    it "can delete a single document" do
-      session[:people].insert([{name: "John"}, {name: "John"}])
-      session[:people].find(name: "John").remove
-      session[:people].find.count.should eq 1
-    end
-
-    it "can delete a single document safely" do
-      session[:people].insert([{name: "John"}, {name: "John"}])
-      session.with(safe: true) do |session|
-        session[:people].find(name: "John").remove["ok"].should eq 1
-      end
-      session[:people].find.count.should eq 1
-    end
-
-    it "can delete a multiple documents" do
-      session[:people].insert([{name: "John"}, {name: "John"}])
-      session[:people].find(name: "John").remove_all
-      session[:people].find.count.should eq 0
-    end
-
-    it "can retrieve multiple documents with fixed limit" do
-      session[:people].insert([{name: "John"}, {name: "Mary"}])
-      john, mary = session[:people].find.limit(-2).sort(name: 1).to_a
-      john["name"].should eq "John"
-      mary["name"].should eq "Mary"
-    end
-
-    it "can retrieve distinct values" do
-      session[:people].insert([{name: "John"}, {name: "Mary"}])
-      values = session[:people].find.distinct(:name)
-      values.should eq [ "John", "Mary" ]
-    end
-
-    it "can retrieve no documents" do
-      session[:people].find.limit(-2).sort(name: 1).to_a.should eq []
-    end
-
-    it "can limit a result set" do
-      documents = 100.times.map { { _id: Moped::BSON::ObjectId.new } }
-      session[:people].insert(documents)
-      session[:people].find.limit(20).to_a.length.should eq 20
-    end
-
-    it "does not leave open cursors" do
-      documents = 100.times.map { { _id: Moped::BSON::ObjectId.new } }
-      session[:people].insert(documents)
-      session[:people].find.limit(20).to_a.length.should eq 20
-      status = session.command serverStatus: 1
-      status["cursors"]["totalOpen"].should eq 0
-    end
-
-    it "can retrieve large result sets" do
-      documents = 1000.times.map do
-        { _id: Moped::BSON::ObjectId.new }
-      end
-      session[:people].insert(documents)
-      session[:people].find.to_a.length.should eq 1000
-    end
-
-    it "can have multiple connections" do
-      status = session.command serverStatus: 1
-      count = status["connections"]["current"]
-      new_session = session.new
-      status = new_session.command serverStatus: 1
-      status["connections"]["current"].should eq count + 1
-    end
-  end
-end
diff --git a/spec/moped/bson/object_id_spec.rb b/spec/moped/bson/object_id_spec.rb
index 5769b00..afb56e6 100644
--- a/spec/moped/bson/object_id_spec.rb
+++ b/spec/moped/bson/object_id_spec.rb
@@ -2,15 +2,15 @@
 
 describe Moped::BSON::ObjectId do
   let(:bytes) do
-    [78, 77, 102, 52, 59, 57, 182, 132, 7, 0, 0, 1]
+    [78, 77, 102, 52, 59, 57, 182, 132, 7, 0, 0, 1].pack("C12")
   end
 
   describe ".from_string" do
 
     context "when the string is valid" do
 
-      it "initializes with the strings bytes" do
-        Moped::BSON::ObjectId.should_receive(:new).with(bytes)
+      it "initializes with the string's bytes" do
+        Moped::BSON::ObjectId.should_receive(:from_data).with(bytes)
         Moped::BSON::ObjectId.from_string "4e4d66343b39b68407000001"
       end
     end
@@ -47,14 +47,14 @@
 
   end
 
-  describe "#initialize" do
-
-    context "with data" do
-      it "sets the object id's data" do
-        Moped::BSON::ObjectId.new(bytes).data.should == bytes
-      end
+  describe "#from_time" do
+    it "sets the generation time" do
+      time = Time.at((Time.now.utc - 64800).to_i).utc
+      Moped::BSON::ObjectId.from_time(time).generation_time.should == time
     end
+  end
 
+  describe "#initialize" do
     context "with no data" do
       it "increments the id on each call" do
         Moped::BSON::ObjectId.new.should_not eq Moped::BSON::ObjectId.new
@@ -65,21 +65,13 @@
         ids[0].value.should_not eq ids[1].value
       end
     end
-
-    context "with a time" do
-      it "sets the generation time" do
-        time = Time.at((Time.now.utc - 64800).to_i).utc
-        Moped::BSON::ObjectId.new(nil, time).generation_time.should == time
-      end
-    end
-
   end
 
   describe "#==" do
 
     context "when data is identical" do
       it "returns true" do
-        Moped::BSON::ObjectId.new(bytes).should == Moped::BSON::ObjectId.new(bytes)
+        Moped::BSON::ObjectId.from_data(bytes).should == Moped::BSON::ObjectId.from_data(bytes)
       end
     end
 
@@ -95,7 +87,7 @@
 
     context "when data is identical" do
       it "returns true" do
-        Moped::BSON::ObjectId.new(bytes).should eql Moped::BSON::ObjectId.new(bytes)
+        Moped::BSON::ObjectId.from_data(bytes).should eql Moped::BSON::ObjectId.from_data(bytes)
       end
     end
 
@@ -111,7 +103,7 @@
 
     context "when data is identical" do
       it "returns the same hash" do
-        Moped::BSON::ObjectId.new(bytes).hash.should eq Moped::BSON::ObjectId.new(bytes).hash
+        Moped::BSON::ObjectId.from_data(bytes).hash.should eq Moped::BSON::ObjectId.from_data(bytes).hash
       end
     end
 
@@ -126,7 +118,7 @@
   describe "#to_s" do
 
     it "returns a hex string representation of the id" do
-      Moped::BSON::ObjectId.new(bytes).to_s.should eq "4e4d66343b39b68407000001"
+      Moped::BSON::ObjectId.from_data(bytes).to_s.should eq "4e4d66343b39b68407000001"
     end
 
   end
diff --git a/spec/moped/cluster_spec.rb b/spec/moped/cluster_spec.rb
index 4ee42a7..37eda5f 100644
--- a/spec/moped/cluster_spec.rb
+++ b/spec/moped/cluster_spec.rb
@@ -1,358 +1,319 @@
 require "spec_helper"
 
-describe Moped::Cluster do
-
-  let(:master) do
-    TCPServer.new "127.0.0.1", 0
-  end
-
-  let(:secondary_1) do
-    TCPServer.new "127.0.0.1", 0
-  end
-
-  let(:secondary_2) do
-    TCPServer.new "127.0.0.1", 0
-  end
-
-  describe "initialize" do
-    let(:cluster) do
-      Moped::Cluster.new(["127.0.0.1:27017","127.0.0.1:27018"], true)
-    end
-
-    it "stores the list of seeds" do
-      cluster.seeds.should eq ["127.0.0.1:27017", "127.0.0.1:27018"]
-    end
-
-    it "stores whether the connection is direct" do
-      cluster.direct.should be_true
-    end
-
-    it "has an empty list of primaries" do
-      cluster.primaries.should be_empty
-    end
-
-    it "has an empty list of secondaries" do
-      cluster.secondaries.should be_empty
-    end
-
-    it "has an empty list of servers" do
-      cluster.servers.should be_empty
-    end
-
-    it "has an empty list of dynamic seeds" do
-      cluster.dynamic_seeds.should be_empty
-    end
+describe Moped::Cluster, replica_set: true do
+  let(:replica_set) do
+    Moped::Cluster.new(seeds, {})
   end
 
-  describe "#sync" do
-    let(:cluster) { Moped::Cluster.new(["127.0.0.1:27017"]) }
-
-    it "syncs each seed node" do
-      server = Moped::Server.allocate
-      Moped::Server.should_receive(:new).with("127.0.0.1:27017").and_return(server)
-
-      cluster.should_receive(:sync_server).with(server).and_return([])
-      cluster.sync
-    end
-  end
-
-  describe "#sync_server" do
-    let(:cluster) { Moped::Cluster.new [""], false }
-    let(:server) { Moped::Server.new("localhost:27017") }
-    let(:socket) { Moped::Socket.new "", 99999 }
-    let(:connection) { Support::MockConnection.new }
-
-    before do
-      socket.stub(connection: connection, alive?: true)
-      server.stub(socket: socket)
+  context "when the replica set hasn't connected yet" do
+    describe "#with_primary" do
+      it "connects and yields the primary node" do
+        replica_set.with_primary do |node|
+          node.address.should eq @primary.address
+        end
+      end
     end
 
-    context "when node is not running" do
-      it "returns nothing" do
-        socket.stub(connect: false)
-
-        cluster.sync_server(server).should be_empty
+    describe "#with_secondary" do
+      it "connects and yields a secondary node" do
+        replica_set.with_secondary do |node|
+          @secondaries.map(&:address).should include node.address
+        end
       end
     end
 
-    context "when talking to a single node" do
+    context "and the primary is down" do
       before do
-        connection.pending_replies << Hash[
-          "ismaster" => true,
-          "maxBsonObjectSize" => 16777216,
-          "ok" => 1.0
-        ]
-      end
-
-      it "adds the node to the master set" do
-        cluster.sync_server server
-        cluster.primaries.should include server
+        @primary.stop
       end
-    end
-
-    context "when talking to a replica set node" do
-
-      context "that is not configured" do
-        before do
-          connection.pending_replies << Hash[
-            "ismaster" => false,
-            "secondary" => false,
-            "info" => "can't get local.system.replset config from self or any seed (EMPTYCONFIG)",
-            "isreplicaset" => true,
-            "maxBsonObjectSize" => 16777216,
-            "ok" => 1.0
-          ]
-        end
 
-        it "returns nothing" do
-          cluster.sync_server(server).should be_empty
+      describe "#with_primary" do
+        it "raises a connection error" do
+          lambda do
+            replica_set.with_primary do |node|
+              node.command "admin", ping: 1
+            end
+          end.should raise_exception(Moped::Errors::ConnectionFailure)
         end
       end
 
-      context "that is being initiated" do
-        before do
-          connection.pending_replies << Hash[
-            "ismaster" => false,
-            "secondary" => false,
-            "info" => "Received replSetInitiate - should come online shortly.",
-            "isreplicaset" => true,
-            "maxBsonObjectSize" => 16777216,
-            "ok" => 1.0
-          ]
-        end
-
-        it "raises a connection failure exception" do
-          cluster.sync_server(server).should be_empty
+      describe "#with_secondary" do
+        it "connects and yields a secondary node" do
+          replica_set.with_secondary do |node|
+            @secondaries.map(&:address).should include node.address
+          end
         end
       end
+    end
 
-      context "that is ready but not elected" do
-        before do
-          connection.pending_replies << Hash[
-            "setName" => "3fef4842b608",
-            "ismaster" => false,
-            "secondary" => false,
-            "hosts" => ["localhost:61085", "localhost:61086", "localhost:61084"],
-            "primary" => "localhost:61084",
-            "me" => "localhost:61085",
-            "maxBsonObjectSize" => 16777216,
-            "ok" => 1.0
-          ]
-        end
-
-        it "raises no exception" do
-          lambda do
-            cluster.sync_server server
-          end.should_not raise_exception
-        end
+    context "and a single secondary is down" do
+      before do
+        @secondaries.first.stop
+      end
 
-        it "adds the server to the list" do
-          cluster.sync_server server
-          cluster.servers.should include server
+      describe "#with_primary" do
+        it "connects and yields the primary node" do
+          replica_set.with_primary do |node|
+            node.address.should eq @primary.address
+          end
         end
+      end
 
-        it "returns all other known hosts" do
-          cluster.sync_server(server).should =~ ["localhost:61085", "localhost:61086", "localhost:61084"]
+      describe "#with_secondary" do
+        it "connects and yields a secondary node" do
+          replica_set.with_secondary do |node|
+            node.address.should eq @secondaries.last.address
+          end
         end
       end
+    end
 
-      context "that is ready" do
-        before do
-          connection.pending_replies << Hash[
-            "setName" => "3ff029114780",
-            "ismaster" => true,
-            "secondary" => false,
-            "hosts" => ["localhost:59246", "localhost:59248", "localhost:59247"],
-            "primary" => "localhost:59246",
-            "me" => "localhost:59246",
-            "maxBsonObjectSize" => 16777216,
-            "ok" => 1.0
-          ]
-        end
+    context "and all secondaries are down" do
+      before do
+        @secondaries.each &:stop
+      end
 
-        it "adds the node to the master set" do
-          cluster.sync_server server
-          cluster.primaries.should include server
+      describe "#with_primary" do
+        it "connects and yields the primary node" do
+          replica_set.with_primary do |node|
+            node.address.should eq @primary.address
+          end
         end
+      end
 
-        it "returns all other known hosts" do
-          cluster.sync_server(server).should =~ ["localhost:59246", "localhost:59248", "localhost:59247"]
+      describe "#with_secondary" do
+        it "connects and yields the primary node" do
+          replica_set.with_secondary do |node|
+            node.address.should eq @primary.address
+          end
         end
       end
-
     end
   end
 
-  describe "#socket_for" do
-    let(:cluster) do
-      Moped::Cluster.new ""
+  context "when the replica set is connected" do
+    before do
+      replica_set.refresh
     end
 
-    let(:server) do
-      Moped::Server.new("localhost:27017").tap do |server|
-        server.stub(socket: socket)
+    describe "#with_primary" do
+      it "connects and yields the primary node" do
+        replica_set.with_primary do |node|
+          node.address.should eq @primary.address
+        end
       end
     end
 
-    let(:socket) do
-      Moped::Socket.new("127.0.0.1", 27017).tap do |socket|
-        socket.connect
+    describe "#with_secondary" do
+      it "connects and yields a secondary node" do
+        replica_set.with_secondary do |node|
+          @secondaries.map(&:address).should include node.address
+        end
       end
     end
 
-    context "when socket is dead" do
-      let(:dead_server) do
-        Moped::Server.allocate.tap do |server|
-          server.stub(socket: dead_socket)
+    context "and the primary is down" do
+      before do
+        @primary.stop
+      end
+
+      describe "#with_primary" do
+        it "raises a connection error" do
+          lambda do
+            replica_set.with_primary do |node|
+              node.command "admin", ping: 1
+            end
+          end.should raise_exception(Moped::Errors::ConnectionFailure)
         end
       end
 
-      let(:dead_socket) do
-        Moped::Socket.new("127.0.0.1", 27017).tap do |socket|
-          socket.stub(:alive? => false)
+      describe "#with_secondary" do
+        it "connects and yields a secondary node" do
+          replica_set.with_secondary do |node|
+            @secondaries.map(&:address).should include node.address
+          end
         end
       end
+    end
 
+    context "and a single secondary is down" do
       before do
-        primaries = [server, dead_server]
-        primaries.stub(:sample).and_return(dead_server, server)
-        cluster.stub(primaries: primaries)
+        @secondaries.first.stop
       end
 
-      it "removes the socket" do
-        cluster.should_receive(:remove).with(dead_server)
-        cluster.socket_for :write
+      describe "#with_primary" do
+        it "connects and yields the primary node" do
+          replica_set.with_primary do |node|
+            node.address.should eq @primary.address
+          end
+        end
       end
 
-      it "returns the living socket" do
-        cluster.socket_for(:write).should eq socket
+      describe "#with_secondary" do
+        it "connects and yields a secondary node" do
+          replica_set.with_secondary do |node|
+            node.command "admin", ping: 1
+            node.address.should eq @secondaries.last.address
+          end
+        end
       end
     end
 
-    context "when mode is write" do
+    context "and all secondaries are down" do
       before do
-        server.primary = true
+        @secondaries.each &:stop
       end
 
-      context "and the cluster is not synced" do
-        it "syncs the cluster" do
-          cluster.should_receive(:sync) do
-            cluster.servers << server
+      describe "#with_primary" do
+        it "connects and yields the primary node" do
+          replica_set.with_primary do |node|
+            node.address.should eq @primary.address
           end
-          cluster.socket_for :write
         end
+      end
 
-        it "returns the socket" do
-          cluster.stub(:sync) { cluster.servers << server }
-          cluster.socket_for(:write).should eq socket
+      describe "#with_secondary" do
+        it "connects and yields the primary node" do
+          replica_set.with_secondary do |node|
+            node.command "admin", ping: 1
+            node.address.should eq @primary.address
+          end
         end
+      end
+    end
+  end
 
-        it "applies the cached authentication" do
-          cluster.stub(:sync) { cluster.servers << server }
-          socket.should_receive(:apply_auth).with(cluster.auth)
-          cluster.socket_for(:write)
-        end
+  context "with down interval" do
+    let(:replica_set) do
+      Moped::Cluster.new(seeds, { down_interval: 5 })
+    end
+
+    context "and all secondaries are down" do
+      before do
+        replica_set.refresh
+        @secondaries.each &:stop
+        replica_set.refresh
       end
 
-      context "and the cluster is synced" do
-        before do
-          cluster.servers << server
+      describe "#with_secondary" do
+        it "connects and yields the primary node" do
+          replica_set.with_secondary do |node|
+            node.command "admin", ping: 1
+            node.address.should eq @primary.address
+          end
         end
+      end
 
-        it "does not re-sync the cluster" do
-          cluster.should_receive(:sync).never
-          cluster.socket_for :write
+      context "when a secondary node comes back up" do
+        before do
+          @secondaries.each &:restart
         end
 
-        it "returns the socket" do
-          cluster.socket_for(:write).should eq socket
+        describe "#with_secondary" do
+          it "connects and yields the primary node" do
+            replica_set.with_secondary do |node|
+              node.command "admin", ping: 1
+              node.address.should eq @primary.address
+            end
+          end
         end
 
-        it "applies the cached authentication" do
-          socket.should_receive(:apply_auth).with(cluster.auth)
-          cluster.socket_for(:write)
+        context "and the node is ready to be retried" do
+          it "connects and yields the secondary node" do
+            Time.stub(:new).and_return(Time.now + 10)
+            replica_set.with_secondary do |node|
+              node.command "admin", ping: 1
+              @secondaries.map(&:address).should include node.address
+            end
+          end
         end
       end
     end
+  end
 
-    context "when mode is read" do
-      context "and the cluster is not synced" do
-        before do
-          server.primary = true
-        end
+  context "with only primary provided as a seed" do
+    let(:replica_set) do
+      Moped::Cluster.new([@primary.address], {})
+    end
 
-        it "syncs the cluster" do
-          cluster.should_receive(:sync) do
-            cluster.servers << server
-          end
-          cluster.socket_for :read
+    describe "#with_primary" do
+      it "connects and yields the primary node" do
+        replica_set.with_primary do |node|
+          node.address.should eq @primary.address
         end
+      end
+    end
 
-        it "applies the cached authentication" do
-          cluster.stub(:sync) { cluster.servers << server }
-          socket.should_receive(:apply_auth).with(cluster.auth)
-          cluster.socket_for(:read)
+    describe "#with_secondary" do
+      it "connects and yields a secondary node" do
+        replica_set.with_secondary do |node|
+          @secondaries.map(&:address).should include node.address
         end
       end
+    end
+  end
 
-      context "and the cluster is synced" do
-        context "and no secondaries are found" do
-          before do
-            server.primary = true
-            cluster.servers << server
-          end
-
-          it "returns the master connection" do
-            cluster.socket_for(:read).should eq socket
-          end
+  context "with only primary provided as a seed" do
+    let(:replica_set) do
+      Moped::Cluster.new([@secondaries[0].address], {})
+    end
 
-          it "applies the cached authentication" do
-            socket.should_receive(:apply_auth).with(cluster.auth)
-            cluster.socket_for(:read)
-          end
+    describe "#with_primary" do
+      it "connects and yields the primary node" do
+        replica_set.with_primary do |node|
+          node.address.should eq @primary.address
         end
+      end
+    end
 
-        context "and a slave is found" do
-          it "returns a random slave connection" do
-            secondaries = [server]
-            cluster.stub(secondaries: secondaries)
-            secondaries.should_receive(:sample).and_return(server)
-            cluster.socket_for(:read).should eq socket
-          end
-
-          it "applies the cached authentication" do
-            cluster.stub(secondaries: [server])
-            socket.should_receive(:apply_auth).with(cluster.auth)
-            cluster.socket_for(:read)
-          end
+    describe "#with_secondary" do
+      it "connects and yields a secondary node" do
+        replica_set.with_secondary do |node|
+          @secondaries.map(&:address).should include node.address
         end
       end
     end
   end
+end
 
-  describe "#login" do
-    let(:cluster) do
-      Moped::Cluster.allocate
-    end
+describe Moped::Cluster, "authentication", mongohq: :auth do
+  let(:session) do
+    Support::MongoHQ.auth_session(false)
+  end
 
-    it "adds the credentials to the auth cache" do
-      cluster.login("admin", "username", "password")
-      cluster.auth.should eq("admin" => ["username", "password"])
+  describe "logging in with valid credentials" do
+    it "logs in and processes commands" do
+      session.login *Support::MongoHQ.auth_credentials
+      session.command(ping: 1).should eq("ok" => 1)
     end
   end
 
-  describe "#logout" do
-    let(:cluster) do
-      Moped::Cluster.allocate
+  describe "logging in with invalid credentials" do
+    it "raises an AuthenticationFailure exception" do
+      session.login "invalid-user", "invalid-password"
+
+      lambda do
+        session.command(ping: 1)
+      end.should raise_exception(Moped::Errors::AuthenticationFailure)
     end
+  end
 
+  describe "logging in with valid credentials and then logging out" do
     before do
-      cluster.login("admin", "username", "password")
+      session.login *Support::MongoHQ.auth_credentials
+      session.command(ping: 1).should eq("ok" => 1)
     end
 
-    it "removes the stored credentials" do
-      cluster.logout :admin
-      cluster.auth.should be_empty
+    it "logs out" do
+      lambda do
+        session.command dbStats: 1
+      end.should_not raise_exception
+
+      session.logout
+
+      lambda do
+        session.command dbStats: 1
+      end.should raise_exception(Moped::Errors::OperationFailure)
     end
   end
 end
diff --git a/spec/moped/collection_spec.rb b/spec/moped/collection_spec.rb
index b3db63f..e995b96 100644
--- a/spec/moped/collection_spec.rb
+++ b/spec/moped/collection_spec.rb
@@ -1,92 +1,39 @@
 require "spec_helper"
 
 describe Moped::Collection do
-
   let(:session) do
-    mock(Moped::Session)
-  end
-
-  let(:database) do
-    mock(Moped::Database, session: session, name: "moped")
-  end
-
-  let(:collection) do
-    described_class.new database, :users
+    Moped::Session.new %w[127.0.0.1:27017], database: "moped_test"
   end
 
-  describe "#initialize" do
-
-    it "stores the database" do
-      collection.database.should eq database
-    end
-
-    it "stores the collection name" do
-      collection.name.should eq :users
-    end
-  end
-
-  describe "#indexes" do
-    it "returns a new indexes instance" do
-      collection.indexes.should be_an_instance_of Moped::Indexes
-    end
-  end
+  let(:scope) { object_id }
 
   describe "#drop" do
-
-    it "drops the collection" do
-      database.should_receive(:command).with(drop: :users)
-      collection.drop
-    end
-  end
-
-  describe "#find" do
-
-    let(:selector) do
-      Hash[ a: 1 ]
-    end
-
-    let(:query) do
-      mock(Moped::Query)
-    end
-
-    it "returns a new Query" do
-      Moped::Query.should_receive(:new).
-        with(collection, selector).and_return(query)
-      collection.find(selector).should eq query
+    before do
+      session.drop
+      session.command create: "users"
     end
 
-    it "defaults to an empty selector" do
-      Moped::Query.should_receive(:new).
-        with(collection, {}).and_return(query)
-      collection.find.should eq query
+    it "drops the collection" do
+      result = session[:users].drop
+      result["ns"].should eq "moped_test.users"
     end
   end
 
   describe "#insert" do
-
-    before do
-      session.should_receive(:with, :consistency => :strong).and_yield(session)
-      session.stub safe?: false
-    end
-
-    context "when passed a single document" do
-
-      it "inserts the document" do
-        session.should_receive(:execute).with do |insert|
-          insert.documents.should eq [{a: 1}]
-        end
-        collection.insert(a: 1)
-      end
+    it "inserts a single document" do
+      document = { "_id" => Moped::BSON::ObjectId.new, "scope" => scope }
+      session[:users].insert(document)
+      session[:users].find(document).one.should eq document
     end
 
-    context "when passed multiple documents" do
+    it "insert multiple documents" do
+      documents = [
+        { "_id" => Moped::BSON::ObjectId.new, "scope" => scope },
+        { "_id" => Moped::BSON::ObjectId.new, "scope" => scope }
+      ]
 
-      it "inserts the documents" do
-        session.should_receive(:execute).with do |insert|
-          insert.documents.should eq [{a: 1}, {b: 2}]
-        end
-        collection.insert([{a: 1}, {b: 2}])
-      end
+      session[:users].insert(documents)
+      session[:users].find(scope: scope).entries.should eq documents
     end
   end
 end
diff --git a/spec/moped/cursor_spec.rb b/spec/moped/cursor_spec.rb
deleted file mode 100644
index e4f2aa9..0000000
--- a/spec/moped/cursor_spec.rb
+++ /dev/null
@@ -1,237 +0,0 @@
-require "spec_helper"
-
-describe Moped::Cursor do
-  let(:session) { mock Moped::Session }
-  let(:query_operation) { Moped::Protocol::Query.allocate }
-  let(:cursor) { Moped::Cursor.new(session, query_operation) }
-
-  describe "#initialize" do
-    it "stores the session" do
-      cursor.session.should eq session
-    end
-
-    it "stores a copy of the query operation" do
-      query_operation.should_receive(:dup).and_return(query_operation)
-      cursor.query_op.should eq query_operation
-    end
-
-    describe "the get_more operation" do
-      it "inherits the query's database" do
-        cursor.get_more_op.database.should eq query_operation.database
-      end
-
-      it "inherits the query's collection" do
-        cursor.get_more_op.collection.should eq query_operation.collection
-      end
-
-      it "inherits the query's limit" do
-        cursor.get_more_op.limit.should eq query_operation.limit
-      end
-    end
-  end
-
-  describe "#more?" do
-    context "when get more operation's cursor id is 0" do
-      it "returns false" do
-        cursor.get_more_op.cursor_id = 0
-        cursor.more?.should be_false
-      end
-    end
-    context "when get more operation's cursor id is not 0" do
-      it "returns true" do
-        cursor.get_more_op.cursor_id = 123
-        cursor.more?.should be_true
-      end
-    end
-  end
-
-  describe "#limited?" do
-    context "when original query's limit is greater than 0" do
-      before do
-        query_operation.limit = 20
-      end
-
-      it "returns true" do
-        cursor.should be_limited
-      end
-    end
-
-    context "when original query's limit is not greater than 0" do
-      before do
-        query_operation.limit = 0
-      end
-
-      it "returns true" do
-        cursor.should_not be_limited
-      end
-    end
-  end
-
-  describe "#query" do
-    let(:reply) do
-      Moped::Protocol::Reply.allocate.tap do |reply|
-        reply.cursor_id = 123
-        reply.count = 1
-        reply.documents = [{"a" => 1}]
-      end
-    end
-
-    before do
-      session.stub(query: reply)
-    end
-
-    context "when query is limited" do
-      before do
-        query_operation.limit = 21
-        cursor.query query_operation
-      end
-
-      it "updates the more operation's limit" do
-        cursor.get_more_op.limit.should eq 20
-      end
-
-      it "sets the kill cursor operation's cursor id" do
-        cursor.kill_cursor_op.cursor_ids.should eq [reply.cursor_id]
-      end
-
-      it "sets the more operation's cursor id" do
-        cursor.get_more_op.cursor_id.should eq reply.cursor_id
-      end
-    end
-
-    context "when query is limited" do
-      before do
-        query_operation.limit = 0
-        cursor.query query_operation
-      end
-
-      it "does not update the more operation's limit" do
-        cursor.get_more_op.limit.should eq query_operation.limit
-      end
-
-      it "sets the kill cursor operation's cursor id" do
-        cursor.kill_cursor_op.cursor_ids.should eq [reply.cursor_id]
-      end
-
-      it "sets the more operation's cursor id" do
-        cursor.get_more_op.cursor_id.should eq reply.cursor_id
-      end
-    end
-
-    it "returns the documents" do
-      cursor.query(query_operation).should eq reply.documents
-    end
-  end
-
-  describe "#each" do
-
-    context "when query returns all available documents" do
-      let(:reply) do
-        Moped::Protocol::Reply.allocate.tap do |reply|
-          reply.cursor_id = 0
-          reply.count = 21
-          reply.documents = [{"a" => 1}]
-        end
-      end
-
-      before do
-        session.stub(query: reply)
-      end
-
-      it "yields each document" do
-        results = []
-        cursor.each { |doc| results << doc }
-        results.should eq reply.documents
-      end
-
-      it "does not get more" do
-        session.should_receive(:query).once
-        cursor.each {}
-      end
-
-      it "does not kill the cursor" do
-        cursor.should_receive(:kill).never
-        cursor.each {}
-      end
-    end
-
-    context "when query is unlimited" do
-      let(:reply) do
-        Moped::Protocol::Reply.allocate.tap do |reply|
-          reply.cursor_id = 10
-          reply.count = 10
-          reply.documents = [{"a" => 1}]
-        end
-      end
-
-      let(:get_more_reply) do
-        Moped::Protocol::Reply.allocate.tap do |reply|
-          reply.cursor_id = 0
-          reply.count = 21
-          reply.documents = [{"a" => 1}]
-        end
-      end
-
-      before do
-        session.stub(:query).and_return(reply, get_more_reply)
-      end
-
-      it "yields each document" do
-        results = []
-        cursor.each { |doc| results << doc }
-        results.should eq reply.documents + get_more_reply.documents
-      end
-
-      it "gets more twice" do
-        session.should_receive(:query).twice
-        cursor.each {}
-      end
-
-      it "does not kill the cursor" do
-        cursor.should_receive(:kill).never
-        cursor.each {}
-      end
-    end
-
-    context "when query is limited" do
-      let(:reply) do
-        Moped::Protocol::Reply.allocate.tap do |reply|
-          reply.cursor_id = 10
-          reply.count = 10
-          reply.documents = [{"a" => 1}]
-        end
-      end
-
-      let(:get_more_reply) do
-        Moped::Protocol::Reply.allocate.tap do |reply|
-          reply.cursor_id = 10
-          reply.count = 10
-          reply.documents = [{"a" => 1}]
-        end
-      end
-
-      before do
-        query_operation.limit = 20
-        session.stub(:query).and_return(reply, get_more_reply)
-        session.stub(:execute)
-      end
-
-      it "yields each document" do
-        results = []
-        cursor.each { |doc| results << doc }
-        results.should eq reply.documents + get_more_reply.documents
-      end
-
-      it "gets more twice" do
-        session.should_receive(:query).at_least(2)
-        cursor.each {}
-      end
-
-      it "kills the cursor" do
-        cursor.should_receive(:kill).once
-        cursor.each {}
-      end
-    end
-
-  end
-end
diff --git a/spec/moped/database_spec.rb b/spec/moped/database_spec.rb
deleted file mode 100644
index df0ea83..0000000
--- a/spec/moped/database_spec.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-require "spec_helper"
-
-describe Moped::Database do
-
-  let(:session) do
-    Moped::Session.new ""
-  end
-
-  let(:database) do
-    Moped::Database.new(session, :admin)
-  end
-
-  describe "#initialize" do
-
-    it "stores the session" do
-      database.session.should eq session
-    end
-
-    it "stores the database name" do
-      database.name.should eq :admin
-    end
-  end
-
-  describe "#command" do
-
-    before do
-      session.stub(:with).and_yield(session)
-    end
-
-    it "runs the given command against the master connection" do
-      session.should_receive(:with, :consistency => :strong).
-        and_yield(session)
-      session.should_receive(:simple_query) do |query|
-        query.full_collection_name.should eq "admin.$cmd"
-        query.selector.should eq(ismaster: 1)
-
-        { "ok" => 1.0 }
-      end
-
-      database.command ismaster: 1
-    end
-
-    context "when the command fails" do
-
-      it "raises an exception" do
-        session.stub(simple_query: { "ok" => 0.0 })
-
-        expect {
-          database.command ismaster: 1
-        }.to raise_exception(Moped::Errors::OperationFailure)
-      end
-    end
-  end
-
-  describe "#drop" do
-
-    it "drops the database" do
-      database.should_receive(:command).with(dropDatabase: 1)
-      database.drop
-    end
-  end
-
-  describe "#[]" do
-
-    it "returns a collection with that name" do
-      Moped::Collection.should_receive(:new).with(database, :users)
-      database[:users]
-    end
-  end
-
-  describe "#login" do
-
-    it "logs in to the database with the username and password" do
-      session.cluster.should_receive(:login).with(:admin, "username", "password")
-      database.login("username", "password")
-    end
-  end
-
-  describe "#log out" do
-
-    it "logs out from the database" do
-      session.cluster.should_receive(:logout).with(:admin)
-      database.logout
-    end
-  end
-end
diff --git a/spec/moped/errors_spec.rb b/spec/moped/errors_spec.rb
deleted file mode 100644
index 932c9da..0000000
--- a/spec/moped/errors_spec.rb
+++ /dev/null
@@ -1,91 +0,0 @@
-require "spec_helper"
-
-describe Moped::Errors do
-
-  describe "OperationFailure" do
-    let(:command) do
-      Moped::Protocol::Query.allocate
-    end
-
-    let(:error_details) do
-      { "$err"=>"invalid query", "code"=>12580 }
-    end
-
-    let(:error) do
-      described_class::OperationFailure.new(command, error_details)
-    end
-
-    describe "#initialize" do
-      it "stores the command which generated the error" do
-        error.command.should eq command
-      end
-
-      it "stores the details about the error" do
-        error.details.should eq error_details
-      end
-    end
-
-    describe "#message" do
-      it "includes the command that generated the error" do
-        error.message.should include command.inspect
-      end
-
-      context "when code is included in error details" do
-        let(:error_details) do
-          { "err" => "invalid query", "code" => 12580 }
-        end
-
-        it "includes the code" do
-          error.message.should include error_details["code"].to_s
-        end
-
-        it "includes the error code reference site" do
-          error.message.should include Moped::Errors::ERROR_REFERENCE
-        end
-
-        it "includes the error message" do
-          error.message.should include error_details["err"].inspect
-        end
-      end
-
-      context "when err is in the error details" do
-        let(:error_details) do
-          { "err" => "invalid query" }
-        end
-
-        it "includes the error message" do
-          error.message.should include error_details["err"].inspect
-        end
-      end
-
-      context "when $err is in the error details" do
-        let(:error_details) do
-          { "$err" => "not master" }
-        end
-
-        it "includes the error message" do
-          error.message.should include error_details["$err"].inspect
-        end
-      end
-
-      context "when errmsg is in the error details" do
-        let(:error_details) do
-          { "errmsg" => "invalid query" }
-        end
-
-        it "includes the error message" do
-          error.message.should include error_details["errmsg"].inspect
-        end
-      end
-    end
-
-  end
-
-  describe "QueryFailure" do
-    it "is a kind of OperationFailure" do
-      Moped::Errors::QueryFailure.ancestors.should \
-        include Moped::Errors::OperationFailure
-    end
-  end
-
-end
diff --git a/spec/moped/indexes_spec.rb b/spec/moped/indexes_spec.rb
index cfc643a..50cf353 100644
--- a/spec/moped/indexes_spec.rb
+++ b/spec/moped/indexes_spec.rb
@@ -1,126 +1,51 @@
 require "spec_helper"
 
 describe Moped::Indexes do
-  let(:session) { Moped::Session.new ["127.0.0.1:27017"], database: "moped_test" }
-  let(:indexes) do
-    described_class.new(session.current_database, :users)
-  end
-
-  after do
-    session.command(deleteIndexes: "users", index: "*")
+  let(:session) do
+    Moped::Session.new %w[127.0.0.1:27017], database: "moped_test"
   end
 
-  describe "#each" do
-    before do
-      session[:"system.indexes"].insert(ns: "moped_test.users", key: { name: 1 }, name: "name_1")
-    end
-
-    it "yields all indexes on the collection" do
-      indexes.to_a.should eq \
-        session[:"system.indexes"].find(ns: "moped_test.users").to_a
-    end
+  let(:indexes) do
+    session[:users].indexes
   end
 
-  describe "#[]" do
-    before do
-      session[:"system.indexes"].insert(ns: "moped_test.users", key: { name: 1 }, name: "name_1")
-    end
-
-    it "returns the index with the provided key" do
-      indexes[name: 1]["name"].should eq "name_1"
-    end
+  before do
+    indexes.drop
   end
 
   describe "#create" do
-    let(:key) do
-      Hash["location.latlong" => "2d", "name" => 1, "age" => -1]
-    end
-
-    context "with no options" do
-      it "creates an index with a generated name" do
-        indexes.create(key)
-        indexes[key]["name"].should eq "location.latlong_2d_name_1_age_-1"
-      end
-    end
-
-    context "with a name provided" do
-      it "creates an index with the provided name" do
-        indexes.create(key, name: "custom_index_name")
-        indexes[key]["name"].should eq "custom_index_name"
-      end
-    end
-
-    context "with background: true" do
-      it "creates an index" do
-        indexes.create(key, background: true)
-        indexes[key]["background"].should eq true
-      end
-    end
-
-    context "with dropDups: true" do
-      it "creates an index" do
-        indexes.create(key, dropDups: true)
-        indexes[key]["dropDups"].should eq true
+    context "when called without extra options" do
+      it "creates an index with no options" do
+        indexes.create name: 1
+        indexes[name: 1].should_not be_nil
       end
     end
 
-    context "with unique: true" do
-      it "creates an index" do
-        indexes.create(key, unique: true)
-        indexes[key]["unique"].should eq true
+    context "when called with extra options" do
+      it "creates an index with the extra options" do
+        indexes.create({name: 1}, {unique: true, dropDups: true})
+        index = indexes[name: 1]
+        index["unique"].should be_true
+        index["dropDups"].should be_true
       end
     end
-
-    context "with sparse: true" do
-      it "creates an index" do
-        indexes.create(key, sparse: true)
-        indexes[key]["sparse"].should eq true
-      end
-    end
-
-    context "with v: 0" do
-      it "creates an index" do
-        indexes.create(key, v: 0)
-        indexes[key]["v"].should eq 0
-      end
-    end
-
   end
 
   describe "#drop" do
-    before do
-      indexes.create name: 1
-      indexes.create age: -1
-    end
-
-    context "with no key" do
-      before do
-        indexes.drop
-      end
-
-      it "drops all indexes for the collection" do
-        indexes[name: 1].should be_nil
-        indexes[age: -1].should be_nil
+    context "when provided a key" do
+      it "drops the index" do
+        indexes.create name: 1
+        indexes.drop(name: 1).should be_true
       end
     end
 
-    context "with a key" do
-      before do
-        indexes.drop(name: 1)
-      end
-
-      it "drops the index that matches the key" do
+    context "when not provided a key" do
+      it "drops all indexes" do
+        indexes.create name: 1
+        indexes.create age: 1
+        indexes.drop
         indexes[name: 1].should be_nil
-      end
-
-      it "does not drop other indexes" do
-        indexes[age: -1].should_not be_nil
-      end
-    end
-
-    context "with a key that doesn't exist" do
-      it "returns false" do
-        indexes.drop(other: 1).should be_false
+        indexes[age: 1].should be_nil
       end
     end
   end
diff --git a/spec/moped/logging_spec.rb b/spec/moped/logging_spec.rb
deleted file mode 100644
index 9b82f79..0000000
--- a/spec/moped/logging_spec.rb
+++ /dev/null
@@ -1,83 +0,0 @@
-require "spec_helper"
-
-describe Moped::Logging do
-  let(:config) do
-    Module.new { extend Moped::Logging }
-  end
-  let(:logger) { mock(Logger) }
-
-  describe ".rails_logger" do
-    context "when Rails is present" do
-      let(:rails) { Class.new }
-
-      before do
-        Object.const_set :Rails, rails
-      end
-
-      after do
-        Object.send(:remove_const, :Rails)
-      end
-
-      context "and it defines logger" do
-        before do
-          rails.stub(logger: logger)
-        end
-
-        it "returns the logger" do
-          config.rails_logger.should eq logger
-        end
-      end
-
-      context "but does not define logger" do
-        it "returns false" do
-          config.rails_logger.should be_false
-        end
-      end
-
-    end
-  end
-
-  describe ".default_logger" do
-    it "returns a new logger instance" do
-      config.default_logger.should be_a_kind_of Logger
-    end
-
-    it "sets the log level to info" do
-      config.default_logger.level.should eq Logger::INFO
-    end
-  end
-
-  describe ".logger" do
-    context "when a rails logger is available" do
-      before do
-        config.stub(rails_logger: logger)
-      end
-
-      it "returns the rails logger" do
-        config.logger.should eq logger
-      end
-    end
-
-    context "when a rails logger is not available" do
-      before do
-        config.stub(rails_logger: nil)
-        config.stub(default_logger: logger)
-      end
-
-      it "returns the default logger" do
-        config.logger.should eq logger
-      end
-    end
-
-    context "when the logger is set to nil" do
-      before do
-        config.logger = nil
-      end
-
-      it "returns nil" do
-        config.logger.should be_nil
-      end
-    end
-  end
-
-end
diff --git a/spec/moped/node_spec.rb b/spec/moped/node_spec.rb
new file mode 100644
index 0000000..2a0dfcf
--- /dev/null
+++ b/spec/moped/node_spec.rb
@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Moped::Node, replica_set: true do
+  let(:replica_set_node) do
+    @replica_set.nodes.first
+  end
+
+  let(:node) do
+    Moped::Node.new(replica_set_node.address)
+  end
+
+  describe "#ensure_connected" do
+    context "when node is running" do
+      it "processes the block" do
+        node.ensure_connected do
+          node.command("admin", ping: 1)
+        end.should eq("ok" => 1)
+      end
+    end
+
+    context "when node is not running" do
+      before do
+        replica_set_node.stop
+      end
+
+      it "raises a connection error" do
+        lambda do
+          node.ensure_connected do
+            node.command("admin", ping: 1)
+          end
+        end.should raise_exception(Moped::Errors::ConnectionFailure)
+      end
+
+      it "marks the node as down" do
+        node.ensure_connected {} rescue nil
+        node.should be_down
+      end
+    end
+
+    context "when node is connected but connection is dropped" do
+      before do
+        node.ensure_connected do
+          node.command("admin", ping: 1)
+        end
+
+        replica_set_node.hiccup
+      end
+
+      it "reconnects without raising an exception" do
+        node.ensure_connected do
+          node.command("admin", ping: 1)
+        end.should eq("ok" => 1)
+      end
+    end
+  end
+
+end
diff --git a/spec/moped/query_spec.rb b/spec/moped/query_spec.rb
index f3ecb6f..aff94b8 100644
--- a/spec/moped/query_spec.rb
+++ b/spec/moped/query_spec.rb
@@ -1,288 +1,365 @@
 require "spec_helper"
 
 describe Moped::Query do
+  shared_examples_for "Query" do
+    let(:scope) do
+      object_id
+    end
 
-  let(:session) do
-    mock(Moped::Session)
-  end
-
-  let(:database) do
-    mock(
-      Moped::Database,
-      name: "moped",
-      session: session
-    )
-  end
-
-  let(:collection) do
-    mock(
-      Moped::Collection,
-      database: database,
-      name: "users"
-    )
-  end
-
-  let(:selector) do
-    Hash[ a: 1 ]
-  end
-
-  let(:query) do
-    described_class.new collection, selector
-  end
-
-  describe "#initialize" do
-
-    it "stores the collection" do
-      query.collection.should eq collection
+    before do
+      users.find.remove_all
     end
 
-    it "stores the selector" do
-      query.selector.should eq selector
+    let(:documents) do
+      [
+        { "_id" => Moped::BSON::ObjectId.new, "scope" => scope },
+        { "_id" => Moped::BSON::ObjectId.new, "scope" => scope }
+      ]
     end
-  end
 
-  describe "#limit" do
+    it "raises a query failure exception for invalid queries" do
+      lambda do
+        users.find("age" => { "$in" => nil }).first
+      end.should raise_exception(Moped::Errors::QueryFailure)
+    end
 
-    it "sets the query operation's limit field" do
-      query.limit(5)
-      query.operation.limit.should eq 5
+    describe "#limit" do
+      it "limits the query" do
+        users.insert(documents)
+        users.find(scope: scope).limit(1).to_a.should eq [documents.first]
+      end
     end
 
-    it "returns the query" do
-      query.limit(5).should eql query
+    describe "#skip" do
+      it "skips +n+ documents" do
+        users.insert(documents)
+        users.find(scope: scope).skip(1).to_a.should eq [documents.last]
+      end
     end
-  end
 
-  describe "#skip" do
+    describe "#sort" do
+      let(:documents) do
+        [
+          { "_id" => Moped::BSON::ObjectId.new, "scope" => scope, "n" => 0 },
+          { "_id" => Moped::BSON::ObjectId.new, "scope" => scope, "n" => 1 }
+        ]
+      end
 
-    it "sets the query operation's skip field" do
-      query.skip(5)
-      query.operation.skip.should eq 5
+      it "sorts the results" do
+        users.insert(documents)
+        users.find(scope: scope).sort(n: -1).to_a.should eq documents.reverse
+      end
     end
 
-    it "returns the query" do
-      query.skip(5).should eql query
+    describe "#distinct" do
+      let(:documents) do
+        [
+          { count: 0, scope: scope },
+          { count: 1, scope: scope },
+          { count: 1, scope: scope }
+        ]
+      end
+
+      it "returns distinct values for +key+" do
+        users.insert(documents)
+        users.find(scope: scope).distinct(:count).should =~ [0, 1]
+      end
     end
-  end
 
-  describe "#select" do
+    describe "#select" do
+      let(:documents) do
+        [
+          { "scope" => scope, "n" => 0 },
+          { "scope" => scope, "n" => 1 }
+        ]
+      end
 
-    it "sets the query operation's fields" do
-      query.select(a: 1)
-      query.operation.fields.should eq(a: 1)
+      it "changes the fields returned" do
+        users.insert(documents)
+        users.find(scope: scope).select(_id: 0).to_a.should eq documents
+      end
     end
 
-    it "returns the query" do
-      query.select(a: 1).should eql query
-    end
-  end
+    describe "#one" do
+      before do
+        users.insert(documents)
+      end
 
-  describe "#sort" do
+      it "returns the first matching document" do
+        users.find(scope: scope).one.should eq documents.first
+      end
 
-    context "when called for the first time" do
+      it "respects #skip" do
+        users.find(scope: scope).skip(1).one.should eq documents.last
+      end
 
-      it "updates the selector to mongo's advanced selector" do
-        query.sort(a: 1)
-        query.operation.selector.should eq(
-          "$query" => selector,
-          "$orderby" => { a: 1 }
-        )
+      it "respects #sort" do
+        users.find(scope: scope).sort(_id: -1).one.should eq documents.last
       end
     end
 
-    context "when called again" do
+    describe "#explain" do
+      context "when a sort exists" do
+        it "updates to a mongo advanced selector" do
+          stats = Support::Stats.collect do
+            users.find(scope: scope).sort(_id: 1).explain
+          end
+
+          operation = stats[node_for_reads].grep(Moped::Protocol::Query).last
+          operation.selector.should eq(
+            "$query" => { scope: scope },
+            "$explain" => true,
+            "$orderby" => { _id: 1 }
+          )
+        end
+      end
 
-      it "changes the $orderby" do
-        query.sort(a: 1)
-        query.sort(a: 2)
-        query.operation.selector.should eq(
-          "$query" => selector,
-          "$orderby" => { a: 2 }
-        )
+      context "when no sort exists" do
+        it "updates to a mongo advanced selector" do
+          stats = Support::Stats.collect do
+            users.find(scope: scope).explain
+          end
+
+          operation = stats[node_for_reads].grep(Moped::Protocol::Query).last
+          operation.selector.should eq(
+            "$query" => { scope: scope },
+            "$explain" => true,
+            "$orderby" => {}
+          )
+        end
       end
     end
 
-    it "returns the query" do
-      query.sort(a: 1).should eql query
-    end
-  end
+    describe "#each" do
+      it "yields each document" do
+        users.insert(documents)
+        users.find(scope: scope).each.with_index do |document, index|
+          document.should eq documents[index]
+        end
+      end
 
-  describe "#explain" do
+      context "with a limit" do
+        it "closes open cursors" do
+          users.insert(100.times.map { Hash["scope" => scope] })
 
-    before do
-      session.should_receive(:simple_query).with(query.operation)
-    end
+          stats = Support::Stats.collect do
+            users.find(scope: scope).limit(5).entries
+          end
 
-    context "when a sort exists" do
+          stats[node_for_reads].grep(Moped::Protocol::KillCursors).count.should eq 1
+        end
 
-      before do
-        query.sort(_id: 1)
       end
 
-      it "updates to a mongo advanced selector" do
-        query.explain
-        query.operation.selector.should eq(
-          "$query" => selector,
-          "$explain" => true,
-          "$orderby" => { _id: 1 }
-        )
-      end
-    end
+      context "without a limit" do
+        it "fetches more" do
+          users.insert(102.times.map { Hash["scope" => scope] })
 
-    context "when no sort exists" do
+          stats = Support::Stats.collect do
+            users.find(scope: scope).entries
+          end
 
-      it "updates to a mongo advanced selector" do
-        query.explain
-        query.operation.selector.should eq(
-          "$query" => selector,
-          "$explain" => true,
-          "$orderby" => {}
-        )
+          stats[node_for_reads].grep(Moped::Protocol::GetMore).count.should eq 1
+        end
       end
     end
-  end
 
-  describe "#one" do
+    describe "#count" do
+      let(:documents) do
+        [
+          { "_id" => Moped::BSON::ObjectId.new, "scope" => scope },
+          { "_id" => Moped::BSON::ObjectId.new, "scope" => scope },
+          { "_id" => Moped::BSON::ObjectId.new }
+        ]
+      end
 
-    it "executes a simple query" do
-      session.should_receive(:simple_query).with(query.operation)
-      query.one
+      it "returns the number of matching document" do
+        users.insert(documents)
+        users.find(scope: scope).count.should eq 2
+      end
     end
-  end
 
-  describe "#distinct" do
+    describe "#update" do
+      it "updates the first matching document" do
+        users.insert(documents)
+        users.find(scope: scope).update("$set" => { "updated" => true })
+        users.find(scope: scope, updated: true).count.should eq 1
+      end
+    end
 
-    it "executes a distinct command" do
-      database.should_receive(:command).with(
-        distinct: collection.name,
-        key: "name",
-        query: selector
-      ).and_return("values" => [ "durran", "bernerd" ])
-      query.distinct(:name)
+    describe "#update_all" do
+      it "updates all matching documents" do
+        users.insert(documents)
+        users.find(scope: scope).update_all("$set" => { "updated" => true })
+        users.find(scope: scope, updated: true).count.should eq 2
+      end
     end
-  end
 
-  describe "#count" do
+    describe "#upsert" do
+      context "when a document exists" do
+        before do
+          users.insert(scope: scope, counter: 1)
+        end
 
-    it "executes a count command" do
-      database.should_receive(:command).with(
-        count: collection.name,
-        query: selector
-      ).and_return("n" => 4)
+        it "updates the document" do
+          users.find(scope: scope).upsert("$inc" => { counter: 1 })
+          users.find(scope: scope).one["counter"].should eq 2
+        end
+      end
 
-      query.count
+      context "when no document exists" do
+        it "inserts a document" do
+          users.find(scope: scope).upsert("$inc" => { counter: 1 })
+          users.find(scope: scope).one["counter"].should eq 1
+        end
+      end
     end
 
-    it "returns the count" do
-      database.stub(command: { "n" => 4 })
+    describe "#remove" do
+      it "removes the first matching document" do
+        users.insert(documents)
+        users.find(scope: scope).remove
+        users.find(scope: scope).count.should eq 1
+      end
+    end
 
-      query.count.should eq 4
+    describe "#remove_all" do
+      it "removes all matching documents" do
+        users.insert(documents)
+        users.find(scope: scope).remove_all
+        users.find(scope: scope).count.should eq 0
+      end
     end
   end
 
-  describe "#update" do
-
-    let(:change) do
-      Hash[ a: 1 ]
+  context "with a local connection" do
+    let(:session) do
+      Moped::Session.new %w[127.0.0.1:27017], database: "moped_test"
     end
 
-    it "updates the record matching selector with change" do
-      session.should_receive(:with, :consistency => :strong).
-        and_yield(session)
+    let(:users) { session[:users] }
+    let(:node_for_reads) { :primary }
 
-      session.should_receive(:execute).with do |update|
-        update.flags.should eq []
-        update.selector.should eq query.operation.selector
-        update.update.should eq change
-      end
-
-      query.update change
-    end
-  end
+    include_examples "Query"
 
-  describe "#update_all" do
+    describe "#each" do
+      context "with a limit and large result set" do
+        it "gets more and closes cursors" do
+          11.times do
+            users.insert(scope: scope, large_field: "a"*1_000_000)
+          end
 
-    let(:change) do
-      Hash[ a: 1 ]
-    end
+          stats = Support::Stats.collect do
+            users.find(scope: scope).limit(10).entries
+          end
 
-    it "updates all records matching selector with change" do
-      query.should_receive(:update).with(change, [:multi])
-      query.update_all change
+          stats[:primary].grep(Moped::Protocol::GetMore).count.should eq 1
+          stats[:primary].grep(Moped::Protocol::KillCursors).count.should eq 1
+        end
+      end
     end
   end
 
-  describe "#upsert" do
-
-    let(:change) do
-      Hash[ a: 1 ]
+  context "with a remote connection", mongohq: :auth do
+    before :all do
+      @session = Support::MongoHQ.auth_session
     end
 
-    it "upserts the record matching selector with change" do
-      query.should_receive(:update).with(change, [:upsert])
-      query.upsert change
-    end
+    let(:users) { @session[:users] }
+    let(:node_for_reads) { :primary }
+
+    include_examples "Query"
   end
 
-  describe "#remove" do
+  context "with a remote replica set connection with eventual consistency", mongohq: :replica_set do
+    before :all do
+      @session = Support::MongoHQ.replica_set_session.with(safe: true, consistency: :eventual)
+      @session.command ping: 1
+    end
 
-    it "removes the first matching document" do
-      session.should_receive(:with, :consistency => :strong).
-        and_yield(session)
+    let(:users) { @session[:users] }
+    let(:node_for_reads) { :secondary }
 
-      session.should_receive(:execute).with do |delete|
-        delete.flags.should eq [:remove_first]
-        delete.selector.should eq query.operation.selector
-      end
-
-      query.remove
-    end
+    include_examples "Query"
   end
 
-  describe "#remove_all" do
+  context "with a remote replica set connection with strong consistency", mongohq: :replica_set do
+    before :all do
+      @session = Support::MongoHQ.replica_set_session.with(safe: true, consistency: :strong)
+    end
 
-    it "removes all matching documents" do
-      session.should_receive(:with, :consistency => :strong).
-        and_yield(session)
+    let(:users) { @session[:users] }
+    let(:node_for_reads) { :primary }
 
-      session.should_receive(:execute).with do |delete|
-        delete.flags.should eq []
-        delete.selector.should eq query.operation.selector
-      end
+    include_examples "Query"
+  end
 
-      query.remove_all
+  context "with a local replica set w/ failover", replica_set: true do
+    let(:session) do
+      Moped::Session.new seeds, database: "moped_test"
     end
-  end
 
-  describe "#each" do
+    let(:scope) do
+      object_id
+    end
 
     before do
-      session.should_receive(:with).
-        with(retain_socket: true).and_return(session)
+      # Force connection before recording stats
+      session.command ping: 1
     end
 
-    it "creates a new cursor" do
-      cursor = mock(Moped::Cursor, next: nil)
-      Moped::Cursor.should_receive(:new).
-        with(session, query.operation).and_return(cursor)
+    context "and running with eventual consistency" do
+      it "queries a secondary node" do
+        stats = Support::Stats.collect do
+          session.with(consistency: :eventual)[:users].find(scope: scope).entries
+        end
 
-      query.each
-    end
+        stats[:secondary].grep(Moped::Protocol::Query).count.should eq 1
+        stats[:primary].should be_empty
+      end
+
+      it "sets the slave ok flag" do
+        stats = Support::Stats.collect do
+          session.with(consistency: :eventual)[:users].find(scope: scope).one
+        end
+
+        query = stats[:secondary].grep(Moped::Protocol::Query).first
+        query.flags.should include :slave_ok
+      end
 
-    it "yields all documents in the cursor" do
-      cursor = Moped::Cursor.allocate
-      cursor.stub(:to_enum).and_return([1, 2].to_enum)
+      context "and no secondaries are available" do
+        before do
+          @secondaries.each &:stop
+        end
 
-      Moped::Cursor.stub(new: cursor)
+        it "queries the primary node" do
+          stats = Support::Stats.collect do
+            session.with(consistency: :eventual)[:users].find(scope: scope).entries
+          end
 
-      query.to_a.should eq [1, 2]
+          stats[:primary].grep(Moped::Protocol::Query).count.should eq 1
+        end
+      end
     end
 
-    it "returns an enumerator" do
-      cursor = mock(Moped::Cursor)
-      Moped::Cursor.stub(new: cursor)
+    context "and running with strong consistency" do
+      it "queries the primary node" do
+        stats = Support::Stats.collect do
+          session.with(consistency: :strong)[:users].find(scope: scope).entries
+        end
+
+        stats[:primary].grep(Moped::Protocol::Query).count.should eq 1
+        stats[:secondary].should be_empty
+      end
 
-      query.each.should be_a Enumerator
+      it "does not set the slave ok flag" do
+        stats = Support::Stats.collect do
+          session.with(consistency: :strong)[:users].find(scope: scope).one
+        end
+
+        query = stats[:primary].grep(Moped::Protocol::Query).first
+        query.flags.should_not include :slave_ok
+      end
     end
   end
 end
diff --git a/spec/moped/server_spec.rb b/spec/moped/server_spec.rb
deleted file mode 100644
index c9f652b..0000000
--- a/spec/moped/server_spec.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-require "spec_helper"
-
-describe Moped::Server do
-
-  describe "#initialize" do
-    let(:server) do
-      described_class.new("localhost:123")
-    end
-
-    it "stores the original address" do
-      server.address.should eq "localhost:123"
-    end
-
-    it "stores the resolved address" do
-      server.resolved_address.should eql "127.0.0.1:123"
-    end
-
-    it "stores the resolved ip" do
-      server.ip_address.should eq "127.0.0.1"
-    end
-
-    it "stores the port" do
-      server.port.should eq 123
-    end
-  end
-
-  describe "==" do
-    context "when ip and port are the same" do
-      it "returns true" do
-        described_class.new("127.0.0.1:999").should eq \
-          described_class.new("localhost:999")
-      end
-    end
-
-    context "when ip and port are different" do
-      it "returns false" do
-        described_class.new("127.0.0.1:1000").should_not eq \
-          described_class.new("localhost:999")
-      end
-    end
-
-    context "when other is not a server" do
-      it "returns false" do
-        described_class.new("127.0.0.1:999").should_not eq 1
-      end
-    end
-  end
-
-  context "when added to a set" do
-    let(:set) { Set.new }
-
-    context "and ip and port are the same" do
-      it "does not add both servers" do
-        set << described_class.new("127.0.0.1:1000")
-        set << described_class.new("127.0.0.1:1000")
-
-        set.length.should eq 1
-      end
-
-      context "and the original address is different" do
-        it "does not add both servers" do
-          set << described_class.new("localhost:1000")
-          set << described_class.new("127.0.0.1:1000")
-
-          set.length.should eq 1
-        end
-      end
-    end
-
-    context "and ip and port are different" do
-      it "adds both servers" do
-        set << described_class.new("127.0.0.1:1000")
-        set << described_class.new("127.0.0.1:2000")
-
-        set.length.should eq 2
-      end
-    end
-  end
-
-end
diff --git a/spec/moped/session_spec.rb b/spec/moped/session_spec.rb
index c389dd9..e164203 100644
--- a/spec/moped/session_spec.rb
+++ b/spec/moped/session_spec.rb
@@ -1,548 +1,63 @@
 require "spec_helper"
 
 describe Moped::Session do
-
-  let(:seeds) do
-    "127.0.0.1:27017"
-  end
-
-  let(:options) do
-    Hash[database: "test", safe: true, consistency: :eventual]
-  end
-
   let(:session) do
-    described_class.new seeds, options
-  end
-
-  describe "#initialize" do
-
-    it "stores the options provided" do
-      session.options.should eq(options)
-    end
-
-    it "stores the cluster" do
-      session.cluster.should be_a(Moped::Cluster)
-    end
-  end
-
-  describe "#current_database" do
-
-    context "when no database option has been set" do
-
-      let(:session) do
-        described_class.new seeds, {}
-      end
-
-      it "raises an exception" do
-        expect { session.current_database }.to raise_exception
-      end
-    end
-
-    context "when a database option is set" do
-
-      let(:database) do
-        stub
-      end
-
-      before do
-        Moped::Database.should_receive(:new).
-          with(session, options[:database]).and_return(database)
-      end
-
-      it "returns the database from the options" do
-        session.current_database.should eq(database)
-      end
-
-      it "memoizes the database" do
-        database = session.current_database
-        session.current_database.should equal(database)
-      end
-    end
-  end
-
-  describe "#safe?" do
-
-    context "when :safe is not present" do
-
-      before do
-        session.options.delete(:safe)
-      end
-
-      it "returns false" do
-        session.should_not be_safe
-      end
-    end
-
-    context "when :safe is present but false" do
-
-      before do
-        session.options[:safe] = false
-      end
-
-      it "returns false" do
-        session.should_not be_safe
-      end
-    end
-
-    context "when :safe is true" do
-
-      before do
-        session.options[:safe] = true
-      end
-
-      it "returns true" do
-        session.should be_safe
-      end
-    end
-
-    context "when :safe is a hash" do
-
-      before do
-        session.options[:safe] = { fsync: true }
-      end
-
-      it "returns true" do
-        session.should be_safe
-      end
-    end
+    Moped::Session.new %w[127.0.0.1:27017], database: "moped_test"
   end
 
   describe "#use" do
-
-    it "sets the :database option" do
-      session.use :admin
-      session.options[:database].should eq(:admin)
-    end
-
-    context "when there is not already a current database" do
-
-      it "sets the current database" do
-        session.should_receive(:set_current_database).with(:admin)
-        session.use :admin
-      end
+    it "changes the current database" do
+      session.use "moped_test_2"
+      session.command(dbStats: 1)["db"].should eq "moped_test_2"
     end
   end
 
   describe "#with" do
-
-    let(:new_options) do
-      Hash[database: "test-2"]
-    end
-
     context "when called with a block" do
-
-      it "yields a session" do
-        session.with(new_options) do |new_session|
-          new_session.should be_a Moped::Session
-        end
+      it "returns the value from the block" do
+        session.with { :value }.should eq :value
       end
 
-      it "yields a new session" do
-        session.with(new_options) do |new_session|
-          new_session.should_not eql session
+      it "yields a session with the provided options" do
+        session.with(safe: true) do |safe|
+          safe.options[:safe].should eq true
         end
       end
 
-      it "returns the result of the block" do
-        session.with(new_options) { false }.should eq false
-      end
-
-      it "merges the old and new session's options" do
-        session.with(new_options) do |new_session|
-          new_session.options.should eq options.merge(new_options)
-        end
-      end
-
-      it "does not change the original session's options" do
-        original_options = options.dup
-        session.with(new_options) do |new_session|
-          session.options.should eql original_options
-        end
-      end
-
-      it "unmemoizes the current database" do
-        db = session.current_database
-        session.with(new_options) do |new_session|
-          new_session.current_database.should_not eql db
+      it "does not modify the original session" do
+        session.with(database: "other") do |safe|
+          session.options[:database].should eq "moped_test"
         end
       end
     end
 
     context "when called without a block" do
-
-      it "returns a session" do
-        session.with(new_options).should be_a Moped::Session
-      end
-
-      it "returns a new session" do
-        session.with(new_options).should_not eql session
-      end
-
-      it "merges the old and new session's options" do
-        session.with(new_options).options.should eq options.merge(new_options)
-      end
-
-      it "does not change the original session's options" do
-        original_options = options.dup
-        session.with(new_options)
-        session.options.should eql original_options
-      end
-    end
-  end
-
-  describe "#new" do
-
-    let(:new_options) do
-      Hash[database: "test-2"]
-    end
-
-    let(:new_session) do
-      described_class.new seeds, options
-    end
-
-    before do
-      new_session.cluster.stub(:reconnect)
-    end
-
-    it "delegates to #with" do
-      session.should_receive(:with).with(new_options).and_return(new_session)
-      session.new(new_options)
-    end
-
-    it "instructs the cluster to reconnect" do
-      session.stub(with: new_session)
-      new_session.cluster.should_receive(:reconnect)
-      session.new(new_options)
-    end
-
-    context "when called with a block" do
-
-      it "yields the new session" do
-        session.stub(with: new_session)
-        session.new(new_options) do |session|
-          session.should eql new_session
-        end
+      it "returns a session with the provided options" do
+        safe = session.with(safe: true)
+        safe.options[:safe].should eq true
       end
-    end
 
-    context "when called without a block" do
-
-      it "returns the new session" do
-        session.stub(with: new_session)
-        session.new(new_options).should eql new_session
+      it "does not modify the original session" do
+        other = session.with(database: "other")
+        session.options[:database].should eq "moped_test"
       end
     end
   end
 
   describe "#drop" do
-
-    it "delegates to the current database" do
-      database = mock(Moped::Database)
-      session.should_receive(:current_database).and_return(database)
-      database.should_receive(:drop)
-      session.drop
-    end
-  end
-
-  describe "#command" do
-
-    let(:command) do
-      Hash[ismaster: 1]
-    end
-
-    it "delegates to the current database" do
-      database = mock(Moped::Database)
-      session.should_receive(:current_database).and_return(database)
-      database.should_receive(:command).with(command)
-      session.command command
-    end
-  end
-
-  describe "#login" do
-
-    it "delegates to the current database" do
-      database = mock(Moped::Database)
-      session.should_receive(:current_database).and_return(database)
-      database.should_receive(:login).with("username", "password")
-      session.login("username", "password")
-    end
-  end
-
-  describe "#logout" do
-
-    it "delegates to the current database" do
-      database = mock(Moped::Database)
-      session.should_receive(:current_database).and_return(database)
-      database.should_receive(:logout)
-      session.logout
-    end
-  end
-
-  describe "#socket_for" do
-
-    it "delegates to the cluster" do
-      session.cluster.should_receive(:socket_for).with(:read)
-      session.send(:socket_for, :read)
-    end
-
-    context "when retain socket option is set" do
-
-      before do
-        session.options[:retain_socket] = true
-      end
-
-      it "only aquires the socket once" do
-        session.cluster.should_receive(:socket_for).
-          with(:read).once.and_return(mock(Moped::Socket))
-
-        session.send(:socket_for, :read)
-        session.send(:socket_for, :read)
-      end
-    end
-  end
-
-  describe "#simple_query" do
-
-    let(:query) do
-      Moped::Protocol::Query.allocate
-    end
-
-    let(:socket) do
-      mock(Moped::Socket)
-    end
-
-    let(:reply) do
-      Moped::Protocol::Reply.allocate.tap do |reply|
-        reply.documents = [{a: 1}]
+    it "drops the current database" do
+      session.with(database: "moped_test_2") do |session|
+        session.drop.should eq("dropped" => "moped_test_2", "ok" => 1)
       end
     end
-
-    before do
-      session.stub(socket_for: socket)
-      session.stub(query: reply)
-    end
-
-    it "limits the query" do
-      session.should_receive(:query) do |query|
-        query.limit.should eq(-1)
-        reply
-      end
-
-      session.simple_query(query)
-    end
-
-    it "returns the document" do
-      session.simple_query(query).should eq(a: 1)
-    end
   end
 
-  describe "#query" do
-
-    let(:query) do
-      Moped::Protocol::Query.allocate
-    end
-
-    let(:socket) do
-      mock(Moped::Socket)
-    end
-
-    let(:reply) do
-      Moped::Protocol::Reply.allocate.tap do |reply|
-        reply.documents = [{a: 1}]
-      end
-    end
-
-    before do
-      session.stub(socket_for: socket)
-      socket.stub(:execute).and_return(reply)
-    end
-
-    context "when consistency is strong" do
-
-      before do
-        session.options[:consistency] = :strong
-      end
-
-      it "queries the master node" do
-        session.should_receive(:socket_for).with(:write).
-          and_return(socket)
-        session.query(query)
-      end
-    end
-
-    context "when consistency is eventual" do
-
-      before do
-        session.options[:consistency] = :eventual
-      end
-
-      it "queries a slave node" do
-        session.should_receive(:socket_for).with(:read).
-          and_return(socket)
-        session.query(query)
-      end
-
-      context "and query accepts flags" do
-
-        it "sets slave_ok on the query flags" do
-          session.stub(socket_for: socket)
-          socket.should_receive(:execute) do |query|
-            query.flags.should include :slave_ok
-          end
-
-          session.query(query)
-        end
-      end
-
-      context "and query does not accept flags" do
-
-        let(:query) do
-          Moped::Protocol::GetMore.allocate
-        end
-
-        it "doesn't try to set flags" do
-          session.stub(socket_for: socket)
-          expect { session.query(query) }.not_to raise_exception
-        end
-      end
-    end
-
-    context "when reply has :query_failure flag" do
-
-      before do
-        reply.flags = [:query_failure]
-      end
-
-      it "raises a QueryFailure exception" do
-        expect {
-          session.query(query)
-        }.to raise_exception(Moped::Errors::QueryFailure)
+  describe "#command" do
+    it "runs the command on the current database" do
+      session.with(database: "moped_test_2") do |session|
+        session.command(dbStats: 1)["db"].should eq "moped_test_2"
       end
     end
   end
 
-  describe "#execute" do
-
-    let(:operation) do
-      Moped::Protocol::Insert.allocate
-    end
-
-    let(:socket) do
-      mock(Moped::Socket)
-    end
-
-    context "when session is not in safe mode" do
-
-      before do
-        session.options[:safe] = false
-      end
-
-      context "when consistency is strong" do
-
-        before do
-          session.options[:consistency] = :strong
-        end
-
-        it "executes the operation on the master node" do
-          session.should_receive(:socket_for).with(:write).
-            and_return(socket)
-          socket.should_receive(:execute).with(operation)
-
-          session.execute(operation)
-        end
-      end
-
-      context "when consistency is eventual" do
-
-        before do
-          session.options[:consistency] = :eventual
-        end
-
-        it "executes the operation on a slave node" do
-          session.should_receive(:socket_for).with(:read).
-            and_return(socket)
-          socket.should_receive(:execute).with(operation)
-
-          session.execute(operation)
-        end
-      end
-    end
-
-    context "when session is in safe mode" do
-
-      let(:reply) do
-        Moped::Protocol::Reply.allocate.tap do |reply|
-          reply.documents = [{a: 1}]
-        end
-      end
-
-      before do
-        session.options[:safe] = { w: 2 }
-      end
-
-      context "when the operation fails" do
-
-        let(:reply) do
-          Moped::Protocol::Reply.allocate.tap do |reply|
-            reply.documents = [{
-              "err"=>"document to insert can't have $ fields",
-              "code"=>13511,
-              "n"=>0,
-              "connectionId"=>894,
-              "ok"=>1.0
-            }]
-          end
-        end
-
-        it "raises an OperationFailure exception" do
-          session.stub(socket_for: socket)
-          socket.stub(execute: reply)
-
-          expect {
-            session.execute(operation)
-          }.to raise_exception(Moped::Errors::OperationFailure)
-        end
-      end
-
-      context "when consistency is strong" do
-
-        before do
-          session.options[:consistency] = :strong
-        end
-
-        it "executes the operation on the master node" do
-          session.should_receive(:socket_for).with(:write).
-            and_return(socket)
-
-          socket.should_receive(:execute) do |op, query|
-            op.should eq operation
-            query.selector.should eq(getlasterror: 1, w: 2)
-            reply
-          end
-
-          session.execute(operation)
-        end
-      end
-
-      context "when consistency is eventual" do
-
-        before do
-          session.options[:consistency] = :eventual
-        end
-
-        it "executes the operation on a slave node" do
-          session.should_receive(:socket_for).with(:read).
-            and_return(socket)
-
-          socket.should_receive(:execute) do |op, query|
-            op.should eq operation
-            query.selector.should eq(getlasterror: 1, w: 2)
-            reply
-          end
-
-          session.execute(operation)
-        end
-      end
-    end
-  end
 end
diff --git a/spec/moped/socket_spec.rb b/spec/moped/socket_spec.rb
deleted file mode 100644
index 22be808..0000000
--- a/spec/moped/socket_spec.rb
+++ /dev/null
@@ -1,462 +0,0 @@
-require "spec_helper"
-
-describe Moped::Socket do
-
-  let!(:server) do
-    TCPServer.new "127.0.0.1", 0
-  end
-
-  let(:socket) do
-    described_class.new "127.0.0.1", server.addr[1]
-  end
-
-  let(:connection) {
-    socket.connection
-  }
-
-  before do
-    socket.connect
-  end
-
-  after do
-    connection.close if connection && !connection.closed?
-    server.close unless server.closed?
-  end
-
-  describe "#initialize" do
-    it "stores the host of the server" do
-      socket.host.should eq "127.0.0.1"
-    end
-
-    it "stores the port of the server" do
-      socket.port.should eq server.addr[1]
-    end
-
-    it "connects to the server" do
-      socket.connection.should_not be_closed
-    end
-  end
-
-  describe "#connect" do
-    context "when node is not running" do
-      let(:bogus_port) do
-        server = TCPServer.new("127.0.0.1", 0)
-        server.addr[1].tap do
-          server.close
-        end
-      end
-
-      let(:socket) do
-        described_class.new "127.0.0.1", bogus_port
-      end
-
-      it "returns false" do
-        socket.connect.should be_false
-      end
-    end
-
-    context "when connection times out" do
-      if RUBY_PLATFORM == "java"
-        let(:timeout_server) do
-          java.net.ServerSocket.new(0, 1)
-        end
-
-        let(:timeout_port) do
-          timeout_server.getLocalPort
-        end
-      else
-        let(:timeout_server) do
-          TCPServer.new("127.0.0.1", 0).tap do |server|
-            server.listen(1)
-          end
-        end
-
-        let(:timeout_port) do
-          timeout_server.addr[1]
-        end
-      end
-
-      let(:timeout_socket) do
-        described_class.new "127.0.0.1", timeout_port
-      end
-
-      before do
-        sockaddr = Socket.pack_sockaddr_in(timeout_port, '127.0.0.1')
-
-        5.times do # flood the server socket
-          ::Socket.new(::Socket::AF_INET, ::Socket::SOCK_STREAM, 0).connect_nonblock(sockaddr) rescue nil
-        end
-      end
-
-      after do
-        timeout_server.close unless timeout_server.closed?
-      end
-
-      it "returns false" do
-        timeout_socket.connect.should be_false
-      end
-    end
-  end
-
-  describe "#alive?" do
-    context "when not connected" do
-      let(:socket) do
-        described_class.new("127.0.0.1", 99999).tap do |socket|
-          socket.stub(:connect)
-        end
-      end
-
-      it "should be false" do
-        socket.should_not be_alive
-      end
-    end
-
-    context "when connected but server goes away" do
-      before do
-        remote = server.accept
-        remote.shutdown
-        # Give the socket time to be notified
-        sleep 0.1
-      end
-
-      it "should be false" do
-        socket.should_not be_alive
-      end
-    end
-
-    context "when connected but server goes away" do
-      before do
-        server.close
-        # Give the socket time to be notified
-        sleep 0.1
-      end
-
-      it "should be false" do
-        socket.should_not be_alive
-      end
-    end
-
-    context "when connect is explicitly closed" do
-      before do
-        socket.close
-      end
-
-      it "should be false" do
-        socket.should_not be_alive
-      end
-    end
-
-    context "when connected and server is open" do
-      it "should be true" do
-        socket.should be_alive
-      end
-    end
-  end
-
-  describe "#execute" do
-    let(:query) { Moped::Protocol::Query.new(:moped, :test, {}) }
-
-    context "when competing threads attempt to query" do
-      let(:messages) do
-        10.times.map do |i|
-          Moped::Protocol::Insert.new(:moped, :test, {}).tap do |query|
-            query.stub(request_id: 123)
-          end
-        end
-      end
-
-      it "never issues a partial write" do
-        socket
-
-        threads = 10.times.map do |i|
-          Thread.new do
-            Thread.current.abort_on_exception = true
-            socket.execute messages[i]
-          end
-        end
-
-        threads.each(&:join)
-
-        sock = server.accept
-        data = sock.read messages.join.length
-
-        messages.each do |message|
-          fail "server received partial write" unless data.include? message.serialize
-        end
-      end
-    end
-  end
-
-  describe "#parse_reply" do
-    let(:raw) do
-      Moped::Protocol::Reply.allocate.tap do |reply|
-        reply.request_id = 1
-        reply.response_to = 1
-        reply.op_code = 1
-        reply.flags = [:await_capable]
-        reply.offset = 4
-        reply.count = 1
-        reply.documents = [{"name" => "John"}]
-      end.serialize
-    end
-
-    let(:reply) do
-      socket.parse_reply(raw.length, raw[4..-1])
-    end
-
-    it "sets the length" do
-      reply.length.should eq raw.length
-    end
-
-    it "sets the response_to" do
-      reply.response_to.should eq 1
-    end
-
-    it "sets the request id" do
-      reply.request_id.should eq 1
-    end
-
-    it "sets the flags" do
-      reply.flags.should eq [:await_capable]
-    end
-
-    it "sets the offset" do
-      reply.offset.should eq 4
-    end
-
-    it "sets the count" do
-      reply.count.should eq 1
-    end
-
-    it "sets the documents" do
-      reply.documents.should eq [{"name" => "John"}]
-    end
-  end
-
-  describe "#close" do
-    let(:exception) { RuntimeError.new }
-    let(:callback) { stub }
-
-    it "closes the connection" do
-      connection.should_receive(:close).at_least(1)
-      socket.close
-    end
-
-    it "marks the socket as dead" do
-      socket.close
-      socket.should_not be_alive
-    end
-  end
-
-  describe "#login" do
-
-    let(:connection) do
-      Support::MockConnection.new
-    end
-
-    before do
-      socket.stub(connection: connection)
-    end
-
-    context "when authentication is successful" do
-      before do
-        # getnonce
-        connection.pending_replies << Hash["nonce" => "123", "ok" => 1]
-        # authenticate
-        connection.pending_replies << Hash["ok" => 1]
-      end
-
-      it "returns true" do
-        socket.login("admin", "username", "password").should be_true
-      end
-
-      it "adds the credentials to the auth cache" do
-        socket.login(:admin, "username", "password")
-        socket.auth.should eq("admin" => ["username", "password"])
-      end
-    end
-
-    context "when a nonce fails to generate" do
-      before do
-        # getnonce
-        connection.pending_replies << Hash["ok" => 0]
-      end
-
-      it "raises an operation failure" do
-        lambda do
-          socket.login(:admin, "username", "password")
-        end.should raise_exception(Moped::Errors::OperationFailure)
-      end
-
-      it "does not add the credentials to the auth cache" do
-        socket.login(:admin, "username", "password") rescue nil
-        socket.auth.should be_empty
-      end
-    end
-
-    context "when authentication fails" do
-      before do
-        # getnonce
-        connection.pending_replies << Hash["nonce" => "123", "ok" => 1]
-        # authenticate
-        connection.pending_replies << Hash["ok" => 0]
-      end
-
-      it "raises an operation failure" do
-        lambda do
-          socket.login(:admin, "username", "password")
-        end.should raise_exception(Moped::Errors::OperationFailure)
-      end
-
-      it "does not add the credentials to the auth cache" do
-        socket.login(:admin, "username", "password") rescue nil
-        socket.auth.should be_empty
-      end
-    end
-
-  end
-
-  describe "#logout" do
-
-    let(:connection) do
-      Support::MockConnection.new
-    end
-
-    before do
-      socket.stub(connection: connection)
-      socket.auth["admin"] = ["username", "password"]
-    end
-
-    context "when logout is successful" do
-      before do
-        connection.pending_replies << Hash["ok" => 1]
-      end
-
-      it "removes the stored credentials" do
-        socket.logout :admin
-        socket.auth.should be_empty
-      end
-    end
-
-    context "when logout is unsuccessful" do
-      before do
-        connection.pending_replies << Hash["ok" => 0]
-      end
-
-      it "does not remove the stored credentials" do
-        socket.logout :admin rescue nil
-        socket.auth.should_not be_empty
-      end
-
-      it "raises an operation failure" do
-        lambda do
-          socket.logout :admin
-        end.should raise_exception(Moped::Errors::OperationFailure)
-      end
-    end
-
-  end
-
-  describe "#apply_auth" do
-    context "when the socket is unauthenticated" do
-      it "logs in with each credential provided" do
-        socket.should_receive(:login).with("admin", "username", "password")
-        socket.should_receive(:login).with("test", "username", "password")
-
-        socket.apply_auth(
-          "admin" => ["username", "password"],
-          "test" => ["username", "password"]
-        )
-      end
-    end
-
-    context "when the socket is authenticated" do
-      before do
-        socket.auth["admin"] = ["username", "password"]
-      end
-
-      context "and a credential is unchanged" do
-        it "does nothing" do
-          socket.should_not_receive(:login)
-          socket.apply_auth("admin" => ["username", "password"])
-        end
-      end
-
-      context "and a credential changes" do
-        it "logs in with the new credentials" do
-          socket.should_receive(:login).with("admin", "newuser", "password")
-          socket.apply_auth("admin" => ["newuser", "password"])
-        end
-      end
-
-      context "and a credential is removed" do
-        it "logs out from the database" do
-          socket.should_receive(:logout).with("admin")
-          socket.apply_auth({})
-        end
-      end
-
-      context "and a credential is added" do
-        it "logs in with the added credentials" do
-          socket.should_receive(:login).with("test", "username", "password")
-          socket.apply_auth(
-            "admin" => ["username", "password"],
-            "test" => ["username", "password"]
-          )
-        end
-      end
-    end
-  end
-
-  describe "instrument" do
-
-    context "when a logger is configured in debug mode" do
-      before do
-        Moped.stub(logger: mock(Logger, debug?: true))
-      end
-
-      it "logs the operations" do
-        socket.should_receive(:log_operations).once
-        socket.instrument([]) {}
-      end
-    end
-
-    context "when a logger is configured but not in debug level" do
-      before do
-        Moped.stub(logger: mock(Logger, debug?: false))
-      end
-
-      it "does not log the operations" do
-        socket.should_receive(:log_operations).never
-        socket.instrument([]) {}
-      end
-    end
-
-    context "when no logger is configured" do
-      before do
-        Moped.stub(logger: nil)
-      end
-
-      it "does not log the operations" do
-        socket.should_receive(:log_operations).never
-        socket.instrument([]) {}
-      end
-    end
-
-    context "when an error occurs" do
-      before do
-        Moped.stub(logger: mock(Logger, debug?: true))
-      end
-
-      it "does not log the operations" do
-        socket.should_receive(:log_operations).never
-
-        lambda do
-          socket.instrument([]) { raise "inner error" }
-        end.should raise_exception("inner error")
-      end
-    end
-
-  end
-
-end
diff --git a/spec/moped_spec.rb b/spec/moped_spec.rb
deleted file mode 100644
index 671fd6c..0000000
--- a/spec/moped_spec.rb
+++ /dev/null
@@ -1 +0,0 @@
-require "spec_helper"
diff --git a/spec/replset_spec.rb b/spec/replset_spec.rb
deleted file mode 100644
index 7b9c68a..0000000
--- a/spec/replset_spec.rb
+++ /dev/null
@@ -1,106 +0,0 @@
-require "spec_helper"
-
-describe "testing" do
-  let(:cluster) { Moped::Cluster.new "", false }
-  let(:socket) { Moped::Socket.new "", 99999 }
-  let(:connection) { Support::MockConnection.new }
-
-  before do
-    socket.stub(connection: connection, alive?: true)
-  end
-
-  describe "#sync_socket" do
-  end
-end
-
-__END__
-
-# sequence for single node startup:
-#
-#   connection failure (node not up)
-
-{"ismaster" => true, "maxBsonObjectSize" => 16777216, "ok" => 1.0}
-
-# sequence for replica set startup pre-initialize:
-#
-#   connection failure
-
-{"ismaster" => false, "secondary" => false, "info" => "can't get local.system.replset config from self or any seed (EMPTYCONFIG)", "isreplicaset" => true, "maxBsonObjectSize" => 16777216, "ok" => 1.0}
-
-# sequence for replica set startup (master):
-#
-#   connection failure (node not up)
-
-{"ismaster" => false, "secondary" => false, "info" => "can't get local.system.replset config from self or any seed (EMPTYCONFIG)", "isreplicaset" => true, "maxBsonObjectSize" => 16777216, "ok" => 1.0}
-
-{"setName" => "3ff029114780", "ismaster" => false, "secondary" => true, "hosts" => ["localhost:59246", "localhost:59248", "localhost:59247"], "me" => "localhost:59246", "maxBsonObjectSize" => 16777216, "ok" => 1.0}
-
-{"ismaster" => false, "secondary" => false, "info" => "Received replSetInitiate - should come online shortly.", "isreplicaset" => true, "maxBsonObjectSize" => 16777216, "ok" => 1.0}
-
-{"setName" => "3ff029114780", "ismaster" => true, "secondary" => false, "hosts" => ["localhost:59246", "localhost:59248", "localhost:59247"], "primary" => "localhost:59246", "me" => "localhost:59246", "maxBsonObjectSize" => 16777216, "ok" => 1.0}
-
-# sequence for replica set startup (secondary):
-#
-#   connection failure (node not up)
-
-{"ismaster" => false, "secondary" => false, "info" => "can't get local.system.replset config from self or any seed (EMPTYCONFIG)", "isreplicaset" => true, "maxBsonObjectSize" => 16777216, "ok" => 1.0}
-
-{"setName" => "3fef4842b608", "ismaster" => false, "secondary" => false, "hosts" => ["localhost:61085", "localhost:61086", "localhost:61084"], "me" => "localhost:61085", "maxBsonObjectSize" => 16777216, "ok" => 1.0}
-
-{"setName" => "3fef4842b608", "ismaster" => false, "secondary" => false, "hosts" => ["localhost:61085", "localhost:61086", "localhost:61084"], "primary" => "localhost:61084", "me" => "localhost:61085", "maxBsonObjectSize" => 16777216, "ok" => 1.0}
-
-{"setName" => "3fef4842b608", "ismaster" => false, "secondary" => true, "hosts" => ["localhost:61085", "localhost:61086", "localhost:61084"], "primary" => "localhost:61084", "me" => "localhost:61085", "maxBsonObjectSize" => 16777216, "ok" => 1.0}
-
-__END__
-
-describe Moped::Cluster do
-  context "when connecting to a single seed" do
-    context "and the seed is down"
-
-    context "and that seed is primary" do
-      it "finds the primary node"
-
-      it "adds the secondary to the dynamic seeds"
-      it "adds the arbiter to the dynamic seeds"
-    end
-
-    context "and that seed is secondary" do
-      it "finds the secondary node"
-
-      it "adds the primary to the dynamic seeds"
-      it "adds the arbiter to the dynamic seeds"
-    end
-
-    context "and that seed is an arbiter" do
-      it "adds the primary to the dynamic seeds"
-      it "adds the secondary to the dynamic seeds"
-    end
-  end
-
-  context "when connected to a single seed" do
-    context "and that seed goes down" do
-      it "is able to resync from discovered nodes"
-    end
-  end
-
-  context "when connecting to a replica set" do
-    context "and the replica set is not initiated"
-    context "and the replica set is partially initiated"
-    context "and there is no master node"
-    context "and there is no secondary node"
-  end
-
-  context "when connected to a replica set" do
-    context "and the primary node goes down" do
-      it "issues reads to the secondary"
-    end
-
-    context "and the primary node changes"
-
-    context "and the secondary node goes down" do
-      it "issues inserts to the primary"
-      it "issues reads to the primary"
-    end
-  end
-
-end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 24652e6..2c7a4a7 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,9 +1,24 @@
 require "java" if RUBY_PLATFORM == "java"
-require "bundler"
-Bundler.require
+require "rspec"
 
 $:.unshift((Pathname(__FILE__).dirname.parent + "lib").to_s)
 
 require "moped"
+require "support/mongohq"
+require "support/replica_set_simulator"
+require "support/stats"
 
-require "support/mock_connection"
+RSpec.configure do |config|
+  Support::Stats.install!
+
+  config.include Support::ReplicaSetSimulator::Helpers, replica_set: true
+
+  config.filter_run_excluding mongohq: ->(value) do
+    return true if value == :replica_set && !Support::MongoHQ.replica_set_configured?
+    return true if value == :auth && !Support::MongoHQ.auth_node_configured?
+  end
+
+  unless Support::MongoHQ.replica_set_configured? || Support::MongoHQ.auth_node_configured?
+    $stderr.puts Support::MongoHQ.message
+  end
+end
diff --git a/spec/support/mock_connection.rb b/spec/support/mock_connection.rb
deleted file mode 100644
index 9e6ac4d..0000000
--- a/spec/support/mock_connection.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-module Support
-  class MockConnection
-
-    attr_reader :pending_replies
-
-    def initialize
-      @connected = true
-      @buffer = StringIO.new
-      @pending_replies = []
-    end
-
-    def write(*args)
-
-    end
-
-    def read(*args)
-      while documents = pending_replies.shift
-        reply = Moped::Protocol::Reply.allocate.tap do |reply|
-          documents = [documents] unless documents.is_a? Array
-          reply.documents = documents
-          reply.count = documents.length
-        end
-
-        reply.serialize(@buffer.string)
-      end
-
-      @buffer.read(*args)
-    end
-
-    def closed?
-      !@connected
-    end
-
-    def close
-      @connected = false
-    end
-
-  end
-end
diff --git a/spec/support/mongohq.rb b/spec/support/mongohq.rb
new file mode 100644
index 0000000..706fdcb
--- /dev/null
+++ b/spec/support/mongohq.rb
@@ -0,0 +1,61 @@
+module Support
+  module MongoHQ
+    extend self
+
+    def replica_set_configured?
+      ENV["MONGOHQ_REPL_PASS"]
+    end
+
+    def replica_set_seeds
+      [ENV["MONGOHQ_REPL_1_URL"], ENV["MONGOHQ_REPL_2_URL"]]
+    end
+
+    def replica_set_credentials
+      [ENV["MONGOHQ_REPL_USER"], ENV["MONGOHQ_REPL_PASS"]]
+    end
+
+    def replica_set_database
+      ENV["MONGOHQ_REPL_NAME"]
+    end
+
+    def replica_set_session(auth = true)
+      session = Moped::Session.new replica_set_seeds, database: replica_set_database
+      session.login *replica_set_credentials if auth
+      session
+    end
+
+    def auth_seeds
+      [ENV["MONGOHQ_SINGLE_URL"]]
+    end
+
+    def auth_node_configured?
+      ENV["MONGOHQ_SINGLE_PASS"]
+    end
+
+    def auth_credentials
+      [ENV["MONGOHQ_SINGLE_USER"], ENV["MONGOHQ_SINGLE_PASS"]]
+    end
+
+    def auth_database
+      ENV["MONGOHQ_SINGLE_NAME"]
+    end
+
+    def auth_session(auth = true)
+      session = Moped::Session.new auth_seeds, database: auth_database
+      session.login *auth_credentials if auth
+      session
+    end
+
+    def message
+      %Q{
+      ---------------------------------------------------------------------
+      Moped runs specs for authentication and replica sets against MongoHQ.
+
+      If you want to run these specs and need the credentials, contact
+      durran at gmail dot com.
+      ---------------------------------------------------------------------
+      }
+    end
+
+  end
+end
diff --git a/spec/support/replica_set_simulator.rb b/spec/support/replica_set_simulator.rb
new file mode 100644
index 0000000..eb09a60
--- /dev/null
+++ b/spec/support/replica_set_simulator.rb
@@ -0,0 +1,306 @@
+module Support
+
+  # This is a helper class for testing replica sets. It works by starting up a
+  # TCP server socket for each desired node. It then proxies all traffic
+  # between a real mongo instance and the client app, with the exception of
+  # ismaster commands, which it returns simulated responses for.
+  class ReplicaSetSimulator
+
+    module Helpers
+      def self.included(context)
+        context.before :all do
+          @replica_set = ReplicaSetSimulator.new
+          @replica_set.start
+
+          @primary, @secondaries = @replica_set.initiate
+        end
+
+        context.after :all do
+          @replica_set.stop
+        end
+
+        context.after :each do
+          @replica_set.nodes.each &:restart
+        end
+
+        context.let :seeds do
+          @replica_set.nodes.map &:address
+        end
+      end
+    end
+
+    attr_reader :nodes
+    attr_reader :manager
+
+    def initialize(nodes = 3)
+      @nodes = nodes.times.map { Node.new(self) }
+      @manager = ConnectionManager.new(@nodes)
+      @mongo = TCPSocket.new "127.0.0.1", 27017
+    end
+
+    # Start the mock replica set.
+    def start
+      @nodes.each &:start
+      @worker = Thread.start do
+        Thread.abort_on_exception = true
+        catch(:shutdown) do
+          loop do
+            Moped.logger.debug "replica_set: waiting for next client"
+            server, client = @manager.next_client
+
+            if server
+              Moped.logger.debug "replica_set: proxying incoming request to mongo"
+              server.proxy(client, @mongo)
+            else
+              Moped.logger.debug "replica_set: no requests; passing"
+              Thread.pass
+            end
+          end
+        end
+      end
+    end
+
+    # Pick a node to be master, and mark the rest as secondary
+    def initiate
+      primary, *secondaries = @nodes.shuffle
+
+      primary.promote
+      secondaries.each &:demote
+
+      return primary, secondaries
+    end
+
+    # Shut down the mock replica set.
+    def stop
+      @manager.shutdown
+      @nodes.each &:stop
+    end
+
+    class Node
+
+      attr_reader :port
+      attr_reader :host
+
+      def initialize(set)
+        @set = set
+        @primary = false
+        @secondary = false
+
+        server = TCPServer.new 0
+        @host = Socket.gethostname
+        @port = server.addr[1]
+        server.close
+      end
+
+      def ==(other)
+        @host == other.host && @port == other.port
+      end
+
+      def address
+        "#{@host}:#{@port}"
+      end
+
+      def primary?
+        @primary
+      end
+
+      def secondary?
+        @secondary
+      end
+
+      def status
+        {
+          "ismaster" => @primary,
+          "secondary" => @secondary,
+          "hosts" => @set.nodes.map(&:address),
+          "me" => address,
+          "maxBsonObjectSize" => 16777216,
+          "ok" => 1.0
+        }
+      end
+
+      def status_reply
+        reply = Moped::Protocol::Reply.new
+        reply.count = 1
+        reply.documents = [status]
+        reply
+      end
+
+      OP_QUERY = 2004
+      OP_GETMORE = 2005
+
+      # Stop and start the node.
+      def restart
+        stop
+        start
+      end
+
+      # Start the node.
+      def start
+        @server = TCPServer.new @port
+      end
+
+      # Stop the node.
+      def stop
+        if @server
+          hiccup
+
+          @server.close
+          @server = nil
+        end
+      end
+      alias close stop
+
+      def accept
+        to_io.accept
+      end
+
+      def closed?
+        !@server || @server.closed?
+      end
+
+      def to_io
+        @server
+      end
+
+      # Mark this node as secondary.
+      def demote
+        @primary = false
+        @secondary = true
+
+        hiccup
+      end
+
+      def hiccup
+        @set.manager.close_clients_for(self)
+      end
+
+      # Mark this node as primary. This also closes any open connections.
+      def promote
+        @primary = true
+        @secondary = false
+
+        hiccup
+      end
+
+      # Proxies a single message from client to the mongo connection.
+      def proxy(client, mongo)
+        incoming_message = client.read(16)
+        length, op_code = incoming_message.unpack("l<x8l<")
+        incoming_message << client.read(length - 16)
+
+        if op_code == OP_QUERY && ismaster_command?(incoming_message)
+          # Intercept the ismaster command and send our own reply.
+          client.write status_reply
+        else
+          # This is a normal command, so proxy it to the real mongo instance.
+          mongo.write incoming_message
+
+          if op_code == OP_QUERY || op_code == OP_GETMORE
+            outgoing_message = mongo.read(4)
+            length, = outgoing_message.unpack('l<')
+            outgoing_message << mongo.read(length - 4)
+
+            client.write outgoing_message
+          end
+        end
+      end
+
+      private
+
+      # Checks a message to see if it's an `ismaster` query.
+      def ismaster_command?(incoming_message)
+        data = StringIO.new(incoming_message)
+        data.read(20) # header and flags
+        data.gets("\x00") # collection name
+        data.read(8) # skip/limit
+
+        selector = Moped::BSON::Document.deserialize(data)
+        selector == { "ismaster" => 1 }
+      end
+    end
+
+    class ConnectionManager
+
+      def initialize(servers)
+        @timeout = 0.1
+        @servers = servers
+        @clients = []
+      end
+
+      def shutdown
+        @servers.each &:close
+        @clients.each &:close
+        @shutdown = true
+      end
+
+      def next_client
+        throw :shutdown if @shutdown
+
+        begin
+          servers = @servers.reject &:closed?
+          clients =  @clients.reject &:closed?
+          Moped.logger.debug "replica_set: selecting on connections"
+          readable, _, errors = Kernel.select(servers + clients, nil, clients, @timeout)
+        rescue IOError, Errno::EBADF, TypeError
+          # Looks like we hit a bad file descriptor or closed connection.
+          Moped.logger.debug "replica_set: io error, retrying"
+          retry
+        end
+
+        return unless readable || errors
+
+        errors.each do |client|
+          client.close
+          @clients.delete client
+        end
+
+        clients, servers = readable.partition { |s| s.class == TCPSocket }
+
+        servers.each do |server|
+          Moped.logger.debug "replica_set: accepting new client for #{server.port}"
+          @clients << server.accept
+        end
+
+        Moped.logger.debug "replica_set: closing dead clients"
+        closed, open = clients.partition &:eof?
+        closed.each { |client| @clients.delete client }
+
+        if client = open.shift
+          Moped.logger.debug "replica_set: finding server for client"
+          server = lookup_server(client)
+
+          Moped.logger.debug "replica_set: sending client #{client.inspect} to #{server.port}"
+          return server, client
+        else
+          nil
+        end
+      end
+
+      def close_clients_for(server)
+        Moped.logger.debug "replica_set: closing open clients on #{server.port}"
+
+        @clients.reject! do |client|
+          port = client.addr(false)[1]
+
+          if port == server.port
+            client.close
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def lookup_server(client)
+        port = client.addr(false)[1]
+
+        @servers.find do |server|
+          server.to_io && server.to_io.addr[1] == port
+        end
+      end
+
+    end
+
+  end
+end
diff --git a/spec/support/stats.rb b/spec/support/stats.rb
new file mode 100644
index 0000000..af8cb79
--- /dev/null
+++ b/spec/support/stats.rb
@@ -0,0 +1,51 @@
+module Support
+
+  # Module for recording operations.
+  #
+  #   Support::Stats.install!
+  #
+  #   stats = Support::Stats.collect do
+  #     session.with(safe: true)[:users].insert({})
+  #   end
+  #
+  #   ops = stats["127.0.0.1:27017"]
+  #   ops.size # => 2
+  #   ops[0].class # => Moped::Protocol::Insert
+  #   ops[1].class # => Moped::Protocol::Command
+  #
+  module Stats
+    extend self
+
+    def record(node, operations)
+      key = if node.primary?
+        :primary
+      elsif node.secondary?
+        :secondary
+      else
+        :other
+      end
+
+      @stats[key].concat(operations) if @stats
+    end
+
+    def collect
+      @stats = Hash.new { |hash, key| hash[key] = [] }
+      yield
+      @stats
+    ensure
+      @stats = nil
+    end
+
+    def install!
+      Moped::Node.class_eval <<-EOS
+        alias _logging logging
+
+        def logging(operations, &block)
+          Support::Stats.record(self, operations)
+          _logging(operations, &block)
+        end
+      EOS
+    end
+
+  end
+end",
"url": "https://github.com/mongoid/moped/commit/dd5a7c14b5d2e466f7875d079af71ad19774609b.patch"
}
] |
n/a
|
|
GHSA-4q53-fqhc-cr46
|
ember-source Cross-site Scripting vulnerability
| null |
[
{
"commit_message": "[PATCH] [SECURITY CVE-2014-0046] Ensure link-to non-block escapes title. packages/ember-routing/lib/helpers/link_to.js | 11 +++++++++- packages/ember/tests/helpers/link_to_test.js | 22 +++++++++++++++++++ 2 files changed, 32 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/emberjs/ember.js/commit/45ee8df2a0efc0afe233d6b9b17045782a2e6b2d.patch"
},
{
"commit_message": "[PATCH] [SECURITY CVE-2014-0046] Ensure link-to non-block escapes title. packages/ember-routing/lib/helpers/link_to.js | 11 +++++++++- packages/ember/tests/helpers/link_to_test.js | 22 +++++++++++++++++++ 2 files changed, 32 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/emberjs/ember.js/commit/94b28b8773acf894c4d7d7fccf4411a706292436.patch"
},
{
"commit_message": "[PATCH] [SECURITY CVE-2014-0046] Ensure link-to non-block escapes title. Conflicts: packages/ember-routing/lib/helpers/link_to.js packages/ember/tests/helpers/link_to_test.js packages/ember-routing/lib/helpers/link_to.js | 11 +++++++++- packages/ember/tests/helpers/link_to_test.js | 22 +++++++++++++++++++ 2 files changed, 32 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/emberjs/ember.js/commit/ab3199e68e1d0fc3c8f7f453cd38c51fe02af90b.patch"
}
] | null |
CVE-2018-6335
|
A Malformed h2 frame can cause 'std::out_of_range' exception when parsing priority meta data. This behavior can lead to denial-of-service. This affects all supported versions of HHVM (3.25.2, 3.24.6, and 3.21.10 and below) when using the proxygen server to handle HTTP2 requests.
|
[
{
"commit_message": "[PATCH] [security][CVE-2018-6335] Fix potential crash in HTTP2 padding handling CVE-2018-6335 patches/proxygen-CVE-2018-6335.patch | 100 +++++++++++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 patches/proxygen-CVE-2018-6335.patch",
"patch_text_b64": "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",
"url": "https://github.com/facebook/hhvm/commit/4cb57dd753a339654ca464c139db9871fe961d56.patch"
}
] |
Denial of Service (CWE-400)
|
|
CVE-2019-18985
|
Pimcore before 6.2.2 lacks brute force protection for the 2FA token.
|
[
{
"commit_message": "[PATCH] Brute-force attack protection for 2fa codes .../AdminBundle/Controller/Admin/LoginController.php | 11 +++++++---- .../AdminBundle/Controller/Admin/UserController.php | 2 -- 2 files changed, 7 insertions(+), 6 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/pimcore/pimcore/commit/9f2d075243a8392c114d9a8028858b9faf041e2d.patch"
}
] |
n/a
|
|
CVE-2020-26286
|
Arbitary file upload
|
HedgeDoc is a collaborative platform for writing and sharing markdown. In HedgeDoc before version 1.7.1 an unauthenticated attacker can upload arbitrary files to the upload storage backend including HTML, JS and PHP files. The problem is patched in HedgeDoc 1.7.1. You should however verify that your uploaded file storage only contains files that are allowed, as uploaded files might still be served. As workaround it's possible to block the `/uploadimage` endpoint on your instance using your reverse proxy. And/or restrict MIME-types and file names served from your upload file storage.
|
[
{
"commit_message": "[PATCH 1/5] Fix arbitary file upload for uploadimage API endpoint This patch fixes a security issue with all existing CodiMD and HedgeDoc installation which allows arbitary file uploads to instances that expose the `/uploadimage` API endpoint. With the patch it implies the same restrictions on the MIME-types as the frontend does. Means only images are allowed unless configured differently. This issue was reported by Thomas Lambertz. To verify if you are vulnerable or not, create two files `test.html` and `test.png` and try to upload them to your hedgedoc installation. ``` curl -X POST -F \"image=@$(pwd)/test.html\" http://localhost:3000/uploadimage curl -X POST -F \"image=@$(pwd)/test.png\" http://localhost:3000/uploadimage ``` Note: Not all backends are affected. Imgur and lutim should prevent this by their own upload API. But S3, minio, filesystem and azure, will be at risk. Addition Note: When using filesystem instead of an external uploads providers, there is a higher risk of code injections as the default CSP do not block JS from the main domain. References: https://github.com/hedgedoc/hedgedoc/security/advisories/GHSA-wcr3-xhv7-8gxc Signed-off-by: Christoph Kern <sheogorath@shivering-isles.com> lib/web/imageRouter/index.js | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)",
"patch_text_b64": "From dc29a286e665555cccb92760908e50cd967fd2e7 Mon Sep 17 00:00:00 2001
From: Sheogorath <sheogorath@shivering-isles.com>
Date: Mon, 23 Nov 2020 12:42:19 +0100
Subject: [PATCH 1/5] Fix arbitary file upload for uploadimage API endpoint

This patch fixes a security issue with all existing CodiMD and HedgeDoc
installation which allows arbitary file uploads to instances that expose
the `/uploadimage` API endpoint. With the patch it implies the same
restrictions on the MIME-types as the frontend does. Means only images
are allowed unless configured differently.

This issue was reported by Thomas Lambertz.

To verify if you are vulnerable or not, create two files `test.html` and
`test.png` and try to upload them to your hedgedoc installation.

```
curl -X POST -F "image=@$(pwd)/test.html" http://localhost:3000/uploadimage
curl -X POST -F "image=@$(pwd)/test.png" http://localhost:3000/uploadimage
```

Note: Not all backends are affected. Imgur and lutim should prevent this
by their own upload API. But S3, minio, filesystem and azure, will be at
risk.

Addition Note: When using filesystem instead of an external uploads
providers, there is a higher risk of code injections as the default CSP
do not block JS from the main domain.

References:
https://github.com/hedgedoc/hedgedoc/security/advisories/GHSA-wcr3-xhv7-8gxc

Signed-off-by: Christoph Kern <sheogorath@shivering-isles.com>
---
 lib/web/imageRouter/index.js | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/lib/web/imageRouter/index.js b/lib/web/imageRouter/index.js
index aa02e9b099..b5c486c3f5 100644
--- a/lib/web/imageRouter/index.js
+++ b/lib/web/imageRouter/index.js
@@ -20,9 +20,15 @@ imageRouter.post('/uploadimage', function (req, res) {
   }
 
   form.parse(req, function (err, fields, files) {
-    if (err || !files.image || !files.image.path) {
+    if (err) {
       logger.error(`formidable error: ${err}`)
-      errors.errorForbidden(res)
+      return errors.errorForbidden(res)
+    } else if (!files.image || !files.image.path) {
+      logger.error(`formidable error: Upload didn't contain file)`)
+      return errors.errorBadRequest(res)
+    } else if (!config.allowedUploadMimeTypes.includes(files.image.type)) {
+      logger.error(`formidable error: MIME-type "${files.image.type}" of uploaded file not allowed, only "${config.allowedUploadMimeTypes.join(', ')}" are allowed)`)
+      return errors.errorBadRequest(res)
     } else {
       logger.debug(`SERVER received uploadimage: ${JSON.stringify(files.image)}`)
 

From d097211c545118ac13626e1b0a01390b08880ad7 Mon Sep 17 00:00:00 2001
From: Sheogorath <sheogorath@shivering-isles.com>
Date: Mon, 23 Nov 2020 12:50:39 +0100
Subject: [PATCH 2/5] Fix unauthenticated file uploads

This patch fixes the issue of unauthenticated users, being able to
upload files, even when anonymous edits are disabled.

It's implemented by blocking uploads when either `allowAnonymous` is set
to `false` for all unauthenticated users, unless `allowAnonymousEdits`
is set to true, to make sure anonymous editors still experience the full
feature set.

Signed-off-by: Christoph Kern <sheogorath@shivering-isles.com>
---
 lib/web/imageRouter/index.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/lib/web/imageRouter/index.js b/lib/web/imageRouter/index.js
index b5c486c3f5..f456fd3079 100644
--- a/lib/web/imageRouter/index.js
+++ b/lib/web/imageRouter/index.js
@@ -23,6 +23,9 @@ imageRouter.post('/uploadimage', function (req, res) {
     if (err) {
       logger.error(`formidable error: ${err}`)
       return errors.errorForbidden(res)
+  } else if (!req.isAuthenticated() && !config.allowAnonymous && !config.allowAnonymousEdits) {
+      logger.error(`formidable error: Anonymous edits and therefore uploads are not allowed)`)
+      return errors.errorForbidden(res)
     } else if (!files.image || !files.image.path) {
       logger.error(`formidable error: Upload didn't contain file)`)
       return errors.errorBadRequest(res)

From f83e4d66ed2b6a7f7f8939e2eb63d262387e9374 Mon Sep 17 00:00:00 2001
From: Sheogorath <sheogorath@shivering-isles.com>
Date: Mon, 23 Nov 2020 13:59:50 +0100
Subject: [PATCH 3/5] Rework error messages for image uploads

This patch reworks the error messages for image uploads to make more
sense.

Instead of using the current `formidable error` for everything, all
custom error detection now provide the (hopefully) more useful `Image
Upload error` prefix for error messages.

Signed-off-by: Christoph Kern <sheogorath@shivering-isles.com>
---
 lib/web/imageRouter/index.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/web/imageRouter/index.js b/lib/web/imageRouter/index.js
index f456fd3079..b6ace4a64b 100644
--- a/lib/web/imageRouter/index.js
+++ b/lib/web/imageRouter/index.js
@@ -21,16 +21,16 @@ imageRouter.post('/uploadimage', function (req, res) {
 
   form.parse(req, function (err, fields, files) {
     if (err) {
-      logger.error(`formidable error: ${err}`)
+      logger.error(`Image upload error: formidable error: ${err}`)
       return errors.errorForbidden(res)
   } else if (!req.isAuthenticated() && !config.allowAnonymous && !config.allowAnonymousEdits) {
-      logger.error(`formidable error: Anonymous edits and therefore uploads are not allowed)`)
+      logger.error(`Image upload error: Anonymous edits and therefore uploads are not allowed)`)
       return errors.errorForbidden(res)
     } else if (!files.image || !files.image.path) {
-      logger.error(`formidable error: Upload didn't contain file)`)
+      logger.error(`Image upload error: Upload didn't contain file)`)
       return errors.errorBadRequest(res)
     } else if (!config.allowedUploadMimeTypes.includes(files.image.type)) {
-      logger.error(`formidable error: MIME-type "${files.image.type}" of uploaded file not allowed, only "${config.allowedUploadMimeTypes.join(', ')}" are allowed)`)
+      logger.error(`Image upload error: MIME-type "${files.image.type}" of uploaded file not allowed, only "${config.allowedUploadMimeTypes.join(', ')}" are allowed)`)
       return errors.errorBadRequest(res)
     } else {
       logger.debug(`SERVER received uploadimage: ${JSON.stringify(files.image)}`)

From cf4344d9e031d2e0bf70b8d8f75ab27ecf8d29ad Mon Sep 17 00:00:00 2001
From: David Mehren <git@herrmehren.de>
Date: Sun, 27 Dec 2020 11:31:01 +0100
Subject: [PATCH 4/5] Improve MIME-type checks of uploaded files

This commit adds a check if the MIME-type of the uploaded file (detected using the magic bytes) matches the file extension.

Signed-off-by: David Mehren <git@herrmehren.de>
---
 lib/web/imageRouter/index.js |  26 ++-
 package.json                 |   1 +
 yarn.lock                    | 324 ++++++++++++++++++++++++++++++-----
 3 files changed, 302 insertions(+), 49 deletions(-)

diff --git a/lib/web/imageRouter/index.js b/lib/web/imageRouter/index.js
index b6ace4a64b..5861a2bc8a 100644
--- a/lib/web/imageRouter/index.js
+++ b/lib/web/imageRouter/index.js
@@ -2,6 +2,8 @@
 
 const Router = require('express').Router
 const formidable = require('formidable')
+const path = require('path')
+const FileType = require('file-type')
 
 const config = require('../../config')
 const logger = require('../../logger')
@@ -9,6 +11,23 @@ const errors = require('../../errors')
 
 const imageRouter = module.exports = Router()
 
+async function checkUploadType (filePath) {
+  const typeFromMagic = await FileType.fromFile(filePath)
+  if (typeFromMagic === undefined) {
+    logger.error(`Image upload error: Could not determine MIME-type`)
+    return false
+  }
+  if (path.extname(filePath) !== '.' + typeFromMagic.ext) {
+    logger.error(`Image upload error: Provided file extension does not match MIME-type`)
+    return false
+  }
+  if (!config.allowedUploadMimeTypes.includes(typeFromMagic.mime)) {
+    logger.error(`Image upload error: MIME-type "${typeFromMagic.mime}" of uploaded file not allowed, only "${config.allowedUploadMimeTypes.join(', ')}" are allowed`)
+    return false
+  }
+  return true
+}
+
 // upload image
 imageRouter.post('/uploadimage', function (req, res) {
   var form = new formidable.IncomingForm()
@@ -19,18 +38,17 @@ imageRouter.post('/uploadimage', function (req, res) {
     form.uploadDir = config.uploadsPath
   }
 
-  form.parse(req, function (err, fields, files) {
+  form.parse(req, async function (err, fields, files) {
     if (err) {
       logger.error(`Image upload error: formidable error: ${err}`)
       return errors.errorForbidden(res)
-  } else if (!req.isAuthenticated() && !config.allowAnonymous && !config.allowAnonymousEdits) {
+    } else if (!req.isAuthenticated() && !config.allowAnonymous && !config.allowAnonymousEdits) {
       logger.error(`Image upload error: Anonymous edits and therefore uploads are not allowed)`)
       return errors.errorForbidden(res)
     } else if (!files.image || !files.image.path) {
       logger.error(`Image upload error: Upload didn't contain file)`)
       return errors.errorBadRequest(res)
-    } else if (!config.allowedUploadMimeTypes.includes(files.image.type)) {
-      logger.error(`Image upload error: MIME-type "${files.image.type}" of uploaded file not allowed, only "${config.allowedUploadMimeTypes.join(', ')}" are allowed)`)
+    } else if (!await checkUploadType(files.image.path)) {
       return errors.errorBadRequest(res)
     } else {
       logger.debug(`SERVER received uploadimage: ${JSON.stringify(files.image)}`)
diff --git a/package.json b/package.json
index e90ec03c4e..c77045abff 100644
--- a/package.json
+++ b/package.json
@@ -43,6 +43,7 @@
     "express": ">=4.14",
     "express-session": "^1.14.2",
     "file-saver": "^1.3.3",
+    "file-type": "^16.1.0",
     "flowchart.js": "^1.6.4",
     "fork-awesome": "^1.1.3",
     "formidable": "^1.0.17",
diff --git a/yarn.lock b/yarn.lock
index 9ff34ceead..d25d68a6ec 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -106,6 +106,11 @@
   resolved "https://registry.yarnpkg.com/@passport-next/passport-strategy/-/passport-strategy-1.1.0.tgz#4c0df069e2ec9262791b9ef1e23320c1d73bdb74"
   integrity sha512-2KhFjtPueJG6xVj2HnqXt9BlANOfYCVLyu+pXYjPGBDT8yk+vQwc/6tsceIj+mayKcoxMau2JimggXRPHgoc8w==
 
+"@tokenizer/token@^0.1.0", "@tokenizer/token@^0.1.1":
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/@tokenizer/token/-/token-0.1.1.tgz#f0d92c12f87079ddfd1b29f614758b9696bc29e3"
+  integrity sha512-XO6INPbZCxdprl+9qa/AAbFFOMzzwqYxpjPgLICrMD6C2FCw6qfJOPcBk6JqqPLSaZ/Qx87qn4rpPmPMwaAK6w==
+
 "@types/anymatch@*":
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/@types/anymatch/-/anymatch-1.3.1.tgz#336badc1beecb9dacc38bea2cf32adf627a8421a"
@@ -126,6 +131,11 @@
   dependencies:
     "@types/node" "*"
 
+"@types/debug@^4.1.5":
+  version "4.1.5"
+  resolved "https://registry.yarnpkg.com/@types/debug/-/debug-4.1.5.tgz#b14efa8852b7768d898906613c23f688713e02cd"
+  integrity sha512-Q1y515GcOdTHgagaVFhHnIFQ38ygs/kmxdNpvpou+raI9UO3YZcHDngBSYKQklcKlvA7iuQlmIKbzvmxcOE9CQ==
+
 "@types/express-serve-static-core@*":
   version "4.17.13"
   resolved "https://registry.yarnpkg.com/@types/express-serve-static-core/-/express-serve-static-core-4.17.13.tgz#d9af025e925fc8b089be37423b8d1eac781be084"
@@ -219,7 +229,7 @@
   resolved "https://registry.yarnpkg.com/@types/range-parser/-/range-parser-1.2.3.tgz#7ee330ba7caafb98090bece86a5ee44115904c2c"
   integrity sha512-ewFXqrQHlFsgc09MK5jP5iR7vumV/BYayNC6PgJO2LPe8vrnNFyjQjSppfEngITi0qvfKtzFvgKymGheFM9UOA==
 
-"@types/readable-stream@^2.3.5":
+"@types/readable-stream@^2.3.5", "@types/readable-stream@^2.3.9":
   version "2.3.9"
   resolved "https://registry.yarnpkg.com/@types/readable-stream/-/readable-stream-2.3.9.tgz#40a8349e6ace3afd2dd1b6d8e9b02945de4566a9"
   integrity sha512-sqsgQqFT7HmQz/V5jH1O0fvQQnXAJO46Gg9LRO/JPfjmVmGUlcx831TZZO3Y3HtWhIkzf3kTsNT0Z0kzIhIvZw==
@@ -668,7 +678,7 @@ are-we-there-yet@~1.1.2:
     delegates "^1.0.0"
     readable-stream "^2.0.6"
 
-argparse@^1.0.7:
+argparse@^1.0.10, argparse@^1.0.7:
   version "1.0.10"
   resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
   integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
@@ -836,10 +846,17 @@ atob@^2.1.2:
   resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
   integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
 
-aws-sdk@^2.521.0:
-  version "2.815.0"
-  resolved "https://registry.yarnpkg.com/aws-sdk/-/aws-sdk-2.815.0.tgz#515ead6d0d242f603171faf30c49142fd53a53d9"
-  integrity sha512-BXL3Og97rOY9jE7OeYQdKftMAZ3SneFg/rBslyog+W0dTDKq3NBuM3fBWhc3POf26kHcFjsnLIWScM8bWhD4AA==
+autolinker@^3.11.0:
+  version "3.14.2"
+  resolved "https://registry.yarnpkg.com/autolinker/-/autolinker-3.14.2.tgz#71856274eb768fb7149039e24d3a2be2f5c55a63"
+  integrity sha512-VO66nXUCZFxTq7fVHAaiAkZNXRQ1l3IFi6D5P7DLoyIEAn2E8g7TWbyEgLlz1uW74LfWmu1A17IPWuPQyGuNVg==
+  dependencies:
+    tslib "^1.9.3"
+
+aws-sdk@^2.345.0:
+  version "2.817.0"
+  resolved "https://registry.yarnpkg.com/aws-sdk/-/aws-sdk-2.817.0.tgz#3a97b690b0ec494cf8ee927affb3973cf26abcc8"
+  integrity sha512-DZIdWpkcqbqsCz0MEskHsyFaqc6Tk9XIFqXAg1AKHbOgC8nU45bz+Y2osX77pU01JkS/G7OhGtGmlKDrOPvFwg==
   dependencies:
     buffer "4.9.2"
     events "1.1.1"
@@ -1772,7 +1789,7 @@ browserslist@^4.0.0:
     escalade "^3.1.1"
     node-releases "^1.1.66"
 
-buffer-crc32@^0.2.1, buffer-crc32@^0.2.13:
+buffer-crc32@^0.2.1, buffer-crc32@^0.2.13, buffer-crc32@~0.2.3:
   version "0.2.13"
   resolved "https://registry.yarnpkg.com/buffer-crc32/-/buffer-crc32-0.2.13.tgz#0d333e3f00eac50aa1454abd30ef8c2a5d9a7242"
   integrity sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI=
@@ -2353,6 +2370,11 @@ commander@2.15.1:
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.15.1.tgz#df46e867d0fc2aec66a34662b406a9ccafff5b0f"
   integrity sha512-VlfT9F3V0v+jr4yxPc5gg9s62/fIVWsd2Bk2iD435um1NlGMYdVCq+MjcXnhYq2icNOizHr1kK+5TI6H0Hy0ag==
 
+commander@^3.0.0:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-3.0.2.tgz#6837c3fb677ad9933d1cfba42dd14d5117d6b39e"
+  integrity sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow==
+
 commander@^4.1.1:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/commander/-/commander-4.1.1.tgz#9fd602bd936294e9e9ef46a3f4d6964044b18068"
@@ -2418,7 +2440,7 @@ concat-map@0.0.1:
   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
   integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
 
-concat-stream@^1.4.8, concat-stream@^1.5.0:
+concat-stream@^1.4.7, concat-stream@^1.4.8, concat-stream@^1.5.0, concat-stream@^1.6.2:
   version "1.6.2"
   resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34"
   integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==
@@ -2536,13 +2558,6 @@ cookiejar@2.0.6:
   resolved "https://registry.yarnpkg.com/cookiejar/-/cookiejar-2.0.6.tgz#0abf356ad00d1c5a219d88d44518046dd026acfe"
   integrity sha1-Cr81atANHFohnYjURRgEbdAmrP4=
 
-copy-anything@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/copy-anything/-/copy-anything-2.0.1.tgz#2afbce6da684bdfcbec93752fa762819cb480d9a"
-  integrity sha512-lA57e7viQHOdPQcrytv5jFeudZZOXuyk47lZym279FiDQ8jeZomXiGuVf6ffMKkJ+3TIai3J1J3yi6M+/4U35g==
-  dependencies:
-    is-what "^3.7.1"
-
 copy-concurrently@^1.0.0:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/copy-concurrently/-/copy-concurrently-1.0.5.tgz#92297398cae34937fcafd6ec8139c18051f0b5e0"
@@ -2560,10 +2575,10 @@ copy-descriptor@^0.1.0:
   resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"
   integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=
 
-copy-webpack-plugin@6.4.1:
-  version "6.4.1"
-  resolved "https://registry.yarnpkg.com/copy-webpack-plugin/-/copy-webpack-plugin-6.4.1.tgz#138cd9b436dbca0a6d071720d5414848992ec47e"
-  integrity sha512-MXyPCjdPVx5iiWyl40Va3JGh27bKzOTNY3NjUTrosD2q7dR/cLD0013uqJ3BpFbUjyONINjb6qI7nDIJujrMbA==
+copy-webpack-plugin@6.3.2:
+  version "6.3.2"
+  resolved "https://registry.yarnpkg.com/copy-webpack-plugin/-/copy-webpack-plugin-6.3.2.tgz#0e920a6c181a5052aa6e2861b164bda03f83afeb"
+  integrity sha512-MgJ1uouLIbDg4ST1GzqrGQyKoXY5iPqi6fghFqarijam7FQcBa/r6Rg0VkoIuzx75Xq8iAMghyOueMkWUQ5OaA==
   dependencies:
     cacache "^15.0.5"
     fast-glob "^3.2.4"
@@ -3487,6 +3502,11 @@ dtrace-provider@~0.8:
   dependencies:
     nan "^2.14.0"
 
+duplexer@^0.1.1:
+  version "0.1.2"
+  resolved "https://registry.yarnpkg.com/duplexer/-/duplexer-0.1.2.tgz#3abe43aef3835f8ae077d136ddce0f276b0400e6"
+  integrity sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==
+
 duplexify@^3.4.2, duplexify@^3.6.0:
   version "3.7.1"
   resolved "https://registry.yarnpkg.com/duplexify/-/duplexify-3.7.1.tgz#2a4df5317f6ccfd91f86d6fd25d8d8a103b88309"
@@ -3739,6 +3759,11 @@ es6-iterator@^2.0.3, es6-iterator@~2.0.3:
     es5-ext "^0.10.35"
     es6-symbol "^3.1.1"
 
+es6-promise@^4.0.3:
+  version "4.2.8"
+  resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-4.2.8.tgz#4eb21594c972bc40553d276e510539143db53e0a"
+  integrity sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==
+
 es6-symbol@^3.1.1, es6-symbol@~3.1.3:
   version "3.1.3"
   resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.3.tgz#bad5d3c1bcdac28269f4cb331e431c78ac705d18"
@@ -4156,6 +4181,16 @@ extglob@^2.0.4:
     snapdragon "^0.8.1"
     to-regex "^3.0.1"
 
+extract-zip@^1.6.5:
+  version "1.7.0"
+  resolved "https://registry.yarnpkg.com/extract-zip/-/extract-zip-1.7.0.tgz#556cc3ae9df7f452c493a0cfb51cc30277940927"
+  integrity sha512-xoh5G1W/PB0/27lXgMQyIhP5DSY/LhoCsOyZgb+6iMmRtCwVBo55uKaMoEYrDCKQhWvqEip5ZPKAc6eFNyf/MA==
+  dependencies:
+    concat-stream "^1.6.2"
+    debug "^2.6.9"
+    mkdirp "^0.5.4"
+    yauzl "^2.10.0"
+
 extsprintf@1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.2.0.tgz#5ad946c22f5b32ba7f8cd7426711c6e8a3fc2529"
@@ -4217,6 +4252,13 @@ fault@^1.0.0, fault@^1.0.2:
   dependencies:
     format "^0.2.0"
 
+fd-slicer@~1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/fd-slicer/-/fd-slicer-1.1.0.tgz#25c7c89cb1f9077f8891bbe61d8f390eae256f1e"
+  integrity sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=
+  dependencies:
+    pend "~1.2.0"
+
 feature-policy@0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/feature-policy/-/feature-policy-0.3.0.tgz#7430e8e54a40da01156ca30aaec1a381ce536069"
@@ -4266,6 +4308,16 @@ file-saver@^1.3.3:
   resolved "https://registry.yarnpkg.com/file-saver/-/file-saver-1.3.8.tgz#e68a30c7cb044e2fb362b428469feb291c2e09d8"
   integrity sha512-spKHSBQIxxS81N/O21WmuXA2F6wppUCsutpzenOeZzOCCJ5gEfcbqJP983IrpLXzYmXnMUa6J03SubcNPdKrlg==
 
+file-type@^16.1.0:
+  version "16.1.0"
+  resolved "https://registry.yarnpkg.com/file-type/-/file-type-16.1.0.tgz#1c8a4458b2103e07d2b49ae7f76384abafe86529"
+  integrity sha512-G4Klqf6tuprtG0pC4r9kni4Wv8XhAAsfHphVqsQGA+YiOlPAO40BZduDqKfv0RFsu9q9ZbFObWfwszY/NqhEZw==
+  dependencies:
+    readable-web-to-node-stream "^3.0.0"
+    strtok3 "^6.0.3"
+    token-types "^2.0.0"
+    typedarray-to-buffer "^3.1.5"
+
 file-uri-to-path@1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
@@ -4511,6 +4563,15 @@ fs-constants@^1.0.0:
   resolved "https://registry.yarnpkg.com/fs-constants/-/fs-constants-1.0.0.tgz#6be0de9be998ce16af8afc24497b9ee9b7ccd9ad"
   integrity sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==
 
+fs-extra@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-1.0.0.tgz#cd3ce5f7e7cb6145883fcae3191e9877f8587950"
+  integrity sha1-zTzl9+fLYUWIP8rjGR6Yd/hYeVA=
+  dependencies:
+    graceful-fs "^4.1.2"
+    jsonfile "^2.1.0"
+    klaw "^1.0.0"
+
 fs-extra@^7.0.1:
   version "7.0.1"
   resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-7.0.1.tgz#4f189c44aa123b895f722804f55ea23eadc348e9"
@@ -4764,7 +4825,7 @@ good-listener@^1.2.2:
   dependencies:
     delegate "^3.1.2"
 
-graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.4, graceful-fs@^4.1.6, graceful-fs@^4.2.0:
+graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.4, graceful-fs@^4.1.6, graceful-fs@^4.1.9, graceful-fs@^4.2.0:
   version "4.2.4"
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.4.tgz#2256bde14d3632958c465ebc96dc467ca07a29fb"
   integrity sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw==
@@ -4905,6 +4966,14 @@ hash.js@^1.0.0, hash.js@^1.0.3:
     inherits "^2.0.3"
     minimalistic-assert "^1.0.1"
 
+hasha@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/hasha/-/hasha-2.2.0.tgz#78d7cbfc1e6d66303fe79837365984517b2f6ee1"
+  integrity sha1-eNfL/B5tZjA/55g3NlmEUXsvbuE=
+  dependencies:
+    is-stream "^1.0.1"
+    pinkie-promise "^2.0.0"
+
 he@1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/he/-/he-1.1.1.tgz#93410fd21b009735151f8868c2f271f3427e23fd"
@@ -4957,7 +5026,7 @@ hide-powered-by@1.1.0:
   resolved "https://registry.yarnpkg.com/hide-powered-by/-/hide-powered-by-1.1.0.tgz#be3ea9cab4bdb16f8744be873755ca663383fa7a"
   integrity sha512-Io1zA2yOA1YJslkr+AJlWSf2yWFkKjvkcL9Ni1XSUqnGLr/qRQe2UI3Cn/J9MsJht7yEVCe0SscY1HgVMujbgg==
 
-highlight.js@^9.12.0:
+highlight.js@^9.12.0, highlight.js@^9.15.9:
   version "9.18.5"
   resolved "https://registry.yarnpkg.com/highlight.js/-/highlight.js-9.18.5.tgz#d18a359867f378c138d6819edfc2a8acd5f29825"
   integrity sha512-a5bFyofd/BHCX52/8i8uJkjr9DYwXIPnM/plwI6W7ezItLGqzt7X2G2nXuYSfsIJdkwwj/g9DG1LkcGJI/dDoA==
@@ -5653,6 +5722,11 @@ is-resolvable@^1.0.0:
   resolved "https://registry.yarnpkg.com/is-resolvable/-/is-resolvable-1.1.0.tgz#fb18f87ce1feb925169c9a407c19318a3206ed88"
   integrity sha512-qgDYXFSR5WvEfuS5dMj6oTMEbrrSaM0CrFk2Yiq/gXnBvD9pMa2jGXxyhGLfvhZpuMZe18CJpFxAt3CRs42NMg==
 
+is-stream@^1.0.1:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
+  integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ=
+
 is-stream@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.0.tgz#bde9c32680d6fae04129d6ac9d921ce7815f78e3"
@@ -5677,16 +5751,11 @@ is-symbol@^1.0.2:
   dependencies:
     has-symbols "^1.0.1"
 
-is-typedarray@~1.0.0:
+is-typedarray@^1.0.0, is-typedarray@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
   integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=
 
-is-what@^3.7.1:
-  version "3.12.0"
-  resolved "https://registry.yarnpkg.com/is-what/-/is-what-3.12.0.tgz#f4405ce4bd6dd420d3ced51a026fb90e03705e55"
-  integrity sha512-2ilQz5/f/o9V7WRWJQmpFYNmQFZ9iM+OXRonZKcYgTkCzjb949Vi4h282PD1UfmgHk666rcWonbRJ++KI41VGw==
-
 is-whitespace-character@^1.0.0:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/is-whitespace-character/-/is-whitespace-character-1.0.4.tgz#0858edd94a95594c7c9dd0b5c174ec6e45ee4aa7"
@@ -5941,6 +6010,13 @@ json5@^2.0.0, json5@^2.1.2:
   dependencies:
     minimist "^1.2.5"
 
+jsonfile@^2.1.0:
+  version "2.4.0"
+  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-2.4.0.tgz#3736a2b428b87bbda0cc83b53fa3d633a35c2ae8"
+  integrity sha1-NzaitCi4e72gzIO1P6PWM6NcKug=
+  optionalDependencies:
+    graceful-fs "^4.1.6"
+
 jsonfile@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb"
@@ -5988,6 +6064,11 @@ jws@3.x.x:
     jwa "^1.4.1"
     safe-buffer "^5.0.1"
 
+kew@^0.7.0:
+  version "0.7.0"
+  resolved "https://registry.yarnpkg.com/kew/-/kew-0.7.0.tgz#79d93d2d33363d6fdd2970b335d9141ad591d79b"
+  integrity sha1-edk9LTM2PW/dKXCzNdkUGtWR15s=
+
 keymaster@^1.6.2:
   version "1.6.2"
   resolved "https://registry.yarnpkg.com/keymaster/-/keymaster-1.6.2.tgz#e1ae54d0ea9488f9f60b66b668f02e9a1946c6eb"
@@ -6022,6 +6103,13 @@ kind-of@^6.0.0, kind-of@^6.0.2:
   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
   integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
 
+klaw@^1.0.0:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/klaw/-/klaw-1.3.1.tgz#4088433b46b3b1ba259d78785d8e96f73ba02439"
+  integrity sha1-QIhDO0azsbolnXh4XY6W9zugJDk=
+  optionalDependencies:
+    graceful-fs "^4.1.9"
+
 kuler@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/kuler/-/kuler-2.0.0.tgz#e2c570a3800388fb44407e851531c1d670b061b3"
@@ -6091,12 +6179,11 @@ less-loader@5.0.0:
     loader-utils "^1.1.0"
     pify "^4.0.1"
 
-less@3.13.1:
-  version "3.13.1"
-  resolved "https://registry.yarnpkg.com/less/-/less-3.13.1.tgz#0ebc91d2a0e9c0c6735b83d496b0ab0583077909"
-  integrity sha512-SwA1aQXGUvp+P5XdZslUOhhLnClSLIjWvJhmd+Vgib5BFIr9lMNlQwmwUNOjXThF/A0x+MCYYPeWEfeWiLRnTw==
+less@3.12.2:
+  version "3.12.2"
+  resolved "https://registry.yarnpkg.com/less/-/less-3.12.2.tgz#157e6dd32a68869df8859314ad38e70211af3ab4"
+  integrity sha512-+1V2PCMFkL+OIj2/HrtrvZw0BC0sYLMICJfbQjuj/K8CEnlrFX6R5cKKgzzttsZDHyxQNL1jqMREjKN3ja/E3Q==
   dependencies:
-    copy-anything "^2.0.1"
     tslib "^1.10.0"
   optionalDependencies:
     errno "^0.1.1"
@@ -6523,6 +6610,21 @@ markdown-it@^10.0.0:
     mdurl "^1.0.1"
     uc.micro "^1.0.5"
 
+markdown-pdf@^10.0.0:
+  version "10.0.0"
+  resolved "https://registry.yarnpkg.com/markdown-pdf/-/markdown-pdf-10.0.0.tgz#0cf7a32740c2966aa79392a35742749d6ed2a491"
+  integrity sha512-o3lFfAOTpCgCXEXpNN86RaCVGE1YlxjWuAJ79XevAPoTyCBsl06BWhnFogYedg+JZxPjB3LWsA8JxZiCjsPPLA==
+  dependencies:
+    commander "^3.0.0"
+    duplexer "^0.1.1"
+    extend "^3.0.2"
+    highlight.js "^9.15.9"
+    phantomjs-prebuilt "^2.1.3"
+    remarkable "^2.0.0"
+    stream-from-to "^1.4.2"
+    through2 "^3.0.1"
+    tmp "^0.1.0"
+
 markdown-table@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/markdown-table/-/markdown-table-2.0.0.tgz#194a90ced26d31fe753d8b9434430214c011865b"
@@ -6957,7 +7059,7 @@ mkdirp@0.5.1:
   dependencies:
     minimist "0.0.8"
 
-mkdirp@^0.5.0, mkdirp@^0.5.1, mkdirp@^0.5.3, mkdirp@~0.5.1:
+mkdirp@^0.5.0, mkdirp@^0.5.1, mkdirp@^0.5.3, mkdirp@^0.5.4, mkdirp@~0.5.1:
   version "0.5.5"
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def"
   integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==
@@ -7962,6 +8064,16 @@ pdfobject@^2.0.201604172:
   resolved "https://registry.yarnpkg.com/pdfobject/-/pdfobject-2.2.4.tgz#ccb3c191129298a471e9ccb59c88a3ee0b7c7530"
   integrity sha512-r6Rw9CQWsrY6uqmKvlgFNoupmuRbSt9EsG0sZhSAy3cIk4WgOXyAVmebFSlLhqj6gA5NIEXL3lSEbwOOYfdUvw==
 
+peek-readable@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/peek-readable/-/peek-readable-3.1.0.tgz#250b08b7de09db8573d7fd8ea475215bbff14348"
+  integrity sha512-KGuODSTV6hcgdZvDrIDBUkN0utcAVj1LL7FfGbM0viKTtCHmtZcuEJ+lGqsp0fTFkGqesdtemV2yUSMeyy3ddA==
+
+pend@~1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/pend/-/pend-1.2.0.tgz#7a57eb550a6783f9115331fcf4663d5c8e007a50"
+  integrity sha1-elfrVQpng/kRUzH89GY9XI4AelA=
+
 performance-now@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b"
@@ -8025,6 +8137,21 @@ pgpass@1.x:
   dependencies:
     split2 "^3.1.1"
 
+phantomjs-prebuilt@^2.1.3:
+  version "2.1.16"
+  resolved "https://registry.yarnpkg.com/phantomjs-prebuilt/-/phantomjs-prebuilt-2.1.16.tgz#efd212a4a3966d3647684ea8ba788549be2aefef"
+  integrity sha1-79ISpKOWbTZHaE6ouniFSb4q7+8=
+  dependencies:
+    es6-promise "^4.0.3"
+    extract-zip "^1.6.5"
+    fs-extra "^1.0.0"
+    hasha "^2.2.0"
+    kew "^0.7.0"
+    progress "^1.1.8"
+    request "^2.81.0"
+    request-progress "^2.0.1"
+    which "^1.2.10"
+
 picomatch@^2.0.4, picomatch@^2.0.5, picomatch@^2.2.1:
   version "2.2.2"
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.2.tgz#21f333e9b6b8eaff02468f5146ea406d345f4dad"
@@ -8045,6 +8172,18 @@ pify@^4.0.1:
   resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231"
   integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==
 
+pinkie-promise@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
+  integrity sha1-ITXW36ejWMBprJsXh3YogihFD/o=
+  dependencies:
+    pinkie "^2.0.0"
+
+pinkie@^2.0.0:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
+  integrity sha1-clVrgM+g1IqXToDnckjoDtT3+HA=
+
 pkg-dir@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-2.0.0.tgz#f6d5d1109e19d63edf428e0bd57e12777615334b"
@@ -8498,6 +8637,11 @@ process@^0.11.10:
   resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
   integrity sha1-czIwDoQBYb2j5podHZGn1LwW8YI=
 
+progress@^1.1.8:
+  version "1.1.8"
+  resolved "https://registry.yarnpkg.com/progress/-/progress-1.1.8.tgz#e260c78f6161cdd9b0e56cc3e0a85de17c7a57be"
+  integrity sha1-4mDHj2Fhzdmw5WzD4Khd4Xx6V74=
+
 progress@^2.0.0:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
@@ -8746,6 +8890,15 @@ readable-stream@1.0.27-1:
     isarray "0.0.1"
     string_decoder "~0.10.x"
 
+"readable-stream@2 || 3", readable-stream@^3.0.0, readable-stream@^3.0.1, readable-stream@^3.0.2, readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198"
+  integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
+  dependencies:
+    inherits "^2.0.3"
+    string_decoder "^1.1.1"
+    util-deprecate "^1.0.1"
+
 "readable-stream@>=1.0.33-1 <1.1.0-0":
   version "1.0.34"
   resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.0.34.tgz#125820e34bc842d2f2aaafafe4c2916ee32c157c"
@@ -8756,15 +8909,6 @@ readable-stream@1.0.27-1:
     isarray "0.0.1"
     string_decoder "~0.10.x"
 
-readable-stream@^3.0.0, readable-stream@^3.0.1, readable-stream@^3.0.2, readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.6.0:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198"
-  integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
-  dependencies:
-    inherits "^2.0.3"
-    string_decoder "^1.1.1"
-    util-deprecate "^1.0.1"
-
 readable-stream@~2.0.0:
   version "2.0.6"
   resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.0.6.tgz#8f90341e68a53ccc928788dacfcd11b36eb9b78e"
@@ -8777,6 +8921,14 @@ readable-stream@~2.0.0:
     string_decoder "~0.10.x"
     util-deprecate "~1.0.1"
 
+readable-web-to-node-stream@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/readable-web-to-node-stream/-/readable-web-to-node-stream-3.0.0.tgz#4ca5408e70471069119d691934141a52de413955"
+  integrity sha512-HNmLb3n0SteGAs8HQlErYPGeO+y7cvL/mVUKtXeUkl0iCZ/2GIgKGrCFHyS7UXFnO8uc9U+0y3pYIzAPsjFfvA==
+  dependencies:
+    "@types/readable-stream" "^2.3.9"
+    readable-stream "^3.6.0"
+
 readdir-glob@^1.0.0:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/readdir-glob/-/readdir-glob-1.1.1.tgz#f0e10bb7bf7bfa7e0add8baffdc54c3f7dbee6c4"
@@ -9448,6 +9600,14 @@ remark@^12.0.0:
     remark-stringify "^8.0.0"
     unified "^9.0.0"
 
+remarkable@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/remarkable/-/remarkable-2.0.1.tgz#280ae6627384dfb13d98ee3995627ca550a12f31"
+  integrity sha512-YJyMcOH5lrR+kZdmB0aJJ4+93bEojRZ1HGDn9Eagu6ibg7aVZhc3OWbbShRid+Q5eAfsEqWxpe+g5W5nYNfNiA==
+  dependencies:
+    argparse "^1.0.10"
+    autolinker "^3.11.0"
+
 remove-trailing-separator@^1.0.1:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef"
@@ -9486,6 +9646,13 @@ replace-ext@1.0.0:
   resolved "https://registry.yarnpkg.com/replace-ext/-/replace-ext-1.0.0.tgz#de63128373fcbf7c3ccfa4de5a480c45a67958eb"
   integrity sha1-3mMSg3P8v3w8z6TeWkgMRaZ5WOs=
 
+request-progress@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/request-progress/-/request-progress-2.0.1.tgz#5d36bb57961c673aa5b788dbc8141fdf23b44e08"
+  integrity sha1-XTa7V5YcZzqlt4jbyBQf3yO0Tgg=
+  dependencies:
+    throttleit "^1.0.0"
+
 request-promise-core@1.1.4:
   version "1.1.4"
   resolved "https://registry.yarnpkg.com/request-promise-core/-/request-promise-core-1.1.4.tgz#3eedd4223208d419867b78ce815167d10593a22f"
@@ -9502,7 +9669,7 @@ request-promise-native@^1.0.5:
     stealthy-require "^1.1.1"
     tough-cookie "^2.3.3"
 
-request@2.x, "request@>= 2.52.0", request@^2.83.0, request@^2.86.0, request@^2.87.0, request@^2.88.0, request@^2.88.2:
+request@2.x, "request@>= 2.52.0", request@^2.81.0, request@^2.83.0, request@^2.86.0, request@^2.87.0, request@^2.88.0, request@^2.88.2:
   version "2.88.2"
   resolved "https://registry.yarnpkg.com/request/-/request-2.88.2.tgz#d73c918731cb5a87da047e207234146f664d12b3"
   integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==
@@ -9880,6 +10047,11 @@ serialize-javascript@^5.0.1:
   dependencies:
     randombytes "^2.1.0"
 
+series-stream@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/series-stream/-/series-stream-1.0.1.tgz#311a09c5c1d5a091440832e1a480a47400f1005d"
+  integrity sha1-MRoJxcHVoJFECDLhpICkdADxAF0=
+
 serve-static@1.14.1:
   version "1.14.1"
   resolved "https://registry.yarnpkg.com/serve-static/-/serve-static-1.14.1.tgz#666e636dc4f010f7ef29970a88a674320898b2f9"
@@ -10306,6 +10478,16 @@ stream-each@^1.1.0:
     end-of-stream "^1.1.0"
     stream-shift "^1.0.0"
 
+stream-from-to@^1.4.2:
+  version "1.4.3"
+  resolved "https://registry.yarnpkg.com/stream-from-to/-/stream-from-to-1.4.3.tgz#b270473ebc514e73615727c5d2f76b229941df94"
+  integrity sha1-snBHPrxRTnNhVyfF0vdrIplB35Q=
+  dependencies:
+    async "^1.5.2"
+    concat-stream "^1.4.7"
+    mkdirp "^0.5.0"
+    series-stream "^1.0.1"
+
 stream-http@^2.7.2:
   version "2.8.3"
   resolved "https://registry.yarnpkg.com/stream-http/-/stream-http-2.8.3.tgz#b2d242469288a5a27ec4fe8933acf623de6514fc"
@@ -10464,6 +10646,15 @@ strip-json-comments@^2.0.1, strip-json-comments@~2.0.1:
   resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
   integrity sha1-PFMZQukIwml8DsNEhYwobHygpgo=
 
+strtok3@^6.0.3:
+  version "6.0.4"
+  resolved "https://registry.yarnpkg.com/strtok3/-/strtok3-6.0.4.tgz#ede0d20fde5aa9fda56417c3558eaafccc724694"
+  integrity sha512-rqWMKwsbN9APU47bQTMEYTPcwdpKDtmf1jVhHzNW2cL1WqAxaM9iBb9t5P2fj+RV2YsErUWgQzHD5JwV0uCTEQ==
+  dependencies:
+    "@tokenizer/token" "^0.1.1"
+    "@types/debug" "^4.1.5"
+    peek-readable "^3.1.0"
+
 stylehacks@^4.0.0:
   version "4.0.3"
   resolved "https://registry.yarnpkg.com/stylehacks/-/stylehacks-4.0.3.tgz#6718fcaf4d1e07d8a1318690881e8d96726a71d5"
@@ -10654,6 +10845,11 @@ text-table@^0.2.0:
   resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
   integrity sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=
 
+throttleit@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/throttleit/-/throttleit-1.0.0.tgz#9e785836daf46743145a5984b6268d828528ac6c"
+  integrity sha1-nnhYNtr0Z0MUWlmEtiaNgoUorGw=
+
 through2@^0.6.5:
   version "0.6.5"
   resolved "https://registry.yarnpkg.com/through2/-/through2-0.6.5.tgz#41ab9c67b29d57209071410e1d7a7a968cd3ad48"
@@ -10670,6 +10866,14 @@ through2@^2.0.0:
     readable-stream "~2.3.6"
     xtend "~4.0.1"
 
+through2@^3.0.1:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/through2/-/through2-3.0.2.tgz#99f88931cfc761ec7678b41d5d7336b5b6a07bf4"
+  integrity sha512-enaDQ4MUyP2W6ZyT6EsMzqBPZaM/avg8iuo+l2d3QCs0J+6RaqkHV/2/lOwDTueBHeJ/2LG9lrLW3d5rWPucuQ==
+  dependencies:
+    inherits "^2.0.4"
+    readable-stream "2 || 3"
+
 through@^2.3.6:
   version "2.3.8"
   resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
@@ -10707,6 +10911,13 @@ tmp@^0.0.33:
   dependencies:
     os-tmpdir "~1.0.2"
 
+tmp@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.1.0.tgz#ee434a4e22543082e294ba6201dcc6eafefa2877"
+  integrity sha512-J7Z2K08jbGcdA1kkQpJSqLF6T0tdQqpR2pnSUXsIchbPdTI9v3e85cLW0d6WDhwuAleOV71j2xWs8qMPfK7nKw==
+  dependencies:
+    rimraf "^2.6.3"
+
 to-array@0.1.4:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/to-array/-/to-array-0.1.4.tgz#17e6c11f73dd4f3d74cda7a4ff3238e9ad9bf890"
@@ -10767,6 +10978,14 @@ toidentifier@1.0.0:
   resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.0.tgz#7e1be3470f1e77948bc43d94a3c8f4d7752ba553"
   integrity sha512-yaOH/Pk/VEhBWWTlhI+qXxDFXlejDGcQipMlyxda9nthulaxLZUNcUqFxokp0vcYnvteJln5FNQDRrxj3YcbVw==
 
+token-types@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/token-types/-/token-types-2.0.0.tgz#b23618af744818299c6fbf125e0fdad98bab7e85"
+  integrity sha512-WWvu8sGK8/ZmGusekZJJ5NM6rRVTTDO7/bahz4NGiSDb/XsmdYBn6a1N/bymUHuWYTWeuLUg98wUzvE4jPdCZw==
+  dependencies:
+    "@tokenizer/token" "^0.1.0"
+    ieee754 "^1.1.13"
+
 toobusy-js@^0.5.1:
   version "0.5.1"
   resolved "https://registry.yarnpkg.com/toobusy-js/-/toobusy-js-0.5.1.tgz#5511f78f6a87a6a512d44fdb0efa13672217f659"
@@ -10837,7 +11056,7 @@ tsconfig-paths@^3.9.0:
     minimist "^1.2.0"
     strip-bom "^3.0.0"
 
-tslib@^1.10.0, tslib@^1.9.0, tslib@^1.9.2:
+tslib@^1.10.0, tslib@^1.9.0, tslib@^1.9.2, tslib@^1.9.3:
   version "1.14.1"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
   integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
@@ -10896,6 +11115,13 @@ type@^2.0.0:
   resolved "https://registry.yarnpkg.com/type/-/type-2.1.0.tgz#9bdc22c648cf8cf86dd23d32336a41cfb6475e3f"
   integrity sha512-G9absDWvhAWCV2gmF1zKud3OyC61nZDwWvBL2DApaVFogI07CprggiQAOOjvp2NRjYWFzPyu7vwtDrQFq8jeSA==
 
+typedarray-to-buffer@^3.1.5:
+  version "3.1.5"
+  resolved "https://registry.yarnpkg.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz#a97ee7a9ff42691b9f783ff1bc5112fe3fca9080"
+  integrity sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==
+  dependencies:
+    is-typedarray "^1.0.0"
+
 typedarray@^0.0.6:
   version "0.0.6"
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
@@ -11518,7 +11744,7 @@ which-module@^2.0.0:
   resolved "https://registry.yarnpkg.com/which-module/-/which-module-2.0.0.tgz#d9ef07dce77b9902b8a3a8fa4b31c3e3f7e6e87a"
   integrity sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=
 
-which@^1.2.14, which@^1.2.9, which@^1.3.1:
+which@^1.2.10, which@^1.2.14, which@^1.2.9, which@^1.3.1:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
   integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
@@ -11804,6 +12030,14 @@ yargs@^13.1.0, yargs@^13.3.2:
     y18n "^4.0.0"
     yargs-parser "^13.1.2"
 
+yauzl@^2.10.0:
+  version "2.10.0"
+  resolved "https://registry.yarnpkg.com/yauzl/-/yauzl-2.10.0.tgz#c7eb17c93e112cb1086fa6d8e51fb0667b79a5f9"
+  integrity sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk=
+  dependencies:
+    buffer-crc32 "~0.2.3"
+    fd-slicer "~1.1.0"
+
 yeast@0.1.2:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/yeast/-/yeast-0.1.2.tgz#008e06d8094320c372dbc2f8ed76a0ca6c8ac419"

From 6932cc4df7e0c2826e47b2d9ca2f0031f75b1b58 Mon Sep 17 00:00:00 2001
From: David Mehren <git@herrmehren.de>
Date: Sun, 27 Dec 2020 15:52:26 +0100
Subject: [PATCH 5/5] Always save uploads to a tmpdir first and cleanup
 afterwards

This makes sure no unintended files are permanently saved.

Co-authored-by: Yannick Bungers <git@innay.de>
Signed-off-by: David Mehren <git@herrmehren.de>
---
 lib/web/imageRouter/filesystem.js | 11 ++++++++++-
 lib/web/imageRouter/index.js      | 22 ++++++++++++++--------
 package.json                      |  1 +
 3 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/lib/web/imageRouter/filesystem.js b/lib/web/imageRouter/filesystem.js
index 3ba09e88d0..f8fd7e1654 100644
--- a/lib/web/imageRouter/filesystem.js
+++ b/lib/web/imageRouter/filesystem.js
@@ -1,6 +1,7 @@
 'use strict'
 const URL = require('url').URL
 const path = require('path')
+const fs = require('fs')
 
 const config = require('../../config')
 const logger = require('../../logger')
@@ -16,5 +17,13 @@ exports.uploadImage = function (imagePath, callback) {
     return
   }
 
-  callback(null, (new URL(path.basename(imagePath), config.serverURL + '/uploads/')).href)
+  const fileName = path.basename(imagePath)
+  // move image from temporary path to upload directory
+  try {
+    fs.copyFileSync(imagePath, path.join(config.uploadsPath, fileName))
+  } catch (e) {
+    callback(new Error('Error while moving file'), null)
+    return
+  }
+  callback(null, (new URL(fileName, config.serverURL + '/uploads/')).href)
 }
diff --git a/lib/web/imageRouter/index.js b/lib/web/imageRouter/index.js
index 5861a2bc8a..afa9bbf606 100644
--- a/lib/web/imageRouter/index.js
+++ b/lib/web/imageRouter/index.js
@@ -4,6 +4,9 @@ const Router = require('express').Router
 const formidable = require('formidable')
 const path = require('path')
 const FileType = require('file-type')
+const fs = require('fs')
+const os = require('os')
+const rimraf = require('rimraf')
 
 const config = require('../../config')
 const logger = require('../../logger')
@@ -30,25 +33,27 @@ async function checkUploadType (filePath) {
 
 // upload image
 imageRouter.post('/uploadimage', function (req, res) {
-  var form = new formidable.IncomingForm()
+  if (!req.isAuthenticated() && !config.allowAnonymous && !config.allowAnonymousEdits) {
+    logger.error(`Image upload error: Anonymous edits and therefore uploads are not allowed)`)
+    return errors.errorForbidden(res)
+  }
 
+  var form = new formidable.IncomingForm()
   form.keepExtensions = true
-
-  if (config.imageUploadType === 'filesystem') {
-    form.uploadDir = config.uploadsPath
-  }
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hedgedoc-'))
+  form.uploadDir = tmpDir
 
   form.parse(req, async function (err, fields, files) {
     if (err) {
       logger.error(`Image upload error: formidable error: ${err}`)
-      return errors.errorForbidden(res)
-    } else if (!req.isAuthenticated() && !config.allowAnonymous && !config.allowAnonymousEdits) {
-      logger.error(`Image upload error: Anonymous edits and therefore uploads are not allowed)`)
+      rimraf(tmpDir)
       return errors.errorForbidden(res)
     } else if (!files.image || !files.image.path) {
       logger.error(`Image upload error: Upload didn't contain file)`)
+      rimraf.sync(tmpDir)
       return errors.errorBadRequest(res)
     } else if (!await checkUploadType(files.image.path)) {
+      rimraf.sync(tmpDir)
       return errors.errorBadRequest(res)
     } else {
       logger.debug(`SERVER received uploadimage: ${JSON.stringify(files.image)}`)
@@ -56,6 +61,7 @@ imageRouter.post('/uploadimage', function (req, res) {
       const uploadProvider = require('./' + config.imageUploadType)
       logger.debug(`imageRouter: Uploading ${files.image.path} using ${config.imageUploadType}`)
       uploadProvider.uploadImage(files.image.path, function (err, url) {
+        rimraf.sync(tmpDir)
         if (err !== null) {
           logger.error(err)
           return res.status(500).end('upload image error')
diff --git a/package.json b/package.json
index c77045abff..ae23418222 100644
--- a/package.json
+++ b/package.json
@@ -112,6 +112,7 @@
     "readline-sync": "^1.4.7",
     "request": "^2.88.0",
     "reveal.js": "^3.9.2",
+    "rimraf": "^3.0.2",
     "scrypt-async": "^2.0.1",
     "scrypt-kdf": "^2.0.1",
     "select2": "^3.5.2-browserify",",
"url": "https://github.com/hedgedoc/hedgedoc/commit/e9306991cdb5ff2752c1eeba3fedba42aec3c2d8.patch"
}
] |
CWE-434 Unrestricted Upload of File with Dangerous Type
|
CVE-2015-2678
|
Multiple cross-site scripting (XSS) vulnerabilities in MetalGenix GeniXCMS before 0.0.2 allow remote attackers to inject arbitrary web script or HTML via the (1) cat parameter in the categories page to gxadmin/index.php or (2) page parameter to index.php.
|
[
{
"commit_message": "[PATCH] Security FIX, Bug FIX gxadmin/inc/categories.php | 42 ++- gxadmin/inc/menus.php | 35 ++- gxadmin/inc/menus_form.php | 30 +++ gxadmin/inc/menus_form_edit.php | 38 ++- gxadmin/inc/pages.php | 176 +++++++------ gxadmin/inc/pages_form.php | 46 +++- gxadmin/inc/posts.php | 13 +- gxadmin/inc/posts_form.php | 100 +++---- gxadmin/inc/settings.php | 46 +++- gxadmin/inc/user.php | 9 +- gxadmin/inc/user_form.php | 51 ++-- inc/lib/Categories.class.php | 5 +- inc/lib/Control.class.php | 4 +- .../Control/Backend/categories.control.php | 55 +++- inc/lib/Control/Backend/menus.control.php | 245 +++++++++++------- inc/lib/Control/Backend/pages.control.php | 128 ++++++--- inc/lib/Control/Backend/posts.control.php | 137 +++++++--- inc/lib/Control/Backend/settings.control.php | 78 +++--- inc/lib/Control/Backend/users.control.php | 26 +- inc/lib/Control/Error/db.control.php | 8 + inc/lib/Control/Error/unknown.control.php | 10 + inc/lib/Control/Frontend/cat.control.php | 5 +- inc/lib/Control/Frontend/default.control.php | 3 +- inc/lib/Control/Frontend/page.control.php | 11 +- inc/lib/Control/Frontend/post.control.php | 9 +- inc/lib/Control/Install/default.control.php | 1 + inc/lib/Db.class.php | 21 +- inc/lib/GxMain.class.php | 2 + inc/lib/Install.class.php | 16 +- inc/lib/Mail.class.php | 2 +- inc/lib/Menus.class.php | 98 ++++--- inc/lib/Options.class.php | 21 +- inc/lib/Posts.class.php | 4 +- inc/lib/Rss.class.php | 6 +- inc/lib/Site.class.php | 44 ++-- inc/lib/System.class.php | 27 +- inc/lib/Token.class.php | 119 +++++++++ inc/lib/Upload.class.php | 2 +- inc/lib/Url.class.php | 20 +- 39 files changed, 1165 insertions(+), 528 deletions(-) create mode 100644 inc/lib/Control/Error/db.control.php create mode 100644 inc/lib/Control/Error/unknown.control.php create mode 100644 inc/lib/Token.class.php",
"patch_text_b64": "From 698245488343396185b1b49e7482ee5b25541815 Mon Sep 17 00:00:00 2001
From: Puguh Wijayanto <hangbowl@gmail.com>
Date: Tue, 10 Mar 2015 08:54:35 +0700
Subject: [PATCH] Security FIX, Bug FIX

---
 gxadmin/inc/categories.php                    |  42 ++-
 gxadmin/inc/menus.php                         |  35 ++-
 gxadmin/inc/menus_form.php                    |  30 +++
 gxadmin/inc/menus_form_edit.php               |  38 ++-
 gxadmin/inc/pages.php                         | 176 +++++++------
 gxadmin/inc/pages_form.php                    |  46 +++-
 gxadmin/inc/posts.php                         |  13 +-
 gxadmin/inc/posts_form.php                    | 100 +++----
 gxadmin/inc/settings.php                      |  46 +++-
 gxadmin/inc/user.php                          |   9 +-
 gxadmin/inc/user_form.php                     |  51 ++--
 inc/lib/Categories.class.php                  |   5 +-
 inc/lib/Control.class.php                     |   4 +-
 .../Control/Backend/categories.control.php    |  55 +++-
 inc/lib/Control/Backend/menus.control.php     | 245 +++++++++++-------
 inc/lib/Control/Backend/pages.control.php     | 128 ++++++---
 inc/lib/Control/Backend/posts.control.php     | 137 +++++++---
 inc/lib/Control/Backend/settings.control.php  |  78 +++---
 inc/lib/Control/Backend/users.control.php     |  26 +-
 inc/lib/Control/Error/db.control.php          |   8 +
 inc/lib/Control/Error/unknown.control.php     |  10 +
 inc/lib/Control/Frontend/cat.control.php      |   5 +-
 inc/lib/Control/Frontend/default.control.php  |   3 +-
 inc/lib/Control/Frontend/page.control.php     |  11 +-
 inc/lib/Control/Frontend/post.control.php     |   9 +-
 inc/lib/Control/Install/default.control.php   |   1 +
 inc/lib/Db.class.php                          |  21 +-
 inc/lib/GxMain.class.php                      |   2 +
 inc/lib/Install.class.php                     |  16 +-
 inc/lib/Mail.class.php                        |   2 +-
 inc/lib/Menus.class.php                       |  98 ++++---
 inc/lib/Options.class.php                     |  21 +-
 inc/lib/Posts.class.php                       |   4 +-
 inc/lib/Rss.class.php                         |   6 +-
 inc/lib/Site.class.php                        |  44 ++--
 inc/lib/System.class.php                      |  27 +-
 inc/lib/Token.class.php                       | 119 +++++++++
 inc/lib/Upload.class.php                      |   2 +-
 inc/lib/Url.class.php                         |  20 +-
 39 files changed, 1165 insertions(+), 528 deletions(-)
 create mode 100644 inc/lib/Control/Error/db.control.php
 create mode 100644 inc/lib/Control/Error/unknown.control.php
 create mode 100644 inc/lib/Token.class.php

diff --git a/gxadmin/inc/categories.php b/gxadmin/inc/categories.php
index 4f12fd0b..b520411b 100644
--- a/gxadmin/inc/categories.php
+++ b/gxadmin/inc/categories.php
@@ -12,7 +12,35 @@
 * @copyright 2014-2015 Puguh Wijayanto
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 *
-*/?>
+*/
+
+if (isset($data['alertgreen'])) {
+    # code...
+    echo "<div class=\"alert alert-success\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>";
+    foreach ($data['alertgreen'] as $alert) {
+        # code...
+        echo "$alert\n";
+    }
+    echo "</div>";
+}
+if (isset($data['alertred'])) {
+    # code...
+    echo "<div class=\"alert alert-danger\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>";
+    foreach ($data['alertred'] as $alert) {
+        # code...
+        echo "$alert\n";
+    }
+    echo "</div>";
+}
+?>
 <div class="row">
     <div class="col-md-12">
         <h1><i class="fa fa-cubes"></i>  Categories 
@@ -34,12 +62,12 @@
                         // echo "<td>".$c->parent."</td>";
                         // echo "<td></td>";
 
-                        if($c->parent == ""){
+                        if($c->parent == "" || $c->parent == 0){
                             echo "<div class=\"col-md-4 item\" >
                             <div class=\"panel panel-default\">
                                 <div class=\"panel-heading\">
                                   <h3 class=\"panel-title\">{$c->name} 
-                                  <a href=\"?page=categories&act=del&id={$c->id}\" class=\"pull-right\"
+                                  <a href=\"?page=categories&act=del&id={$c->id}&token=".TOKEN."\" class=\"pull-right\"
                                   onclick=\"return confirm('Are you sure you want to delete this item?');\">
                                   <span class=\"glyphicon glyphicon-remove\"></span></a></h3>
                                 </div>
@@ -48,13 +76,14 @@
                                 foreach ($data['cat'] as $c2) {
                                     if($c2->parent == $c->id){
                                         echo "<li class=\"list-group-item\">
-                                        <form action=\"\" method=\"POST\" name=\"updatecat\">
+                                        <form action=\"index.php?page=categories\" method=\"POST\" name=\"updatecat\">
                                         <div class=\"input-group\">
-                                            <a href=\"?page=categories&act=del&id={$c2->id}\" class=\"input-group-addon\"
+                                            <a href=\"?page=categories&act=del&id={$c2->id}&token=".TOKEN."\" class=\"input-group-addon\"
                                             onclick=\"return confirm('Are you sure you want to delete this item?');\"
                                             ><span class=\"glyphicon glyphicon-remove\"></span></a>
                                             <input type=\"text\" name=\"cat\" class=\"form-control\" value=\"{$c2->name}\">
                                             <input type=\"hidden\" name=\"id\" value=\"{$c2->id}\">
+                                            <input type=\"hidden\" name=\"token\" value=\"".TOKEN."\">
                                             <span class=\"input-group-btn\">
                                                 <button class=\"btn btn-default\" type=\"submit\" name=\"updatecat\">Go!</button>
                                             </span>
@@ -92,7 +121,7 @@
                     <label>Parent</label>
                     <?php
                         $vars = array(
-                                    'parent' => '',
+                                    'parent' => '0',
                                     'name' => 'parent',
                                     'sort' => 'ASC',
                                     'order_by' => 'name'
@@ -107,6 +136,7 @@
             
           </div>
           <div class="modal-footer">
+            <input type="hidden" name="token" value="<?=TOKEN;?>">
             <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
             <button type="submit" class="btn btn-success" name="addcat">Save changes</button>
           </div>
diff --git a/gxadmin/inc/menus.php b/gxadmin/inc/menus.php
index 0339104e..e79aac03 100644
--- a/gxadmin/inc/menus.php
+++ b/gxadmin/inc/menus.php
@@ -12,7 +12,37 @@
 * @copyright 2014-2015 Puguh Wijayanto
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 *
-*/?>
+*/
+
+if (isset($data['alertgreen'])) {
+    # code...
+    echo "<div class=\"alert alert-success\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>
+    <ul>";
+    foreach ($data['alertgreen'] as $alert) {
+        # code...
+        echo "<li>$alert</li>\n";
+    }
+    echo "</ul></div>";
+}elseif (isset($data['alertred'])) {
+    # code...
+    //print_r($data['alertred']);
+    echo "<div class=\"alert alert-danger\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>
+    <ul>";
+    foreach ($data['alertred'] as $alert) {
+        # code...
+        echo "<li>$alert</li>\n";
+    }
+    echo "</ul></div>";
+}
+?>
 <div class="row">
     <div class="col-md-12">
 
@@ -84,7 +114,7 @@
                                           </div>
                                           <div class=\"tab-pane\" id=\"{$k}additem\">
                                           ";
-                                              $data['parent'] = Menus::getParent('', $k);
+                                              $data['parent'] = Menus::isHadParent('', $k);
                                               //print_r($data['parent']);
                                               $data['menuid'] = $k;
                                               System::inc('menus_form', $data);
@@ -146,6 +176,7 @@
 
           </div>
           <div class="modal-footer">
+            <input type="hidden" name="token" value="<?=TOKEN;?>">
             <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
             <button type="submit" class="btn btn-success" name="submit">Save changes</button>
           </div>
diff --git a/gxadmin/inc/menus_form.php b/gxadmin/inc/menus_form.php
index 970a1dc8..d2db913e 100644
--- a/gxadmin/inc/menus_form.php
+++ b/gxadmin/inc/menus_form.php
@@ -19,6 +19,35 @@
     }else{
         $menuid = $data['menuid'];
     }
+if (isset($data['alertgreen'])) {
+    # code...
+    echo "<div class=\"alert alert-success\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>
+    <ul>";
+    foreach ($data['alertgreen'] as $alert) {
+        # code...
+        echo "<li>$alert</li>\n";
+    }
+    echo "</ul></div>";
+}elseif (isset($data['alertred'])) {
+    # code...
+    //print_r($data['alertred']);
+    echo "<div class=\"alert alert-danger\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>
+    <ul>";
+    foreach ($data['alertred'] as $alert) {
+        # code...
+        echo "<li>$alert</li>\n";
+    }
+    echo "</ul></div>";
+}
+
 ?>
 <form action="" method="POST">
 <h1><i class="fa fa-sitemap"></i> Add Menu
@@ -142,4 +171,5 @@
         </div>
     </div>
 </div>
+<input type="hidden" name="token" value="<?=TOKEN;?>">
 </form>
\ No newline at end of file
diff --git a/gxadmin/inc/menus_form_edit.php b/gxadmin/inc/menus_form_edit.php
index 8c4ddcb6..d2a6716b 100644
--- a/gxadmin/inc/menus_form_edit.php
+++ b/gxadmin/inc/menus_form_edit.php
@@ -21,12 +21,34 @@
     }
 
     //print_r($data['menus']);
-    if(isset($data['alertgreen']) ) {
-        echo "<div class=\"alert alert-success\">";
-            foreach ($data['alertgreen'] as $alert) {
-                echo "$alert"; 
-            }
-        echo "</div>"; }
+    if (isset($data['alertgreen'])) {
+    # code...
+    echo "<div class=\"alert alert-success\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>
+    <ul>";
+    foreach ($data['alertgreen'] as $alert) {
+        # code...
+        echo "<li>$alert</li>\n";
+    }
+    echo "</ul></div>";
+}elseif (isset($data['alertred'])) {
+    # code...
+    //print_r($data['alertred']);
+    echo "<div class=\"alert alert-danger\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>
+    <ul>";
+    foreach ($data['alertred'] as $alert) {
+        # code...
+        echo "<li>$alert</li>\n";
+    }
+    echo "</ul></div>";
+}
 ?>
 <form action="" method="POST">
 <div class="row">
@@ -48,11 +70,12 @@
     <div class="col-sm-4">
         <div class="form-group">
             <label>Parent Menu</label>
+            
             <select class="form-control" name="parent">
                 <option></option>
             <?php
                //echo($data['abc']);
-                //print_r($data['parent']);
+                //print_r($data['menus']);
                 foreach ($data['parent'] as $p) {
                     # code...
                     if($data['menus'][0]->parent == $p->id){
@@ -183,5 +206,6 @@
         </div>
     </div>
 </div>
+<input type="hidden" name="token" value="<?=$_GET['token'];?>">
 </form>
 </div>
\ No newline at end of file
diff --git a/gxadmin/inc/pages.php b/gxadmin/inc/pages.php
index 36fde2a7..82319cb0 100644
--- a/gxadmin/inc/pages.php
+++ b/gxadmin/inc/pages.php
@@ -13,32 +13,32 @@
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 *
 */
-    if (isset($data['alertgreen'])) {
+if (isset($data['alertgreen'])) {
+    # code...
+    echo "<div class=\"alert alert-success\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>";
+    foreach ($data['alertgreen'] as $alert) {
         # code...
-        echo "<div class=\"alert alert-success\" >
-        <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
-            <span aria-hidden=\"true\">&times;</span>
-            <span class=\"sr-only\">Close</span>
-        </button>";
-        foreach ($data['alertgreen'] as $alert) {
-            # code...
-            echo "$alert\n";
-        }
-        echo "</div>";
+        echo "$alert\n";
     }
-    if (isset($data['alertred'])) {
+    echo "</div>";
+}
+if (isset($data['alertred'])) {
+    # code...
+    echo "<div class=\"alert alert-danger\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>";
+    foreach ($data['alertred'] as $alert) {
         # code...
-        echo "<div class=\"alert alert-danger\" >
-        <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
-            <span aria-hidden=\"true\">&times;</span>
-            <span class=\"sr-only\">Close</span>
-        </button>";
-        foreach ($data['alertred'] as $alert) {
-            # code...
-            echo "$alert\n";
-        }
-        echo "</div>";
+        echo "$alert\n";
     }
+    echo "</div>";
+}
 ?>
 <div class="row">
     <div class="col-md-12">
@@ -46,68 +46,80 @@
         <hr />
     </div>
     <div class="col-md-12">
-        <div class="table-responsive">
-            <table class="table table-hover">
-                <thead>
-                    <tr>
-                        <th>ID</th>
-                        <th>Title</th>
-                        <th>Date</th>
-                        <th>Edit/Delete</th>
-                        <th>All <input type="checkbox" id="selectall"></th>
-                    </tr>
-                </thead>
-                <tbody>
-                    <?php
-                        //print_r($data);
-                    if($data['num'] > 0){
-                        foreach ($data['posts'] as $p) {
-                            # code...
-                            //echo $p->id;
+        <form action="" method="post">
+            <div class="table-responsive">
+                <table class="table table-hover">
+                    <thead>
+                        <tr>
+                            <th>ID</th>
+                            <th>Title</th>
+                            <th>Date</th>
+                            <th>Status</th>
+                            <th>Edit/Delete</th>
+                            <th>All <input type="checkbox" id="selectall"></th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        <?php
+                            //print_r($data);
+                        if($data['num'] > 0){
+                            foreach ($data['posts'] as $p) {
+                                # code...
+                                //echo $p->id;
+                                if($p->status == '0'){
+                                    $status = "UnPublished";
+                                }else{
+                                    $status = "Published";
+                                }
+                                echo "
+                                <tr>
+                                    <td>{$p->id}</td>
+                                    <td><a href=\"".Url::page($p->id)."\" target=\"_new\">{$p->title}</a></td>
+                                    <td>{$p->date}</td>
+                                    <td>{$status}</td>
+                                    <td>
+                                        <a href=\"index.php?page=pages&act=edit&id={$p->id}&token=".TOKEN."\" class=\"label label-success\">Edit</a> 
+                                        <a href=\"index.php?page=pages&act=del&id={$p->id}&token=".TOKEN."\" class=\"label label-danger\" 
+                                        onclick=\"return confirm('Are you sure you want to delete this item?');\">Delete</a>
+                                    </td>
+                                        <td>
+                                        <input type=\"checkbox\" name=\"post_id[]\" value=\"{$p->id}\" id=\"select\">
+                                    </td>
+                                </tr>
+                                ";
+                            }
+                        }else{
                             echo "
-                            <tr>
-                                <td>{$p->id}</td>
-                                <td><a href=\"".Url::page($p->id)."\" target=\"_new\">{$p->title}</a></td>
-                                <td>{$p->date}</td>
-                                <td>
-                                    <a href=\"index.php?page=pages&act=edit&id={$p->id}\" class=\"label label-success\">Edit</a> 
-                                    <a href=\"index.php?page=pages&act=del&id={$p->id}\" class=\"label label-danger\" 
-                                    onclick=\"return confirm('Are you sure you want to delete this item?');\">Delete</a>
-                                </td>
+                                <tr>
                                     <td>
-                                    <input type=\"checkbox\" name=\"post_id[]\" value=\"{$p->id}\" id=\"select\">
-                                </td>
-                            </tr>
-                            ";
+                                        No Pages Found 
+                                    </td>
+                                </tr>";
                         }
-                    }else{
-                        echo "
-                            <tr>
-                                <td>
-                                    No Pages Found 
-                                </td>
-                            </tr>";
-                    }
-                    ?>
-                </tbody>
-                <tfoot>
-                    <th>ID</th>
-                    <th>Title</th>
-                    <th>Date</th>
-                    <th>
-                    <select name="action" class="form-control">
-                        <option value="publish">Publish</option>
-                        <option value="unpublish">UnPublish</option>
-                        <option value="delete">Delete</option>
-                    </select>
-                    </th>
-                    <th>
-                        <button type="submit" name="doaction" class="btn btn-danger">
-                            Submit
-                        </button>
-                    </th>
-                </tfoot>
-            </table>
-        </div>
+                        ?>
+                    </tbody>
+                    <tfoot>
+                        <th>ID</th>
+                        <th>Title</th>
+                        <th>Date</th>
+                        <th>Status</th>
+                        <th>
+                        <select name="action" class="form-control">
+                            <option value="publish">Publish</option>
+                            <option value="unpublish">UnPublish</option>
+                            <option value="delete">Delete</option>
+                        </select>
+                        <input type="hidden" name="token" value="<?=TOKEN;?>">
+                        </th>
+                        <th>
+                            <button type="submit" name="doaction" class="btn btn-danger">
+                                Submit
+                            </button>
+                        </th>
+                    </tfoot>
+                </table>
+            </div>
+        </form>
+        
     </div>
 </div>
\ No newline at end of file
diff --git a/gxadmin/inc/pages_form.php b/gxadmin/inc/pages_form.php
index 75b649b6..c07949f7 100644
--- a/gxadmin/inc/pages_form.php
+++ b/gxadmin/inc/pages_form.php
@@ -13,20 +13,39 @@
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 *
 */
-    if (isset($data['alertgreen'])) {
+
+isset($_GET['token'])? $token = $_GET['token']: $token = TOKEN;
+($_GET['act'] == "edit")? $pagetitle = "Edit": $pagetitle = "New";
+($_GET['act'] == "edit")? $act = "edit&id={$_GET['id']}&token={$_GET['token']}": $act = "add";
+
+if (isset($data['alertgreen'])) {
+    # code...
+    echo "<div class=\"alert alert-success\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>
+    ";
+    foreach ($data['alertgreen'] as $alert) {
         # code...
-        echo "<div class=\"alert alert-success\" >
-        <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
-            <span aria-hidden=\"true\">&times;</span>
-            <span class=\"sr-only\">Close</span>
-        </button>
-        ";
-        foreach ($data['alertgreen'] as $alert) {
-            # code...
-            echo "$alert\n";
-        }
-        echo "</div>";
+        echo "$alert\n";
+    }
+    echo "</div>";
+}
+
+if (isset($data['alertred'])) {
+    # code...
+    echo "<div class=\"alert alert-danger\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>";
+    foreach ($data['alertred'] as $alert) {
+        # code...
+        echo "$alert\n";
     }
+    echo "</div>";
+}
 
     if(isset($data['post'])) {
         foreach ($data['post'] as $p) {
@@ -54,7 +73,7 @@
         $unpub = "";
     }
 ?>
-<form action="" method="post" role="form" class="">
+<form action="index.php?page=pages&act=<?=$act?>" method="post" role="form" class="">
 <div class="row">
     <div class="col-md-12">
         <h1><i class="fa fa-file-o"></i> New Page 
@@ -114,5 +133,6 @@
         
     </div>
 </div>
+<input type="hidden" name="token" value="<?=$token;?>">
 </form>
 
diff --git a/gxadmin/inc/posts.php b/gxadmin/inc/posts.php
index 51287dc6..a3d29e02 100644
--- a/gxadmin/inc/posts.php
+++ b/gxadmin/inc/posts.php
@@ -55,6 +55,7 @@
                 <th>Title</th>
                 <th>Category</th>
                 <th>Date</th>
+                <th>Status</th>
                 <th>Edit/Delete</th>
                 <th>All <input type="checkbox" id="selectall"></th>
             </tr>
@@ -66,15 +67,21 @@
                     foreach ($data['posts'] as $p) {
                         # code...
                         //echo $p->id;
+                        if($p->status == '0'){
+                            $status = "UnPublished";
+                        }else{
+                            $status = "Published";
+                        }
                         echo "
                         <tr>
                             <td>{$p->id}</td>
                             <td><a href=\"".Url::post($p->id)."\" target=\"_new\">{$p->title}</a></td>
                             <td>".Categories::name($p->cat)."</td>
                             <td>{$p->date}</td>
+                            <td>{$status}</td>
                             <td>
-                                <a href=\"index.php?page=posts&act=edit&id={$p->id}\" class=\"label label-success\">Edit</a> 
-                                <a href=\"index.php?page=posts&act=del&id={$p->id}\" class=\"label label-danger\" 
+                                <a href=\"index.php?page=posts&act=edit&id={$p->id}&token=".TOKEN."\" class=\"label label-success\">Edit</a> 
+                                <a href=\"index.php?page=posts&act=del&id={$p->id}&token=".TOKEN."\" class=\"label label-danger\" 
                                 onclick=\"return confirm('Are you sure you want to delete this item?');\">Delete</a>
                             </td>
                             <td>
@@ -98,12 +105,14 @@
             <th>Title</th>
             <th>Category</th>
             <th>Date</th>
+            <th>Status</th>
             <th>
             <select name="action" class="form-control">
                 <option value="publish">Publish</option>
                 <option value="unpublish">UnPublish</option>
                 <option value="delete">Delete</option>
             </select>
+            <input type="hidden" name="token" value="<?=TOKEN;?>">
             </th>
             <th>
                 <button type="submit" name="doaction" class="btn btn-danger">
diff --git a/gxadmin/inc/posts_form.php b/gxadmin/inc/posts_form.php
index b8a7e31a..c02f862a 100644
--- a/gxadmin/inc/posts_form.php
+++ b/gxadmin/inc/posts_form.php
@@ -13,63 +13,66 @@
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 *
 */
-    if (isset($data['alertgreen'])) {
+isset($_GET['token'])? $token = $_GET['token']: $token = TOKEN;
+($_GET['act'] == "edit")? $pagetitle = "Edit": $pagetitle = "New";
+($_GET['act'] == "edit")? $act = "edit&id={$_GET['id']}&token={$_GET['token']}": $act = "add";
+if (isset($data['alertgreen'])) {
+    # code...
+    echo "<div class=\"alert alert-success\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>";
+    foreach ($data['alertgreen'] as $alert) {
         # code...
-        echo "<div class=\"alert alert-success\" >
-        <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
-            <span aria-hidden=\"true\">&times;</span>
-            <span class=\"sr-only\">Close</span>
-        </button>";
-        foreach ($data['alertgreen'] as $alert) {
-            # code...
-            echo "$alert\n";
-        }
-        echo "</div>";
+        echo "$alert\n";
     }
-    if (isset($data['alertred'])) {
+    echo "</div>";
+}
+if (isset($data['alertred'])) {
+    # code...
+    echo "<div class=\"alert alert-danger\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>";
+    foreach ($data['alertred'] as $alert) {
         # code...
-        echo "<div class=\"alert alert-danger\" >
-        <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
-            <span aria-hidden=\"true\">&times;</span>
-            <span class=\"sr-only\">Close</span>
-        </button>";
-        foreach ($data['alertred'] as $alert) {
-            # code...
-            echo "$alert\n";
-        }
-        echo "</div>";
+        echo "$alert\n";
     }
+    echo "</div>";
+}
 
-    if(isset($data['post'])) {
-        foreach ($data['post'] as $p) {
-            # code...
-            $title = $p->title;
-            $content = $p->content;
-            $date = $p->date;
-            $status = $p->status;
-            $cat = $p->cat;
-        }
-        if($status == 1) {
-            $pub = "SELECTED"; 
-            $unpub = ""; 
-        }elseif ($status == 0) {
-            $pub = ""; 
-            $unpub = "SELECTED";
-        }
-    }else{
-        $title = "";
-        $content = "";
-        $date = "";
-        $status = "";
-        $cat = "";
-        $pub = "";
-        $unpub = "";
+if(isset($data['post'])) {
+    foreach ($data['post'] as $p) {
+        # code...
+        $title = $p->title;
+        $content = $p->content;
+        $date = $p->date;
+        $status = $p->status;
+        $cat = $p->cat;
+    }
+    if($status == 1) {
+        $pub = "SELECTED"; 
+        $unpub = ""; 
+    }elseif ($status == 0) {
+        $pub = ""; 
+        $unpub = "SELECTED";
     }
+}else{
+    $title = "";
+    $content = "";
+    $date = "";
+    $status = "";
+    $cat = "";
+    $pub = "";
+    $unpub = "";
+}
 ?>
-<form action="" method="post" role="form" class="">
+<form action="index.php?page=posts&act=<?=$act?>" method="post" role="form" class="">
 <div class="row">
     <div class="col-md-12">
-        <h1><i class="fa fa-file-text-o"></i> New Post
+        <h1><i class="fa fa-file-text-o"></i> <?=$pagetitle;?> Post
             <div class="pull-right">
                 <button type="submit" name="submit" class="btn btn-success">
                     <span class="glyphicon glyphicon-ok"></span>
@@ -141,5 +144,6 @@
         
     </div>
 </div>
+<input type="hidden" name="token" value="<?=$token;?>">
 </form>
 
diff --git a/gxadmin/inc/settings.php b/gxadmin/inc/settings.php
index 1310439a..2d5362fe 100644
--- a/gxadmin/inc/settings.php
+++ b/gxadmin/inc/settings.php
@@ -12,7 +12,38 @@
 * @copyright 2014-2015 Puguh Wijayanto
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 *
-*/?>
+*/
+
+if (isset($data['alertgreen'])) {
+    # code...
+    echo "<div class=\"alert alert-success\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>
+    ";
+    foreach ($data['alertgreen'] as $alert) {
+        # code...
+        echo "$alert\n";
+    }
+    echo "</div>";
+}
+
+if (isset($data['alertred'])) {
+    # code...
+    echo "<div class=\"alert alert-danger\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>";
+    foreach ($data['alertred'] as $alert) {
+        # code...
+        echo "$alert\n";
+    }
+    echo "</div>";
+}
+
+?>
 <form action="" method="POST" enctype="multipart/form-data">
 <div class="row">
     <div class="col-md-12">
@@ -50,7 +81,7 @@
                   <div class="row">
                       <div class="col-sm-6 form-group">
                           <label>Website Name</label>
-                          <input type="text" name="sitename" value="<?=Options::get('sitename');?>" class="form-control">
+                          <input type="text" name="sitename" value="<?=Site::$name;?>" class="form-control">
                           <small>Your Website Name, Title</small>
                       </div>
                       <div class="col-sm-6 form-group">
@@ -66,12 +97,12 @@
                   <div class="row">
                       <div class="col-sm-6 form-group">
                           <label>Website Domain</label>
-                          <input type="text" name="sitedomain" value="<?=Options::get('sitedomain');?>" class="form-control">
+                          <input type="text" name="sitedomain" value="<?=Site::$domain;?>" class="form-control">
                           <small>Your Domain, eg: example.org</small>
                       </div>
                       <div class="col-sm-6 form-group">
                           <label>Website URL</label>
-                          <input type="text" name="siteurl" value="<?=Options::get('siteurl');?>" class="form-control">
+                          <input type="text" name="siteurl" value="<?=Site::$url;?>" class="form-control">
                           <small>Your Website URL, eg: http://www.example.org</small>
                       </div>
                   </div>
@@ -82,12 +113,12 @@
                   <div class="row">
                       <div class="col-sm-6 form-group">
                           <label>Website Keywords</label>
-                          <input type="text" name="sitekeywords" value="<?=Options::get('sitekeywords');?>" class="form-control">
+                          <input type="text" name="sitekeywords" value="<?=Site::$key;?>" class="form-control">
                           <small>Your Website Keywords, type your website main keywords.</small>
                       </div>
                       <div class="col-sm-6 form-group">
                           <label>Website Description</label>
-                          <textarea  name="sitedesc" class="form-control"><?=Options::get('sitedesc');?></textarea>
+                          <textarea  name="sitedesc" class="form-control"><?=Site::$desc;?></textarea>
                           <small>Your Website Description, describe your website.</small>
                       </div>
                   </div>
@@ -224,7 +255,7 @@
                               if($is_logourl == 'on' && $logourl != ''){
                                 $logoimg = "<img src=\"".Options::get('logourl')."\" class=\"clearfix\">";
                               }elseif($is_logourl == 'off' && $logo != ''){
-                                $logoimg = "<img src=\"".Options::get('siteurl').Options::get('logo')."\" class=\"clearfix\">";
+                                $logoimg = "<img src=\"".Site::$url.Options::get('logo')."\" class=\"clearfix\">";
                               }else{
                                 $logoimg = '';
                               }
@@ -562,6 +593,7 @@ class="form-control disable" placeholder="Bootstrap Validator Version"
 
     </div>
 </div>
+<input type="hidden" name="token" value="<?=TOKEN;?>">
 </form>
 <script>
 $('#myTab a').click(function (e) {
diff --git a/gxadmin/inc/user.php b/gxadmin/inc/user.php
index 670826e9..55136afd 100644
--- a/gxadmin/inc/user.php
+++ b/gxadmin/inc/user.php
@@ -75,9 +75,9 @@
                         <td>{$p->userid}</td>
                         <td>{$p->email}</td>
                         <td>
-                            <a href=\"index.php?page=users&act=edit&id={$p->id}\" class=\"label label-success\">Edit</a> 
-                            <a href=\"index.php?page=users&act=del&id={$p->id}\" class=\"label label-danger\" 
-                            onclick=\"return confirm('Are you sure you want to delete this item?');\">Delete</a>
+                            <a href=\"index.php?page=users&act=edit&id={$p->id}&token=".TOKEN."\" class=\"label label-success\">Edit</a> 
+                            <a href=\"index.php?page=users&act=del&id={$p->id}&token=".TOKEN."\" class=\"label label-danger\" 
+                            onclick=\"return confirm('Are you sure you want to delete this?');\">Delete</a>
                         </td>
                     </tr>
                     ";
@@ -114,7 +114,7 @@
                 </div>
                 <div class="form-group">
                     <label>E-Mail</label>
-                    <input type="password" name="email" class="form-control">
+                    <input type="email" name="email" class="form-control">
                 </div>
                 <div class="form-group">
                     <label>Group Level</label>
@@ -129,6 +129,7 @@
             <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
             <button type="submit" class="btn btn-success" name="adduser">Save changes</button>
           </div>
+          <input type="hidden" name="token" value="<?=TOKEN;?>">
           </form>
         </div><!-- /.modal-content -->
       </div><!-- /.modal-dialog -->
diff --git a/gxadmin/inc/user_form.php b/gxadmin/inc/user_form.php
index 0b6b7539..b692e1e9 100644
--- a/gxadmin/inc/user_form.php
+++ b/gxadmin/inc/user_form.php
@@ -13,34 +13,34 @@
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 *
 */
-    if (isset($data['alertgreen'])) {
+if (isset($data['alertgreen'])) {
+    # code...
+    echo "<div class=\"alert alert-success\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>
+    <ul>";
+    foreach ($data['alertgreen'] as $alert) {
         # code...
-        echo "<div class=\"alert alert-success\" >
-        <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
-            <span aria-hidden=\"true\">&times;</span>
-            <span class=\"sr-only\">Close</span>
-        </button>
-        <ul>";
-        foreach ($data['alertgreen'] as $alert) {
-            # code...
-            echo "<li>$alert</li>\n";
-        }
-        echo "</ul></div>";
-    }elseif (isset($data['alertred'])) {
+        echo "<li>$alert</li>\n";
+    }
+    echo "</ul></div>";
+}elseif (isset($data['alertred'])) {
+    # code...
+    //print_r($data['alertred']);
+    echo "<div class=\"alert alert-danger\" >
+    <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
+        <span aria-hidden=\"true\">&times;</span>
+        <span class=\"sr-only\">Close</span>
+    </button>
+    <ul>";
+    foreach ($data['alertred'] as $alert) {
         # code...
-        //print_r($data['alertred']);
-        echo "<div class=\"alert alert-danger\" >
-        <button type=\"button\" class=\"close\" data-dismiss=\"alert\">
-            <span aria-hidden=\"true\">&times;</span>
-            <span class=\"sr-only\">Close</span>
-        </button>
-        <ul>";
-        foreach ($data['alertred'] as $alert) {
-            # code...
-            echo "<li>$alert</li>\n";
-        }
-        echo "</ul></div>";
+        echo "<li>$alert</li>\n";
     }
+    echo "</ul></div>";
+}
 ?>
 <form action="" method="post">
 <div class="row">
@@ -109,4 +109,5 @@
     </div>
     </div>
 </div>
+<input type="hidden" name="token" value="<?=$_GET['token'];?>">
 </form>
diff --git a/inc/lib/Categories.class.php b/inc/lib/Categories.class.php
index 6ae6fd4d..2e675240 100644
--- a/inc/lib/Categories.class.php
+++ b/inc/lib/Categories.class.php
@@ -68,14 +68,17 @@ public static function dropdown($vars) {
             }
             if (isset($vars['sort'])) {
                 $sort = " {$vars['sort']}";
+            }else{
+                $sort = " ASC";
             }
         }
         $cat = Db::result("SELECT * FROM `cat` {$where} {$order_by} {$sort}");
+        //print_r($cat);
         $drop = "<select name=\"{$name}\" class=\"form-control\"><option></option>";
         if(Db::$num_rows > 0 ){
             foreach ($cat as $c) {
                 # code...
-                if($c->parent == ''){
+                if($c->parent == null || $c->parent == '0' ){
                     if(isset($vars['selected']) && $c->id == $vars['selected']) $sel = "SELECTED"; else $sel = "";
                     $drop .= "<option value=\"{$c->id}\" $sel style=\"padding-left: 10px;\">{$c->name}</option>";
                     foreach ($cat as $c2) {
diff --git a/inc/lib/Control.class.php b/inc/lib/Control.class.php
index 78b39dd9..ae1ff495 100644
--- a/inc/lib/Control.class.php
+++ b/inc/lib/Control.class.php
@@ -145,11 +145,11 @@ public static function backend($vars="") {
     * @author Puguh Wijayanto (www.metalgenix.com)
     * @since 0.0.1 
     */
-    public static function error ($vars="") {
+    public static function error ($vars="", $val='') {
         if( isset($vars) && $vars != "" ) {
             include(GX_PATH.'/inc/lib/Control/Error/'.$vars.'.control.php');
         }else{
-            include(GX_PATH.'/inc/lib/Control/Error/404.control.php');
+            include(GX_PATH.'/inc/lib/Control/Error/unknown.control.php');
         }
     }
 
diff --git a/inc/lib/Control/Backend/categories.control.php b/inc/lib/Control/Backend/categories.control.php
index 1fb8242f..598dedcb 100644
--- a/inc/lib/Control/Backend/categories.control.php
+++ b/inc/lib/Control/Backend/categories.control.php
@@ -16,8 +16,23 @@
 switch (isset($_POST['addcat'])) {
     case true:
         # code...
-        $slug = Typo::slugify($_POST['cat']);
-        $cat = Db::insert("INSERT INTO `cat` VALUES ('', '{$_POST['cat']}', '{$slug}', '{$_POST['parent']}', '' )");
+        if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+            // VALIDATE ALL
+            $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+        }
+        if(isset($alertred)){
+            $data['alertred'] = $alertred;
+        }else{
+            $slug = Typo::slugify(Typo::cleanX($_POST['cat']));
+            $cat = Typo::cleanX($_POST['cat']);
+            $cat = Db::insert(
+                        sprintf("INSERT INTO `cat` VALUES (null, '%s', '%s', '%d', '' )", 
+                            $cat, $slug, $_POST['parent']
+                        )
+                    );
+            //print_r($cat);
+            $data['alertgreen'][] = "Category Added: ".$_POST['cat'];
+        }
         break;
     
     default:
@@ -28,14 +43,23 @@
 switch (isset($_POST['updatecat'])) {
     case true:
         # code...
-        $vars = array(
-                    'table' => 'cat',
-                    'id' => $_POST['id'],
-                    'key' => array(
-                                'name' => $_POST['cat']
-                            )
-                );
-        $cat = Db::update($vars);
+        if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+            // VALIDATE ALL
+            $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+        }
+        if(isset($alertred)){
+            $data['alertred'] = $alertred;
+        }else{
+            $vars = array(
+                        'table' => 'cat',
+                        'id' => $_POST['id'],
+                        'key' => array(
+                                    'name' => Typo::cleanX($_POST['cat'])
+                                )
+                    );
+            $cat = Db::update($vars);
+            $data['alertgreen'][] = "Category Updated: ".$_POST['cat'];
+        }
         break;
     
     default:
@@ -44,7 +68,16 @@
 }
 
 if(isset($_GET['act']) == 'del'){
-    Categories::delete($_GET['id']);
+    if (!isset($_GET['token']) || !Token::isExist($_GET['token'])) {
+        // VALIDATE ALL
+        $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+    }
+    if(isset($alertred)){
+        $data['alertred'] = $alertred;
+    }else{
+        Categories::delete($_GET['id']);
+        $data['alertgreen'][] = "Category Removed";
+    }
 }
 $data['cat'] = Db::result("SELECT * FROM `cat` ORDER BY `id` DESC");
 $data['num'] = Db::$num_rows;
diff --git a/inc/lib/Control/Backend/menus.control.php b/inc/lib/Control/Backend/menus.control.php
index 87dd97c5..f1a71252 100644
--- a/inc/lib/Control/Backend/menus.control.php
+++ b/inc/lib/Control/Backend/menus.control.php
@@ -27,61 +27,69 @@
         switch ($submit) {
             case true:
                 # code...
-                $menus = Options::get('menus');
-                $menus = json_decode(Options::get('menus'), true);
-                echo "<pre>"; print_r($menus); echo "</pre>";
-                // $menu = array(
-                //                 $_POST['id']  =>  array(
-                //                             'name' => $menus[$_POST['id']]['name'],
-                //                             'class' => $menus[$_POST['id']]['class'],
-                //                             'menu' => array(
-                //                                     'parent' => $_POST['parent'],
-                //                                     'menuid' => $_POST['id'],
-                //                                     'type' => $_POST['type'],
-                //                                     'value' => $_POST[$_POST['type']]
-                //                                 )
-                //                         )
-                //                 );
-                
-                // if(is_array($menus)){
-                //     $menu = array_merge($menus, $menu);
-                // }
-                // echo "<pre>"; print_r($menu); echo "</pre>";
-                //$menu = $menus;
-                $menu[$_POST['id']]['menu'] = $menus[$_POST['id']]['menu'];
-                $menu[$_POST['id']]['menu'][] = array(
-                                                    'parent' => $_POST['parent'],
-                                                    'menuid' => $_POST['id'],
-                                                    'name' => $_POST['name'],
-                                                    'type' => $_POST['type'],
-                                                    'value' => $_POST[$_POST['type']],
-                                                    'sub' => ''
-                                                );
-                 $menu = array(
-                                $_POST['id']  =>  array(
-                                            'name' => $menus[$_POST['id']]['name'],
-                                            'class' => $menus[$_POST['id']]['class'],
-                                            'menu' => $menu[$_POST['id']]['menu']    
-                                        )
-                                );
-                if(is_array($menus)){
-                    $menu = array_merge($menus, $menu);
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
+                }else{
+                    $menus = Options::get('menus');
+                    $menus = json_decode(Options::get('menus'), true);
+                   //echo "<pre>"; print_r($menus); echo "</pre>";
+                    // $menu = array(
+                    //                 $_POST['id']  =>  array(
+                    //                             'name' => $menus[$_POST['id']]['name'],
+                    //                             'class' => $menus[$_POST['id']]['class'],
+                    //                             'menu' => array(
+                    //                                     'parent' => $_POST['parent'],
+                    //                                     'menuid' => $_POST['id'],
+                    //                                     'type' => $_POST['type'],
+                    //                                     'value' => $_POST[$_POST['type']]
+                    //                                 )
+                    //                         )
+                    //                 );
+                    
+                    // if(is_array($menus)){
+                    //     $menu = array_merge($menus, $menu);
+                    // }
+                    // echo "<pre>"; print_r($menu); echo "</pre>";
+                    //$menu = $menus;
+                    $menu[$_POST['id']]['menu'] = $menus[$_POST['id']]['menu'];
+                    $menu[$_POST['id']]['menu'][] = array(
+                                                        'parent' => $_POST['parent'],
+                                                        'menuid' => $_POST['id'],
+                                                        'name' => Typo::cleanX($_POST['name']),
+                                                        'type' => $_POST['type'],
+                                                        'value' => $_POST[$_POST['type']],
+                                                        'sub' => ''
+                                                    );
+                     $menu = array(
+                                    $_POST['id']  =>  array(
+                                                'name' => $menus[$_POST['id']]['name'],
+                                                'class' => $menus[$_POST['id']]['class'],
+                                                'menu' => $menu[$_POST['id']]['menu']    
+                                            )
+                                    );
+                    if(is_array($menus)){
+                        $menu = array_merge($menus, $menu);
+                    }
+                    //echo "<pre>"; print_r($menu); echo "</pre>";
+                    $menu = json_encode($menu);
+                    //echo "<pre>"; print_r($menu); echo "</pre>";
+                    //Options::update('menus', $menu);
+
+                    $vars = array(
+                                'parent' => $_POST['parent'],
+                                'menuid' => $_POST['id'],
+                                'name' => Typo::cleanX($_POST['name']),
+                                'class' => Typo::cleanX($_POST['class']),
+                                'type' => $_POST['type'],
+                                'value' => $_POST[$_POST['type']]
+                            );
+                    Menus::insert($vars);
+                    $data['alertgreen'][] = 'Menu Added';
                 }
-                 echo "<pre>"; print_r($menu); echo "</pre>";
-                $menu = json_encode($menu);
-                echo "<pre>"; print_r($menu); echo "</pre>";
-                //Options::update('menus', $menu);
-
-                $vars = array(
-                            'parent' => $_POST['parent'],
-                            'menuid' => $_POST['id'],
-                            'name' => $_POST['name'],
-                            'class' => $_POST['class'],
-                            'type' => $_POST['type'],
-                            'value' => $_POST[$_POST['type']]
-                        );
-                Menus::insert($vars);
-                $data['alertgreen'][] = 'Menu Added';
                 break;
             
             default:
@@ -95,7 +103,7 @@
         }else{
             $menuid = '';
         }
-        $data['parent'] = Menus::getParent('', $menuid);
+        $data['parent'] = Menus::isHadParent('', $menuid);
         //echo "<pre>"; print_r($data); echo "</pre>";
         System::inc('menus_form', $data);
         break;
@@ -110,22 +118,29 @@
         }
         switch ($submit) {
             case true:
-                
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
+                }else{
 
-                $vars = array(
-                            // 'parent' => $_POST['parent'],
-                            'menuid' => $_POST['id'],
-                            'name' => $_POST['name'],
-                            'class' => $_POST['class'],
-                            'type' => $_POST['type'],
-                            'value' => $_POST[$_POST['type']]
-                        );
-                $vars = array(
-                            'id' => $_GET['itemid'],
-                            'key' => $vars
-                        );
-                Menus::update($vars);
-                $data['alertgreen'][] = 'Menu Updated';
+                    $vars = array(
+                                'parent' => $_POST['parent'],
+                                'menuid' => $_POST['id'],
+                                'name' => Typo::cleanX($_POST['name']),
+                                'class' => Typo::cleanX($_POST['class']),
+                                'type' => $_POST['type'],
+                                'value' => $_POST[$_POST['type']]
+                            );
+                    $vars = array(
+                                'id' => $_GET['itemid'],
+                                'key' => $vars
+                            );
+                    Menus::update($vars);
+                    $data['alertgreen'][] = 'Menu Updated';
+                }
                 break;
             
             default:
@@ -140,13 +155,21 @@
             $menuid = '';
         }
         $data['menus'] = Menus::getId($_GET['itemid']);
-        $data['parent'] = Menus::getParent('', $menuid);
+        $data['parent'] = Menus::isHadParent('', $menuid);
         System::inc('menus_form_edit', $data);
         break;
     case 'del':
         if(isset($_GET['itemid'])){
-            Menus::delete($_GET['itemid']);
-            $data['alertgreen'][] = 'Menu Deleted';
+            if (!isset($_GET['token']) || !Token::isExist($_GET['token'])) {
+                // VALIDATE ALL
+                $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+            }
+            if(isset($alertred)){
+                $data['alertred'] = $alertred;
+            }else{
+                Menus::delete($_GET['itemid']);
+                $data['alertgreen'][] = 'Menu Deleted';
+            }
         }else{
             $data['alertred'][] = 'No ID Selected.';
         }
@@ -162,20 +185,28 @@
         switch ($submit) {
             case true:
                 # code...
-                $menu = array(
-                                $_POST['id']  =>  array(
-                                            'name' => $_POST['name'],
-                                            'class' => $_POST['class'],
-                                            'menu' => array()
-                                        )
-                                );
-                $menus = json_decode(Options::get('menus'), true);
-                if(is_array($menus)){
-                    $menu = array_merge($menus, $menu);
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
+                }else{
+                    $menu = array(
+                                    $_POST['id']  =>  array(
+                                                'name' => Typo::cleanX($_POST['name']),
+                                                'class' => Typo::cleanX($_POST['class']),
+                                                'menu' => array()
+                                            )
+                                    );
+                    $menus = json_decode(Options::get('menus'), true);
+                    if(is_array($menus)){
+                        $menu = array_merge($menus, $menu);
+                    }
+                    
+                    $menu = json_encode($menu);
+                    Options::update('menus', $menu);
                 }
-                
-                $menu = json_encode($menu);
-                Options::update('menus', $menu);
                 break;
             
             default:
@@ -196,17 +227,24 @@
         switch ($submit) {
             case true:
                 
-
-                $vars = array(
-                            'parent' => $_POST['parent'],
-                            'menuid' => $_POST['id'],
-                            'name' => $_POST['name'],
-                            'class' => $_POST['class'],
-                            'type' => $_POST['type'],
-                            'value' => $_POST[$_POST['type']]
-                        );
-                Menus::insert($vars);
-                $data['alertgreen'][] = 'Menu Item Added';
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
+                }else{
+                    $vars = array(
+                                'parent' => $_POST['parent'],
+                                'menuid' => $_POST['id'],
+                                'name' => Typo::cleanX($_POST['name']),
+                                'class' => Typo::cleanX($_POST['class']),
+                                'type' => $_POST['type'],
+                                'value' => $_POST[$_POST['type']]
+                            );
+                    Menus::insert($vars);
+                    $data['alertgreen'][] = 'Menu Item Added';
+                }
                 break;
             
             default:
@@ -230,9 +268,16 @@
                 // echo "<pre>";
                 // print_r($_POST['order']);
                 // echo "</pre>";
-
-                Menus::updateMenuOrder($_POST['order']);
-                $data['alertgreen'][] = 'Menu Order Changed';
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
+                }else{
+                    Menus::updateMenuOrder($_POST['order']);
+                    $data['alertgreen'][] = 'Menu Order Changed';
+                }
                 break;
             
             default:
diff --git a/inc/lib/Control/Backend/pages.control.php b/inc/lib/Control/Backend/pages.control.php
index afcb27ad..f6f62ec8 100644
--- a/inc/lib/Control/Backend/pages.control.php
+++ b/inc/lib/Control/Backend/pages.control.php
@@ -23,23 +23,31 @@
         switch (isset($_POST['submit'])) {
             case true:
                 # code...
-                if (!isset($_POST['date']) || $_POST['date'] == "") {
-                    # code...
-                    $date = date("Y-m-d H:i:s");
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
                 }else{
-                    $date = $_POST['date'];
+                    if (!isset($_POST['date']) || $_POST['date'] == "") {
+                        # code...
+                        $date = date("Y-m-d H:i:s");
+                    }else{
+                        $date = $_POST['date'];
+                    }
+                    $vars = array(
+                                    'title' => Typo::cleanX($_POST['title']),
+                                    'content' => Typo::cleanX($_POST['content']),
+                                    'date' => $date,
+                                    'type' => 'page',
+                                    'author' => Session::val('username'),
+                                    'status' => $_POST['status'],
+                                );
+                    //print_r($vars);
+                    Posts::insert($vars);
+                    $data['alertgreen'][] = "Page : {$_POST['title']} Added.";
                 }
-                $vars = array(
-                                'title' => Typo::cleanX($_POST['title']),
-                                'content' => Typo::cleanX($_POST['content']),
-                                'date' => $date,
-                                'type' => 'page',
-                                'author' => Session::val('username'),
-                                'status' => $_POST['status'],
-                            );
-                //print_r($vars);
-                Posts::insert($vars);
-                $data['alertgreen'][] = "Page : {$_POST['title']} Added.";
                 break;
             
             default:
@@ -55,23 +63,31 @@
         switch (isset($_POST['submit'])) {
             case true:
                 # code...
-                if (!isset($_POST['date']) || $_POST['date'] == "") {
-                    # code...
-                    $date = date("Y-m-d H:i:s");
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
                 }else{
-                    $date = $_POST['date'];
+                    if (!isset($_POST['date']) || $_POST['date'] == "") {
+                        # code...
+                        $date = date("Y-m-d H:i:s");
+                    }else{
+                        $date = $_POST['date'];
+                    }
+                    $moddate = date("Y-m-d H:i:s");
+                    $vars = array(
+                                    'title' => Typo::cleanX($_POST['title']),
+                                    'content' => Typo::cleanX($_POST['content']),
+                                    'modified' => $moddate,
+                                    'date' => $date,
+                                    'status' => $_POST['status'],
+                                );
+                    //print_r($vars);
+                    Posts::update($vars);
+                    $data['alertgreen'][] = "Page : {$_POST['title']} Updated.";
                 }
-                $moddate = date("Y-m-d H:i:s");
-                $vars = array(
-                                'title' => Typo::cleanX($_POST['title']),
-                                'content' => Typo::cleanX($_POST['content']),
-                                'modified' => $moddate,
-                                'date' => $date,
-                                'status' => $_POST['status'],
-                            );
-                //print_r($vars);
-                Posts::update($vars);
-                $data['alertgreen'][] = "Page : {$_POST['title']} Updated.";
                 break;
             
             default:
@@ -91,7 +107,15 @@
         if(isset($_GET['act']) && $_GET['act'] == 'del'){
             if(isset($_GET['id'])){
                 $title = Posts::title($_GET['id']);
-                $del = Posts::delete($_GET['id']);
+                if (!isset($_GET['token']) || !Token::isExist($_GET['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
+                }else{
+                    $del = Posts::delete($_GET['id']);
+                }
                 //echo $title['error'];
                 if(isset($del['error'])){
                     $data['alertred'][] = $del['error'];
@@ -114,23 +138,47 @@
             
             case 'publish':
                 # code...
-                foreach ($post_id as $id) {
-                    # code...
-                    Posts::publish($id);
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
+                }else{
+                    foreach ($post_id as $id) {
+                        # code...
+                        Posts::publish($id);
+                    }
                 }
                 break;
             case 'unpublish':
                 # code...
-                foreach ($post_id as $id) {
-                    # code...
-                    Posts::unpublish($id);
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
+                }else{
+                    foreach ($post_id as $id) {
+                        # code...
+                        Posts::unpublish($id);
+                    }
                 }
                 break;
             case 'delete':
                 # code...
-                foreach ($post_id as $id) {
-                    # code...
-                    Posts::delete($id);
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
+                }else{
+                    foreach ($post_id as $id) {
+                        # code...
+                        Posts::delete($id);
+                    }
                 }
                 break;
             
diff --git a/inc/lib/Control/Backend/posts.control.php b/inc/lib/Control/Backend/posts.control.php
index 60846938..ce17feba 100644
--- a/inc/lib/Control/Backend/posts.control.php
+++ b/inc/lib/Control/Backend/posts.control.php
@@ -23,24 +23,33 @@
         switch (isset($_POST['submit'])) {
             case true:
                 # code...
-                if (!isset($_POST['date']) || $_POST['date'] == "") {
-                    # code...
-                    $date = date("Y-m-d H:i:s");
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if(isset($alertred)){
+                    $data['alertred'] = $alertred;
                 }else{
-                    $date = $_POST['date'];
+                    if (!isset($_POST['date']) || $_POST['date'] == "") {
+                        # code...
+                        $date = date("Y-m-d H:i:s");
+                    }else{
+                        $date = $_POST['date'];
+                    }
+                    $vars = array(
+                                    'title' => Typo::cleanX($_POST['title']),
+                                    'cat' => $_POST['cat'],
+                                    'content' => Typo::cleanX($_POST['content']),
+                                    'date' => $date,
+                                    'type' => 'post',
+                                    'author' => Session::val('username'),
+                                    'status' => $_POST['status'],
+                                );
+                    //print_r($vars);
+                    Posts::insert($vars);
+                    $data['alertgreen'][] = "Post : {$_POST['title']} Added.";
                 }
-                $vars = array(
-                                'title' => Typo::cleanX($_POST['title']),
-                                'cat' => $_POST['cat'],
-                                'content' => Typo::cleanX($_POST['content']),
-                                'date' => $date,
-                                'type' => 'post',
-                                'author' => Session::val('username'),
-                                'status' => $_POST['status'],
-                            );
-                //print_r($vars);
-                Posts::insert($vars);
-                $data['alertgreen'][] = "Post : {$_POST['title']} Added.";
+                    
                 break;
             
             default:
@@ -57,20 +66,29 @@
         switch (isset($_POST['submit'])) {
             case true:
                 # code...
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if (isset($alertred)) {
+                    # code...
+                    $data['alertred'] = $alertred;
+                }else{
+                    $moddate = date("Y-m-d H:i:s");
+                    $vars = array(
+                                    'title' => Typo::cleanX($_POST['title']),
+                                    'cat' => $_POST['cat'],
+                                    'content' => Typo::cleanX($_POST['content']),
+                                    'modified' => $moddate,
+                                    'date' => $_POST['date'],
+                                    'status' => $_POST['status'],
+                                );
+                    //print_r($vars);
+                    
+                    Posts::update($vars);
+                    $data['alertgreen'][] = "Post : <b>{$_POST['title']}</b> Updated.";
+                }
                 
-                $moddate = date("Y-m-d H:i:s");
-                $vars = array(
-                                'title' => Typo::cleanX($_POST['title']),
-                                'cat' => $_POST['cat'],
-                                'content' => Typo::cleanX($_POST['content']),
-                                'modified' => $moddate,
-                                'date' => $_POST['date'],
-                                'status' => $_POST['status'],
-                            );
-                //print_r($vars);
-                
-                Posts::update($vars);
-                $data['alertgreen'][] = "Post : <b>{$_POST['title']}</b> Updated.";
                 break;
             
             default:
@@ -89,13 +107,23 @@
         # code...
         if(isset($_GET['act']) && $_GET['act'] == 'del'){
             if(isset($_GET['id'])){
-                $title = Posts::title($_GET['id']);
-                $del = Posts::delete($_GET['id']);
-                //echo $title['error'];
-                if(isset($del['error'])){
-                    $data['alertred'][] = $del['error'];
+                if (!isset($_GET['token']) || !Token::isExist($_GET['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if (isset($alertred)) {
+                    # code...
+                    $data['alertred'] = $alertred;
                 }else{
-                    $data['alertgreen'][] = 'Post <b>'.$title.'</b> Removed';
+
+                    $title = Posts::title($_GET['id']);
+                    $del = Posts::delete($_GET['id']);
+                    //echo $title['error'];
+                    if(isset($del['error'])){
+                        $data['alertred'][] = $del['error'];
+                    }else{
+                        $data['alertgreen'][] = 'Post <b>'.$title.'</b> Removed';
+                    }
                 }
                 
             }else{
@@ -113,23 +141,50 @@
 
             case 'publish':
                 # code...
-                foreach ($post_id as $id) {
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if (isset($alertred)) {
                     # code...
-                    Posts::publish($id);
+                    $data['alertred'] = $alertred;
+                }else{
+                    foreach ($post_id as $id) {
+                        # code...
+                        Posts::publish($id);
+                    }
                 }
                 break;
             case 'unpublish':
                 # code...
-                foreach ($post_id as $id) {
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if (isset($alertred)) {
                     # code...
-                    Posts::unpublish($id);
+                    $data['alertred'] = $alertred;
+                }else{
+                    foreach ($post_id as $id) {
+                        # code...
+                        Posts::unpublish($id);
+                    }
                 }
                 break;
             case 'delete':
                 # code...
-                foreach ($post_id as $id) {
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
+                if (isset($alertred)) {
                     # code...
-                    Posts::delete($id);
+                    $data['alertred'] = $alertred;
+                }else{
+                    foreach ($post_id as $id) {
+                        # code...
+                        Posts::delete($id);
+                    }
                 }
                 break;
             
diff --git a/inc/lib/Control/Backend/settings.control.php b/inc/lib/Control/Backend/settings.control.php
index cdb543f2..beb5b246 100644
--- a/inc/lib/Control/Backend/settings.control.php
+++ b/inc/lib/Control/Backend/settings.control.php
@@ -14,48 +14,56 @@
 *
 */
 
-
+$data = "";
 switch (isset($_POST['change'])) {
     case '1':
         # code...
-        $vars = array();
-        if(isset($_FILES['logo']) && $_FILES['logo'] != ''){
-            $path = "/assets/images/";
-            $allowed = array('png', 'jpg', 'gif');
-            $upload = Upload::go('logo', $path, $allowed );
-            if(isset($upload['error']) != ''){
-                echo $upload['error'];
+        if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+            // VALIDATE ALL
+            $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+        }
+        if(isset($alertred)){
+            $data['alertred'] = $alertred;
+        }else{
+            $vars = array();
+            if(isset($_FILES['logo']) && $_FILES['logo'] != ''){
+                $path = "/assets/images/";
+                $allowed = array('png', 'jpg', 'gif');
+                $upload = Upload::go('logo', $path, $allowed );
+                if(isset($upload['error']) != ''){
+                    echo $upload['error'];
+                }else{
+                    $vars['logo'] = $upload['path'];
+                }
             }else{
-                $vars['logo'] = $upload['path'];
+                unset($_POST['logo']);
             }
-        }else{
-            unset($_POST['logo']);
-        }
 
-        
-        
-        //print_r($_POST);
-        $flip = array_flip($_POST);
-        $sql = "SELECT * FROM `options` WHERE `value` = 'on'";        
-        $q = Db::result($sql);
-        foreach($q as $ob) {
-            if( isset( $flip[$ob->name] ) ) {
-                $vars[$ob->name] = 'on';
-                //echo $ob->name;
-            }else{
-                $vars[$ob->name] = 'off';
-                //echo $ob->name;
+            
+            
+            //print_r($_POST);
+            $flip = array_flip($_POST);
+            $sql = "SELECT * FROM `options` WHERE `value` = 'on'";        
+            $q = Db::result($sql);
+            foreach($q as $ob) {
+                if( isset( $flip[$ob->name] ) ) {
+                    $vars[$ob->name] = 'on';
+                    //echo $ob->name;
+                }else{
+                    $vars[$ob->name] = 'off';
+                    //echo $ob->name;
+                }
             }
+            //print_r($ob);
+            foreach ($_POST as $key => $val) {
+                # code...
+                $vars[$key] = $val;
+            }
+            unset($vars['change']);
+            //print_r($vars);
+            Options::update($vars);
+            $data['alertgreen'][] = "New Settings Saved.";
         }
-        //print_r($ob);
-        foreach ($_POST as $key => $val) {
-            # code...
-            $vars[$key] = $val;
-        }
-        unset($vars['change']);
-        //print_r($vars);
-        Options::update($vars);
-
         break;
     
     default:
@@ -63,7 +71,7 @@
         //print_r($data);
         break;
 }
-System::inc('settings');
+System::inc('settings',$data);
 
 /* End of file settings.control.php */
 /* Location: ./inc/lib/Control/Backend/settings.control.php */
\ No newline at end of file
diff --git a/inc/lib/Control/Backend/users.control.php b/inc/lib/Control/Backend/users.control.php
index e5c94818..09787ca9 100644
--- a/inc/lib/Control/Backend/users.control.php
+++ b/inc/lib/Control/Backend/users.control.php
@@ -23,6 +23,11 @@
         switch (isset($_POST['edituser'])) {
             case true:
                 # code...
+                //check token first 
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
                 // VALIDATE ALL
                 if(!User::is_exist($_POST['userid'])){
                     $alertred[] = "User Exist!! Choose another userid.";
@@ -59,6 +64,8 @@
                 }else{
                     $data['alertred'] = $alertred;
                 }
+                
+                
                 break;
             
             default:
@@ -70,8 +77,14 @@
     case 'del':
             if(isset($_GET['id'])){
                 $user = User::userid($_GET['id']);
-                User::delete($_GET['id']);
-                $data['alertgreen'][] = "User : ".$user." Removed";
+                if (!isset($_GET['token']) || !Token::isExist($_GET['token'])) {
+                    // VALIDATE ALL
+                    $data['alertred'][] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }else{
+                    User::delete($_GET['id']);
+                    $data['alertgreen'][] = "User : ".$user." Removed";
+                }
+                
             }else{
                 $data['alertred'][] = "No ID selected";
             }
@@ -85,7 +98,12 @@
         switch (isset($_POST['adduser'])) {
             case true:
                 # code...
-                // VALIDATE ALL
+                // CHECK TOKEN FIRST 
+                //echo Token::isExist($_POST['token']);
+                if (!isset($_POST['token']) || !Token::isExist($_POST['token'])) {
+                    // VALIDATE ALL
+                    $alertred[] = "Token not exist, or your time has expired. Please refresh your browser to get a new token.";
+                }
                 if(!User::is_exist($_POST['userid'])){
                     $alertred[] = "User Exist!! Choose another userid.";
                 }
@@ -108,9 +126,11 @@
                                     
                                 );   
                     User::create($vars);
+                    Token::remove(TOKEN);
                 }else{
                     $data['alertred'] = $alertred;
                 }
+
                 break;
             
             default:
diff --git a/inc/lib/Control/Error/db.control.php b/inc/lib/Control/Error/db.control.php
new file mode 100644
index 00000000..ad9ef52d
--- /dev/null
+++ b/inc/lib/Control/Error/db.control.php
@@ -0,0 +1,8 @@
+<h2>Database Error</h2>
+Something went wrong with the database.<br />
+<span style="border-radius: 7px; border: 3px solid #cc0000; line-height: 35px; 
+height: 50px; background-color: #aa0000; color: #fff; padding: 5px;">
+<?php
+echo $val;
+?>
+</span>
\ No newline at end of file
diff --git a/inc/lib/Control/Error/unknown.control.php b/inc/lib/Control/Error/unknown.control.php
new file mode 100644
index 00000000..da0ad168
--- /dev/null
+++ b/inc/lib/Control/Error/unknown.control.php
@@ -0,0 +1,10 @@
+<h2>Unknown Error Occured</h2>
+<?php if(isset($val)) {?>
+<div class="alert alert-danger">
+<?=$val;?>
+</div>
+
+<?php
+    }
+    Site::footer();
+?>
\ No newline at end of file
diff --git a/inc/lib/Control/Frontend/cat.control.php b/inc/lib/Control/Frontend/cat.control.php
index b6b34c7a..bf976afd 100644
--- a/inc/lib/Control/Frontend/cat.control.php
+++ b/inc/lib/Control/Frontend/cat.control.php
@@ -26,6 +26,7 @@
                         sprintf("SELECT * FROM `posts` 
                             WHERE `type` = 'post' 
                             AND `cat` = '%d'
+                            AND `status` = '1'
                             ORDER BY `date` 
                             DESC LIMIT %d, %d",
                             $_GET['cat'], $offset, $data['max']
@@ -33,11 +34,13 @@
                         );
 $data['num'] = Db::$num_rows;
 if($data['num'] > 0) {
-    Theme::theme('header');
+    Theme::theme('header',$data);
     Theme::theme('cat', $data);
     Theme::footer();
+    exit;
 }else{
     Control::error('404');
+    exit;
 }
 
 /* End of file cat.control.php */
diff --git a/inc/lib/Control/Frontend/default.control.php b/inc/lib/Control/Frontend/default.control.php
index 160c9f76..bf4f3a82 100644
--- a/inc/lib/Control/Frontend/default.control.php
+++ b/inc/lib/Control/Frontend/default.control.php
@@ -24,13 +24,14 @@
 $data['posts'] = Db::result(
                         sprintf("SELECT * FROM `posts` 
                             WHERE `type` = 'post' 
+                            AND `status` = '1'
                             ORDER BY `date` 
                             DESC LIMIT %d, %d",
                             $offset, $data['max']
                             )
                         );
 $data['num'] = Db::$num_rows;
-Theme::theme('header');
+Theme::theme('header',$data);
 Theme::theme('index', $data);
 Theme::footer();
 
diff --git a/inc/lib/Control/Frontend/page.control.php b/inc/lib/Control/Frontend/page.control.php
index efa5431d..70628ab2 100644
--- a/inc/lib/Control/Frontend/page.control.php
+++ b/inc/lib/Control/Frontend/page.control.php
@@ -18,6 +18,7 @@
     case 'sitemap':
         # code...
         Sitemap::create();
+        exit;
         break;
     
     default:
@@ -25,20 +26,22 @@
         $page = $_GET['page'];
         $data['posts'] = Db::result(
                             sprintf("SELECT * FROM `posts` 
-                                    WHERE `id` = '%d' 
+                                    WHERE (`id` = '%d' OR `slug` = '%s')
                                     AND `type` = 'page'
-                                    OR `slug` = '%s' 
+                                    AND `status` = '1'
                                     LIMIT 1", 
                                     $page, 
-                                    $page
+                                    Typo::cleanX($page)
                                     )
                             );
         if(Db::$num_rows > 0) {
-            Theme::theme('header');
+            Theme::theme('header',$data);
             Theme::theme('page', $data);
             Theme::footer();
+            exit;
         }else{
             Control::error('404');
+            exit;
         }
         break;
 }
diff --git a/inc/lib/Control/Frontend/post.control.php b/inc/lib/Control/Frontend/post.control.php
index 1277cf4d..b474f7d4 100644
--- a/inc/lib/Control/Frontend/post.control.php
+++ b/inc/lib/Control/Frontend/post.control.php
@@ -17,17 +17,22 @@
 $post = $_GET[$vars];
 $data['posts'] = Db::result(
                     sprintf("SELECT * FROM `posts` 
-                            WHERE `id` = '%d' AND `type` = 'post' LIMIT 1",
+                            WHERE `id` = '%d' 
+                            AND `type` = 'post'
+                            AND `status` = '1' 
+                            LIMIT 1",
                             $post
                             )
                 );
 
 if(Db::$num_rows > 0) {
-    Theme::theme('header');
+    Theme::theme('header',$data);
     Theme::theme('single', $data);
     Theme::footer();
+    exit;
 }else{
     Control::error('404');
+    exit;
 }
 
 
diff --git a/inc/lib/Control/Install/default.control.php b/inc/lib/Control/Install/default.control.php
index 94af95f7..7dca8bcd 100644
--- a/inc/lib/Control/Install/default.control.php
+++ b/inc/lib/Control/Install/default.control.php
@@ -95,6 +95,7 @@ class=\"btn btn-danger\">Back Button</a>.";
                 <br>
                 After You had set the permission, please refresh this page. 
                 <br>
+                <br>
                 or <a href=\"?step=4\" class=\"btn btn-primary\">Click Here</a>";
             }
         }catch (exception $e) {
diff --git a/inc/lib/Db.class.php b/inc/lib/Db.class.php
index e00cbb48..a7b27057 100644
--- a/inc/lib/Db.class.php
+++ b/inc/lib/Db.class.php
@@ -48,8 +48,19 @@ public function __construct () {
             mysql_connect(DB_HOST, DB_USER, DB_PASS);
             mysql_select_db(DB_NAME);
         }elseif(DB_DRIVER == 'mysqli') {
-            self::$mysqli = new mysqli(DB_HOST, DB_USER, DB_PASS, DB_NAME);
-            return self::$mysqli;
+            try {
+                self::$mysqli = new mysqli(DB_HOST, DB_USER, DB_PASS, DB_NAME);
+                if (self::$mysqli->connect_error) {
+                    Control::error('db', self::$mysqli->connect_error);
+                    exit;
+                }else{
+                    return true;
+                }
+            } catch (exception $e) {
+                Control::error('db', $e->getMessage() );
+            }
+            
+            //return self::$mysqli;
         }
     }
 
@@ -93,8 +104,7 @@ public static function query ($vars) {
         elseif(DB_DRIVER == 'mysqli') {
             $q = self::$mysqli->query($vars) ;
             if($q === false) {
-                user_error("Query failed: ".self::$mysqli->error."<br />\n$vars"); 
-                return false; 
+                Control::error('db',"Query failed: ".self::$mysqli->error."<br />\n"); 
             }
         }
         
@@ -265,7 +275,8 @@ public static function insert ($vars) {
         }elseif(DB_DRIVER == 'mysqli'){
             try {
                 if(!self::query($sql)){
-                    printf("<div class=\"alert alert-danger\">Errormessage: %s</div>\n", self::$mysqli->error);
+                    // printf("<div class=\"alert alert-danger\">Errormessage: %s</div>\n", self::$mysqli->error);
+                    //Control::error('db',self::$mysqli->error);
                 }else{
                     self::$last_id = self::$mysqli->insert_id;
                 }
diff --git a/inc/lib/GxMain.class.php b/inc/lib/GxMain.class.php
index a76f2c47..0312d618 100644
--- a/inc/lib/GxMain.class.php
+++ b/inc/lib/GxMain.class.php
@@ -38,6 +38,8 @@ public function __construct() {
         if (System::existConf()) {
             new System();
             new Db();
+            new Site();
+            Token::create();
         }else{
             $this->install();
         }
diff --git a/inc/lib/Install.class.php b/inc/lib/Install.class.php
index 1ca5f841..0882c859 100644
--- a/inc/lib/Install.class.php
+++ b/inc/lib/Install.class.php
@@ -52,7 +52,7 @@ public static function makeConfig ($file) {
 * @copyright 2014-2015 Puguh Wijayanto
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 *
-*/
+*/error_reporting(0);
 
 // DB CONFIG
 define('DB_HOST', '".Session::val('dbhost')."');
@@ -66,6 +66,15 @@ public static function makeConfig ($file) {
 define('GX_LANG', 'english');
 define('SMART_URL', false); //set 'true' if you want use SMART URL (SEO Friendly URL)
 define('GX_URL_PREFIX', '.html');
+
+
+
+
+
+
+
+
+// DON't REMOVE or EDIT THIS.
 define('SECURITY', '".Typo::getToken(200)."'); // for security purpose, will be used for creating password
 
         ";
@@ -191,7 +200,7 @@ public static function createTable () {
         $user_detail = "CREATE TABLE IF NOT EXISTS `user_detail` (
                 `id` bigint(20) NOT NULL,
                   `userid` varchar(32) COLLATE latin1_general_ci NOT NULL,
-                  `fname` varchar(32) COLLATE latin1_general_ci NOT NULL,
+                  `fname` varchar(32) COLLATE latin1_general_ci NULL,
                   `lname` varchar(255) COLLATE latin1_general_ci DEFAULT NULL,
                   `sex` varchar(2) COLLATE latin1_general_ci DEFAULT NULL,
                   `birthplace` varchar(32) COLLATE latin1_general_ci DEFAULT NULL,
@@ -272,7 +281,8 @@ public static function insertData () {
             (null, 'ppsandbox', 'off'),
             (null, 'ppuser', ''),
             (null, 'pppass', ''),
-            (null, 'ppsign', '')";
+            (null, 'ppsign', ''),
+            (null, 'tokens', '')";
         $db->query($options);
     }
 }
\ No newline at end of file
diff --git a/inc/lib/Mail.class.php b/inc/lib/Mail.class.php
index e20359ec..b08088c1 100644
--- a/inc/lib/Mail.class.php
+++ b/inc/lib/Mail.class.php
@@ -27,7 +27,7 @@ class Mail
     static $siteemail   = "";
     static $sitename    = "";
     
-    function __construct()
+    public function __construct()
     {
         # code...
         self::$smtphost    = Options::get('smtphost');
diff --git a/inc/lib/Menus.class.php b/inc/lib/Menus.class.php
index 3ab23e08..c8ee3722 100644
--- a/inc/lib/Menus.class.php
+++ b/inc/lib/Menus.class.php
@@ -1,36 +1,68 @@
 <?php if(!defined('GX_LIB')) die("Direct Access Not Allowed!");
-/*
-*    GeniXCMS - Content Management System
-*    ============================================================
-*    Build          : 20140925
-*    Version        : 0.0.1 pre
-*    Developed By   : Puguh Wijayanto (www.metalgenix.com)
-*    License        : MIT License
-*    ------------------------------------------------------------
-* filename : Menus.class.php
-* version : 0.0.1 pre
-* build : 20141007
+/**
+* GeniXCMS - Content Management System
+* 
+* PHP Based Content Management System and Framework
+*
+* @package GeniXCMS
+* @since 0.0.1 build date 20141007
+* @version 0.0.1
+* @link https://github.com/semplon/GeniXCMS
+* @author Puguh Wijayanto (www.metalgenix.com)
+* @copyright 2014-2015 Puguh Wijayanto
+* @license http://www.opensource.org/licenses/mit-license.php MIT
+*
+*/
+
+/**
+* Menus Class.
+* This class is for managing the menu at the dasboard. 
+*
+* @author Puguh Wijayanto (www.metalgenix.com)
+* @since 0.0.1
 */
 class Menus
 {
-
+    /**
+    * Menus Constructor.
+    * Nothing to construct
+    * @since 0.0.1
+    *
+    */
     public function __construct(){
-
     }
 
-    public static function getParent($parent='', $menuid = ''){
+
+    /**
+    * isHadParent Function
+    * 
+    * This function is to get the list of parent in certain conditions. There are 
+    * two paramaters to be inserted. 
+    * @param int $parent
+    * @param string $menuid
+    * 
+    * @author Puguh Wijayanto (www.metalgenix.com)
+    * @since 0.0.1
+    */
+    public static function isHadParent($parent='', $menuid = ''){
         if(isset($menuid)){
             $where = " AND `menuid` = '{$menuid}'";
         }else{
             $where = '';
         }
-        $sql = sprintf("SELECT * FROM `menus` WHERE `parent` = '%s' %s", $parent, $where);
+        if(isset($parent)){
+            $parent = " `parent` = '{$parent}'";
+        }else{
+            $parent = '1';
+        }
+        $sql = sprintf("SELECT * FROM `menus` WHERE %s %s", $parent, $where);
         $menu = Db::result($sql);
         return $menu;
     }
 
-    public static function isHadSub($parent, $menuid =''){
-        $sql = sprintf("SELECT * FROM `menus` WHERE `parent` = '%s' %s", $parent, $where);
+    public static function getParent($id){
+        $q = self::getId($id);
+        return $q[0]->parent;
     }
 
 
@@ -50,7 +82,7 @@ public static function getMenu($menuid, $class='', $bsnav=false){
             foreach ($menus as $m) {
                 # code...
                 if($m->parent == ''){
-                    $parent = self::getParent($m->id, $menuid);
+                    $parent = self::isHadParent($m->id, $menuid);
                     $n = Db::$num_rows;
                     if($n > 0 && $bsnav) { 
                         $class = "class=\"dropdown\"";
@@ -70,7 +102,7 @@ public static function getMenu($menuid, $class='', $bsnav=false){
                         $menu .= "<ul class=\"submenu {$class}\" role=\"dropdown\">";
                             foreach ($menus as $m2) {
                                 if($m2->parent == $m->id){
-                                    $parent = self::getParent($m2->id, $menuid);
+                                    $parent = self::isHadParent($m2->id, $menuid);
                                     $n = Db::$num_rows;
                                     if($n > 0 && $bsnav) { 
                                         $class = "class=\"dropdown\"";
@@ -88,7 +120,7 @@ public static function getMenu($menuid, $class='', $bsnav=false){
                                             $menu .= "<ul class=\"submenu {$class}\">";
                                             foreach ($menus as $m3) {
                                                 if($m3->parent == $m2->id){
-                                                    $parent = self::getParent($m3->id, $menuid);
+                                                    $parent = self::isHadParent($m3->id, $menuid);
                                                     $n = Db::$num_rows;
                                                     if($n > 0 && $bsnav) { 
                                                         $class = "class=\"dropdown\"";
@@ -107,7 +139,7 @@ public static function getMenu($menuid, $class='', $bsnav=false){
                                                             $menu .= "<ul class=\"submenu {$class}\">";
                                                             foreach ($menus as $m4) {
                                                                 if($m4->parent == $m3->id){
-                                                                    $parent = self::getParent($m4->id, $menuid);
+                                                                    $parent = self::isHadParent($m4->id, $menuid);
                                                                     $n = Db::$num_rows;
                                                                     if($n > 0 && $bsnav) { 
                                                                         $class = "class=\"dropdown\"";
@@ -167,10 +199,10 @@ public static function getMenuAdmin($menuid, $class=''){
                     $menu .= "<li clas=\"form-inline\"><div class=\"row\">";
                     $menu .= "
                             <h4 class=\"col-md-10\">".$m->name." 
-                                <a href=\"index.php?page=menus&act=edit&id={$menuid}&itemid={$m->id}\" class=\"label label-primary pull-right\" >
+                                <a href=\"index.php?page=menus&act=edit&id={$menuid}&itemid={$m->id}&token=".TOKEN."\" class=\"label label-primary pull-right\" >
                                     <span class=\"glyphicon glyphicon-edit\"></span>
                                 </a>
-                                <a href=\"index.php?page=menus&act=del&id={$menuid}&itemid={$m->id}\" class=\"label label-danger pull-right\" >
+                                <a href=\"index.php?page=menus&act=del&id={$menuid}&itemid={$m->id}&token=".TOKEN."\" class=\"label label-danger pull-right\" >
                                     <span class=\"glyphicon glyphicon-remove\"></span>
                                 </a>
                             </h4>
@@ -183,7 +215,7 @@ public static function getMenuAdmin($menuid, $class=''){
                     
                     $parent = $m->id;
                     //echo $parent;
-                    $parent = self::getParent($m->id, $menuid);
+                    $parent = self::isHadParent($m->id, $menuid);
                     $n = Db::$num_rows;
                     if($n > 0){
                         $menu .= "<ul class=\"submenu {$class}\">";
@@ -191,10 +223,10 @@ public static function getMenuAdmin($menuid, $class=''){
                                 if($m2->parent == $m->id){
                                     $menu .= "<li><div class=\"row\">";
                                     $menu .= "<h5 class=\"col-md-10\">".$m2->name."
-                                                <a href=\"index.php?page=menus&act=edit&id={$menuid}&itemid={$m2->id}\" class=\"label label-primary pull-right\" >
+                                                <a href=\"index.php?page=menus&act=edit&id={$menuid}&itemid={$m2->id}&token=".TOKEN."\" class=\"label label-primary pull-right\" >
                                                     <span class=\"glyphicon glyphicon-edit\"></span>
                                                 </a>
-                                                <a href=\"index.php?page=menus&act=del&id={$menuid}&itemid={$m2->id}\" class=\"label label-danger pull-right\" >
+                                                <a href=\"index.php?page=menus&act=del&id={$menuid}&itemid={$m2->id}&token=".TOKEN."\" class=\"label label-danger pull-right\" >
                                                     <span class=\"glyphicon glyphicon-remove\"></span>
                                                 </a>
 
@@ -207,7 +239,7 @@ public static function getMenuAdmin($menuid, $class=''){
                                         </div>
                                         
                                                 ";
-                                        $parent = self::getParent($m2->id, $menuid);
+                                        $parent = self::isHadParent($m2->id, $menuid);
                                         $n = Db::$num_rows;
                                         if($n > 0){
                                             $menu .= "<ul class=\"submenu {$class}\">";
@@ -215,10 +247,10 @@ public static function getMenuAdmin($menuid, $class=''){
                                                 if($m3->parent == $m2->id){
                                                     $menu .= "<li><div class=\"row\">";
                                                     $menu .= "<h6 class=\"col-md-10\">".$m3->name."
-                                                                <a href=\"index.php?page=menus&act=edit&id={$menuid}&itemid={$m3->id}\" class=\"label label-primary pull-right\" >
+                                                                <a href=\"index.php?page=menus&act=edit&id={$menuid}&itemid={$m3->id}&token=".TOKEN."\" class=\"label label-primary pull-right\" >
                                                                     <span class=\"glyphicon glyphicon-edit\"></span>
                                                                 </a>
-                                                                <a href=\"index.php?page=menus&act=del&id={$menuid}&itemid={$m3->id}\" class=\"label label-danger pull-right\" >
+                                                                <a href=\"index.php?page=menus&act=del&id={$menuid}&itemid={$m3->id}&token=".TOKEN."\" class=\"label label-danger pull-right\" >
                                                                     <span class=\"glyphicon glyphicon-remove\"></span>
                                                                 </a>
                                                             </h6>";
@@ -228,7 +260,7 @@ public static function getMenuAdmin($menuid, $class=''){
                                                             </div>
                                                         </div>
                                                                 ";
-                                                        $parent = self::getParent($m3->id, $menuid);
+                                                        $parent = self::isHadParent($m3->id, $menuid);
                                                         $n = Db::$num_rows;
                                                         if($n > 0){
                                                             $menu .= "<ul class=\"submenu {$class}\">";
@@ -236,10 +268,10 @@ public static function getMenuAdmin($menuid, $class=''){
                                                                 if($m4->parent == $m3->id){
                                                                     $menu .= "<li><div class=\"row\">";
                                                                     $menu .= "<h6 class=\"col-md-10\">".$m4->name."
-                                                                                <a href=\"index.php?page=menus&act=edit&id={$menuid}&itemid={$m4->id}\" class=\"label label-primary pull-right\" >
+                                                                                <a href=\"index.php?page=menus&act=edit&id={$menuid}&itemid={$m4->id}&token=".TOKEN."\" class=\"label label-primary pull-right\" >
                                                                                     <span class=\"glyphicon glyphicon-edit\"></span>
                                                                                 </a>
-                                                                                <a href=\"index.php?page=menus&act=del&id={$menuid}&itemid={$m4->id}\" class=\"label label-primary pull-right\" >
+                                                                                <a href=\"index.php?page=menus&act=del&id={$menuid}&itemid={$m4->id}&token=".TOKEN."\" class=\"label label-primary pull-right\" >
                                                                                     <span class=\"glyphicon glyphicon-remove\"></span>
                                                                                 </a>
                                                                             </h6>";
@@ -299,7 +331,7 @@ public static function getMenuRaw($menuid){
 
     public static function getId($id=''){
         if(isset($id)){
-            $sql = sprintf("SELECT * FROM `menus` WHERE `id` = '%d' ORDER BY `order` ASC", $id);
+            $sql = sprintf("SELECT * FROM `menus` WHERE `id` = '%d'", $id);
             $menus = Db::result($sql);
             $n = Db::$num_rows;
         }else{
diff --git a/inc/lib/Options.class.php b/inc/lib/Options.class.php
index 073cd93a..a6a426c9 100644
--- a/inc/lib/Options.class.php
+++ b/inc/lib/Options.class.php
@@ -22,26 +22,21 @@ public function __construct() {
     }
 
     // $vars = array(
-    //             'title' => '',
-    //             'cat' => '',
-    //             'content' => '',
-    //             'date' => '',
-    //             'author' => '',
-    //             'type' => '',
-    //             'status' => ''
+    //             'name' => '',
+    //             'value' => ''
     //         );
     public static function insert($vars) {
         if(is_array($vars)) {
-            $slug = Typo::slugify($vars['title']);
-            $vars = array_merge($vars, array('slug' => $slug));
-            //print_r($vars);
             $ins = array(
                         'table' => 'options',
-                        'key' => $vars
+                        'name' => $vars['name'],
+                        'value' => $vars['value']
                     );
-            $post = Db::insert($ins);
+            $opt = Db::insert($ins);
+        }else{
+            Control::error('unknown','Format not Found, please in array');
         }
-        return $post;
+        return $opt;
     }
 
     public static function update($key, $val = '') {
diff --git a/inc/lib/Posts.class.php b/inc/lib/Posts.class.php
index 92a69287..3b9ddb16 100644
--- a/inc/lib/Posts.class.php
+++ b/inc/lib/Posts.class.php
@@ -121,7 +121,7 @@ public static function content($vars) {
     }
 
     public static function recent($vars, $type = 'post') {
-        $sql = "SELECT * FROM `posts` WHERE `type` = '{$type}' ORDER BY `date` DESC LIMIT {$vars}";
+        $sql = "SELECT * FROM `posts` WHERE `type` = '{$type}' AND `status` = '1' ORDER BY `date` DESC LIMIT {$vars}";
         $posts = Db::result($sql);
         if(isset($posts['error'])){
             $posts['error'] = "No Posts found.";
@@ -167,7 +167,7 @@ public static function dropdown($vars){
         if(is_array($vars)){
             //print_r($vars);
             $name = $vars['name'];
-            $where = "WHERE ";
+            $where = "WHERE `status` = '1' AND ";
             if(isset($vars['type'])) {
                 $where .= " `type` = '{$vars['type']}' AND ";
             }else{
diff --git a/inc/lib/Rss.class.php b/inc/lib/Rss.class.php
index d34addec..205a30b3 100644
--- a/inc/lib/Rss.class.php
+++ b/inc/lib/Rss.class.php
@@ -27,9 +27,9 @@ public static function create ($url = 'post', $type='post', $count='20') {
         $xml .= "
             <rss version=\"2.0\">
                 <channel>
-                    <title>".Options::get('sitename')."</title>
-                    <link>".Options::get('siteurl')."</link>
-                    <description>".Options::get('sitedesc')."</description>
+                    <title>".Site::$name."</title>
+                    <link>".Site::$url."</link>
+                    <description>".Site::$desc."</description>
             ";
         foreach ($posts as $p) {
             # code...
diff --git a/inc/lib/Site.class.php b/inc/lib/Site.class.php
index 36124b16..b294db83 100644
--- a/inc/lib/Site.class.php
+++ b/inc/lib/Site.class.php
@@ -19,11 +19,21 @@ class Site
 {
     static $editors;
     static $data;
+    static $url;
+    static $domain;
+    static $name;
+    static $key;
+    static $desc;
 
     public function __construct() {
         global $GLOBALS, $data;
         self::$editors =& $GLOBALS;
         self::$data =& $data;
+        self::$url = Options::get('siteurl');
+        self::$domain = Options::get('sitedomain');
+        self::$name = Options::get('sitename');
+        self::$key = Options::get('sitekeywords');
+        self::$desc = Options::get('sitedesc');
     }
 
     /* Call all Website Meta at Header
@@ -36,7 +46,7 @@ public static function meta($cont_title='', $cont_desc='', $pre =''){
 
         if(is_array($data) && isset($data['posts'][0]->title)){
             
-            $sitenamelength = strlen(Options::get('sitename'));
+            $sitenamelength = strlen(self::$name);
             $limit = 70-$sitenamelength-6;
             $cont_title = substr(Typo::Xclean(Typo::strip($data['posts'][0]->title)),0,$limit);
             $titlelength = strlen($data['posts'][0]->title);
@@ -54,8 +64,8 @@ public static function meta($cont_title='', $cont_desc='', $pre =''){
         $meta = "
     <!--// Start Meta: Generated Automaticaly by GeniXCMS -->
     <!-- SEO: Title stripped 70chars for SEO Purpose -->
-    <title>{$cont_title}".Options::get('sitename')."</title>
-    <meta name=\"Keyword\" content=\"".Options::get('sitekeywords')."\">
+    <title>{$cont_title}".self::$name."</title>
+    <meta name=\"Keyword\" content=\"".self::$key."\">
     <!-- SEO: Description stripped 150chars for SEO Purpose -->
     <meta name=\"Description\" content=\"".self::desc($desc)."\">
     <meta name=\"Author\" content=\"Puguh Wijayanto | MetalGenix IT Solutions - www.metalgenix.com\">
@@ -77,7 +87,7 @@ public static function footer(){
         $bs = Options::get('use_bootstrap');
         if($bs == 'on'){
             $foot .= "
-    <link href=\"".Options::get('siteurl')."/assets/css/bootstrap.min.css\" rel=\"stylesheet\">\n";
+    <link href=\"".self::$url."/assets/css/bootstrap.min.css\" rel=\"stylesheet\">\n";
         }
 
         $jquery = Options::get('use_jquery');
@@ -91,8 +101,8 @@ public static function footer(){
         if($bs == 'on'){
             $foot .= "
             <!-- These files are included by default by GeniXCMS. You can set it at the dashboard -->
-            \t<script src=\"".Options::get('siteurl')."/assets/js/bootstrap.min.js\"></script>
-            \t<script src=\"".Options::get('siteurl')."/assets/js/ie10-viewport-bug-workaround.js\"></script>";
+            \t<script src=\"".self::$url."/assets/js/bootstrap.min.js\"></script>
+            \t<script src=\"".self::$url."/assets/js/ie10-viewport-bug-workaround.js\"></script>";
         }
 
         $fa = Options::get('use_fontawesome');
@@ -111,11 +121,11 @@ public static function footer(){
             \t<script src=\"http://cdnjs.cloudflare.com/ajax/libs/codemirror/3.20.0/mode/xml/xml.min.js\"></script>
             \t<script src=\"http://cdnjs.cloudflare.com/ajax/libs/codemirror/2.36.0/formatting.min.js\"></script>
 
-            \t<link href=\"".Options::get('siteurl')."/assets/css/summernote.css\" rel=\"stylesheet\">
-            \t<script src=\"".Options::get('siteurl')."/assets/js/summernote.min.js\"></script>
-            \t<script src=\"".Options::get('siteurl')."/assets/js/plugins/summernote-ext-fontstyle.js\"></script>
-            \t<script src=\"".Options::get('siteurl')."/assets/js/plugins/summernote-ext-hello.js\"></script>
-            \t<script src=\"".Options::get('siteurl')."/assets/js/plugins/summernote-ext-video.js\"></script>
+            \t<link href=\"".self::$url."/assets/css/summernote.css\" rel=\"stylesheet\">
+            \t<script src=\"".self::$url."/assets/js/summernote.min.js\"></script>
+            \t<script src=\"".self::$url."/assets/js/plugins/summernote-ext-fontstyle.js\"></script>
+            \t<script src=\"".self::$url."/assets/js/plugins/summernote-ext-hello.js\"></script>
+            \t<script src=\"".self::$url."/assets/js/plugins/summernote-ext-video.js\"></script>
             \t<script>
               \t$(document).ready(function() {
                 \t$('.editor').summernote({
@@ -168,8 +178,8 @@ public static function footer(){
 
         if(isset($GLOBALS['validator']) && $GLOBALS['validator'] == true){
             $foot .= "
-            \t<link href=\"".Options::get('siteurl')."/assets/css/bootstrapValidator.min.css\" rel=\"stylesheet\">
-            \t<script src=\"".Options::get('siteurl')."/assets/js/bootstrapValidator.min.js\"></script>
+            \t<link href=\"".self::$url."/assets/css/bootstrapValidator.min.css\" rel=\"stylesheet\">
+            \t<script src=\"".self::$url."/assets/js/bootstrapValidator.min.js\"></script>
             ";
 
             $foot .= $GLOBALS['validator_js'];
@@ -182,9 +192,9 @@ public static function footer(){
 
     public static function desc($vars){
         if(!empty($vars)){
-            $desc = substr(strip_tags(htmlspecialchars_decode($vars).". ".Options::get('sitedesc')),0,150);
+            $desc = substr(strip_tags(htmlspecialchars_decode($vars).". ".self::$desc),0,150);
         }else{
-            $desc = substr(Options::get('sitedesc'),0,150);
+            $desc = substr(self::$desc,0,150);
         }
         
         return $desc;
@@ -193,10 +203,10 @@ public static function desc($vars){
     public static function logo ($width='', $height='') {
         // check which logo is used, logourl or uploaded files.
         if( Options::get('is_logourl') == "on" && Options::get('logourl') != "" ) {
-            $logo = "<img src=\"".Options::get('siteurl').Options::get('logourl')."\"
+            $logo = "<img src=\"".self::$url.Options::get('logourl')."\"
                     style=\"width: $width; height: $height; margin: 1px;\">";
         }elseif( Options::get('is_logourl') == "off" && Options::get('logo') != "" ){
-            $logo = "<img src=\"".Options::get('siteurl').Options::get('logo')."\"
+            $logo = "<img src=\"".self::$url.Options::get('logo')."\"
                     style=\"width: $width; height: $height; margin: 1px;\">";
         }else{
             $logo = "<span class=\"mg genixcms-logo\"></span>";
diff --git a/inc/lib/System.class.php b/inc/lib/System.class.php
index 135ccd9d..a853c205 100644
--- a/inc/lib/System.class.php
+++ b/inc/lib/System.class.php
@@ -17,21 +17,42 @@
 
 class System
 {
-
+    /** 
+    * GeniXCMS Version Variable 
+    * @return double
+    */
     static $version          = "0.0.1";
+
+    /** 
+    * GeniXCMS Version Release 
+    * @return string
+    */
     static $v_release        = "";
 
+    /**
+    * System Constructor.
+    * Initializing the system, check the config file, if exist run the config
+    * loader. 
+    * @author Puguh Wijayanto (www.metalgenix.com)
+    * @since 0.0.1
+    */
     public function __construct () {
         if (self::existConf()) {
             # code...
             self::config('config');
-            self::lang(GX_LANG);
+            self::lang(GX_LANG);            
         }else{
             GxMain::install();
         }
         
     }
 
+    /**
+    * System Library Loader.
+    * This will include library which is called.
+    * @author Puguh Wijayanto (www.metalgenix.com)
+    * @since 0.0.1
+    */
     public static function lib($var) {
         include(GX_LIB.$var.'.class.php');
     }
@@ -109,4 +130,4 @@ public static function v () {
 }
 
 /* End of file system.class.php */
-/* Location: ./inc/lib/system.class.php */
\ No newline at end of file
+/* Location: ./inc/lib/system.class.php */
diff --git a/inc/lib/Token.class.php b/inc/lib/Token.class.php
new file mode 100644
index 00000000..ae155b78
--- /dev/null
+++ b/inc/lib/Token.class.php
@@ -0,0 +1,119 @@
+<?php
+/**
+* GeniXCMS - Content Management System
+* 
+* PHP Based Content Management System and Framework
+*
+* @package GeniXCMS
+* @since 0.0.2 build date 20150309
+* @version 0.0.2
+* @link https://github.com/semplon/GeniXCMS
+* @author Puguh Wijayanto (www.metalgenix.com)
+* @copyright 2014-2015 Puguh Wijayanto
+* @license http://www.opensource.org/licenses/mit-license.php MIT
+*
+*/
+
+
+/**
+* Token Class
+*
+* @author Puguh Wijayanto (www.metalgenix.com)
+* @since 0.0.2
+*/
+class Token
+{
+    public function __construct () {
+
+    }
+
+    public static function create() {
+        self::ridOld();
+        $length = "80";
+        $token = "";
+        $codeAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        $codeAlphabet.= "abcdefghijklmnopqrstuvwxyz";
+        $codeAlphabet.= "0123456789";
+        $codeAlphabet.= SECURITY;
+        for($i=0;$i<$length;$i++){
+            $token .= $codeAlphabet[Typo::crypto_rand_secure(0,strlen($codeAlphabet))];
+        }
+        $url = $_SERVER['REQUEST_URI'];
+        $url = htmlspecialchars($url, ENT_QUOTES, 'UTF-8');
+        $ip = $_SERVER['REMOTE_ADDR'];
+        $time = time();
+        define('TOKEN', $token);
+        define('TOKEN_URL', $url);
+        define('TOKEN_IP', $ip);
+        define('TOKEN_TIME', $time);
+        $json = self::json();
+        Options::update('tokens',$json);
+        return $token;
+    }
+
+    /**
+    * Json Token Function
+    *
+    * $token = [{'time','ip','url',token'},]
+    */
+    public static function json() {
+        $token = Options::get('tokens');
+        $token = json_decode($token, true);
+        $newtoken = array(
+                        TOKEN => array(
+                            'time' => TOKEN_TIME,
+                            'ip' => TOKEN_IP,
+                            'url' => TOKEN_URL
+                            )
+                    );
+        if(is_array($token)){
+            $newtoken = array_merge($token, $newtoken);
+        }
+
+        $newtoken = json_encode($newtoken);
+        return $newtoken;
+    }
+
+    public static function isExist($token){
+        $json = Options::get('tokens');
+        $tokens = json_decode($json, true);
+        if(array_key_exists($token, $tokens)){
+            $call = true;
+        }else{
+            $call = false;
+        }
+        return $call;
+    }
+
+    public static function remove($token){
+        $json = Options::get('tokens');
+        $tokens = json_decode($json, true);
+        unset($tokens[$token]);
+        $tokens = json_encode($tokens);
+        if(Options::update('tokens',$tokens)){
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    public static function ridOld() {
+        $json = Options::get('tokens');
+        $tokens = json_decode($json, true);
+        $time = time();
+        foreach ($tokens as $token => $value) {
+            # code...
+            //print_r($token);
+            if ($time - $value['time'] > 600) {
+                # code...
+                unset($tokens[$token]);
+            }
+        }
+        $tokens = json_encode($tokens);
+        if(Options::update('tokens',$tokens)){
+            return true;
+        }else{
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/inc/lib/Upload.class.php b/inc/lib/Upload.class.php
index aa6c7c4c..cfa5ba3d 100644
--- a/inc/lib/Upload.class.php
+++ b/inc/lib/Upload.class.php
@@ -69,7 +69,7 @@ public static function go($input, $path, $allowed='', $uniq=false, $size='', $wi
                     $result['filename'] = $uniqfile.$filename;
                     $result['path'] = $path.$uniqfile.$filename;
                     $result['filepath'] = $filepath;
-                    $result['fileurl'] = Options::get('siteurl').$path.$uniqfile.$filename;
+                    $result['fileurl'] = Site::$url.$path.$uniqfile.$filename;
 
                 }else{
                     $result['error'] = 'Cannot upload to directory, please check 
diff --git a/inc/lib/Url.class.php b/inc/lib/Url.class.php
index 386e3101..688d1e3b 100644
--- a/inc/lib/Url.class.php
+++ b/inc/lib/Url.class.php
@@ -41,12 +41,12 @@ public static function post($vars) {
         switch (SMART_URL) {
             case true:
                 # code...
-                $url = Options::get('siteurl')."/".self::slug($vars)."/{$vars}";
+                $url = Site::$url."/".self::slug($vars)."/{$vars}";
                 break;
             
             default:
                 # code...
-                $url = Options::get('siteurl')."/index.php?post={$vars}";
+                $url = Site::$url."/index.php?post={$vars}";
                 break;
 
         }
@@ -66,12 +66,12 @@ public static function page($vars) {
         switch (SMART_URL) {
             case true:
                 # code...
-                $url = Options::get('siteurl')."/".self::slug($vars).GX_URL_PREFIX;
+                $url = Site::$url."/".self::slug($vars).GX_URL_PREFIX;
                 break;
             
             default:
                 # code...
-                $url = Options::get('siteurl')."/index.php?page={$vars}";
+                $url = Site::$url."/index.php?page={$vars}";
                 break;
 
         }
@@ -92,12 +92,12 @@ public static function cat($vars) {
         switch (SMART_URL) {
             case true:
                 # code...
-                $url = Options::get('siteurl')."/".$vars."/".Typo::slugify(Categories::name($vars));
+                $url = Site::$url."/".$vars."/".Typo::slugify(Categories::name($vars));
                 break;
             
             default:
                 # code...
-                $url = Options::get('siteurl')."/index.php?cat={$vars}";
+                $url = Site::$url."/index.php?cat={$vars}";
                 break;
 
         }
@@ -129,12 +129,12 @@ public static function sitemap() {
         switch (SMART_URL) {
             case true:
                 # code...
-                $url = Options::get('siteurl')."/sitemap".GX_URL_PREFIX;
+                $url = Site::$url."/sitemap".GX_URL_PREFIX;
                 break;
             
             default:
                 # code...
-                $url = Options::get('siteurl')."/index.php?page=sitemap";
+                $url = Site::$url."/index.php?page=sitemap";
                 break;
 
         }
@@ -154,12 +154,12 @@ public static function rss() {
         switch (SMART_URL) {
             case true:
                 # code...
-                $url = Options::get('siteurl')."/rss".GX_URL_PREFIX;
+                $url = Site::$url."/rss".GX_URL_PREFIX;
                 break;
             
             default:
                 # code...
-                $url = Options::get('siteurl')."/index.php?rss";
+                $url = Site::$url."/index.php?rss";
                 break;
 
         }",
"url": "https://github.com/semplon/GeniXCMS/commit/698245488343396185b1b49e7482ee5b25541815.patch"
}
] |
n/a
|
|
CVE-2023-37266
|
Weak json web token (JWT) secrets in CasaOS
|
CasaOS is an open-source Personal Cloud system. Unauthenticated attackers can craft arbitrary JWTs and access features that usually require authentication and execute arbitrary commands as `root` on CasaOS instances. This problem was addressed by improving the validation of JWTs in commit `705bf1f`. This patch is part of CasaOS 0.4.4. Users should upgrade to CasaOS 0.4.4. If they can't, they should temporarily restrict access to CasaOS to untrusted users, for instance by not exposing it publicly.
|
[
{
"commit_message": "[PATCH] Update jwt (#1025) go.mod | 16 ++++++++-------- go.sum | 33 +++++++++++++++++---------------- route/v1.go | 8 +++++++- route/v2.go | 13 +++++++++---- 4 files changed, 41 insertions(+), 29 deletions(-)",
"patch_text_b64": "From 705bf1facbffd2ca40b159b0303132b6fdf657ad Mon Sep 17 00:00:00 2001
From: link <a624669980@163.com>
Date: Wed, 26 Apr 2023 16:00:43 +0800
Subject: [PATCH] Update jwt (#1025)

---
 go.mod      | 16 ++++++++--------
 go.sum      | 33 +++++++++++++++++----------------
 route/v1.go |  8 +++++++-
 route/v2.go | 13 +++++++++----
 4 files changed, 41 insertions(+), 29 deletions(-)

diff --git a/go.mod b/go.mod
index e3aeb117..62ca7b22 100644
--- a/go.mod
+++ b/go.mod
@@ -4,7 +4,7 @@ go 1.20
 
 require (
 	github.com/Curtis-Milo/nat-type-identifier-go v0.0.0-20220215191915-18d42168c63d
-	github.com/IceWhaleTech/CasaOS-Common v0.4.3
+	github.com/IceWhaleTech/CasaOS-Common v0.4.4-alpha4
 	github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf
 	github.com/deckarep/golang-set/v2 v2.3.0
 	github.com/deepmap/oapi-codegen v1.12.4
@@ -41,10 +41,10 @@ require (
 	github.com/tidwall/gjson v1.14.4
 	go.uber.org/goleak v1.2.1
 	go.uber.org/zap v1.24.0
-	golang.org/x/crypto v0.7.0
+	golang.org/x/crypto v0.8.0
 	golang.org/x/oauth2 v0.6.0
 	golang.org/x/sync v0.1.0
-	golang.org/x/sys v0.6.0
+	golang.org/x/sys v0.7.0
 	gorm.io/gorm v1.24.6
 	gotest.tools v2.2.0+incompatible
 )
@@ -87,12 +87,12 @@ require (
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
-	github.com/klauspost/compress v1.16.3 // indirect
+	github.com/klauspost/compress v1.16.5 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
 	github.com/klauspost/pgzip v1.2.5 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/labstack/gommon v0.4.0 // indirect
-	github.com/leodido/go-urn v1.2.2 // indirect
+	github.com/leodido/go-urn v1.2.3 // indirect
 	github.com/lufia/plan9stats v0.0.0-20230110061619-bbe2e5e100de // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
@@ -119,12 +119,12 @@ require (
 	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
 	github.com/yusufpapurcu/wmi v1.2.2 // indirect
 	go.uber.org/atomic v1.10.0 // indirect
-	go.uber.org/multierr v1.10.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
 	golang.org/x/arch v0.3.0 // indirect
 	golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 // indirect
 	golang.org/x/image v0.6.0 // indirect
-	golang.org/x/net v0.8.0 // indirect
-	golang.org/x/text v0.8.0 // indirect
+	golang.org/x/net v0.9.0 // indirect
+	golang.org/x/text v0.9.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
 	google.golang.org/protobuf v1.30.0 // indirect
diff --git a/go.sum b/go.sum
index 27f1f23c..99eccc58 100644
--- a/go.sum
+++ b/go.sum
@@ -1,7 +1,7 @@
 github.com/Curtis-Milo/nat-type-identifier-go v0.0.0-20220215191915-18d42168c63d h1:62lEBImTxZ83pgzywgDNIrPPuQ+j4ep9QjqrWBn1hrU=
 github.com/Curtis-Milo/nat-type-identifier-go v0.0.0-20220215191915-18d42168c63d/go.mod h1:lW9x+yEjqKdPbE3+cf2fGPJXCw/hChX3Omi9QHTLFsQ=
-github.com/IceWhaleTech/CasaOS-Common v0.4.3 h1:sYsWYhP5EyksH6D0BDv8secIRGAKUZZDTIKqACdFZQ4=
-github.com/IceWhaleTech/CasaOS-Common v0.4.3/go.mod h1:zLzM1RhoBRDdW7DFlEoPq18OhbJYsvc8yFodW0bm/QI=
+github.com/IceWhaleTech/CasaOS-Common v0.4.4-alpha4 h1:KIMQL8fumAczZEsd7uC7n2NUzBYUC4DntRc8usSxGq8=
+github.com/IceWhaleTech/CasaOS-Common v0.4.4-alpha4/go.mod h1:2IuYyy5qW1BE6jqC6M+tOU+WtUec1K565rLATBJ9p/0=
 github.com/RaveNoX/go-jsoncommentstrip v1.0.0/go.mod h1:78ihd09MekBnJnxpICcwzCMzGrKSKYe4AqU6PDYYpjk=
 github.com/andybalholm/brotli v1.0.1/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
 github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
@@ -169,8 +169,8 @@ github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHm
 github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE=
 github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
 github.com/klauspost/compress v1.11.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/klauspost/compress v1.16.3 h1:XuJt9zzcnaz6a16/OU53ZjWp/v7/42WcR5t2a0PcNQY=
-github.com/klauspost/compress v1.16.3/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/compress v1.16.5 h1:IFV2oUNUzZaz+XyusxpLzpzS8Pt5rh0Z16For/djlyI=
+github.com/klauspost/compress v1.16.5/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
@@ -191,8 +191,8 @@ github.com/labstack/echo/v4 v4.10.2/go.mod h1:OEyqf2//K1DFdE57vw2DRgWY0M7s65IVQO
 github.com/labstack/gommon v0.4.0 h1:y7cvthEAEbU0yHOf4axH8ZG2NH8knB9iNSoTO8dyIk8=
 github.com/labstack/gommon v0.4.0/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
 github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
-github.com/leodido/go-urn v1.2.2 h1:7z68G0FCGvDk646jz1AelTYNYWrTNm0bEcFAo147wt4=
-github.com/leodido/go-urn v1.2.2/go.mod h1:kUaIbLZWttglzwNuG0pgsh5vuV6u2YcGBYz1hIPjtOQ=
+github.com/leodido/go-urn v1.2.3 h1:6BE2vPT0lqoz3fmOesHZiaiFh7889ssCo2GMvLCfiuA=
+github.com/leodido/go-urn v1.2.3/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
 github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I=
 github.com/lufia/plan9stats v0.0.0-20230110061619-bbe2e5e100de h1:V53FWzU6KAZVi1tPp5UIsMoUWJ2/PNwYIDXnu7QuBCE=
 github.com/lufia/plan9stats v0.0.0-20230110061619-bbe2e5e100de/go.mod h1:JKx41uQRwqlTZabZc+kILPrO/3jlKnQ2Z8b7YiVw5cE=
@@ -254,7 +254,6 @@ github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTE
 github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
 github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
-github.com/rwtodd/Go.Sed v0.0.0-20210816025313-55464686f9ef/go.mod h1:8AEUvGVi2uQ5b24BIhcr0GCcpd/RNAFWaN2CJFrWIIQ=
 github.com/samber/lo v1.38.1 h1:j2XEAqXKb09Am4ebOg31SpvzUTTs6EN3VfgeLUhPdXM=
 github.com/samber/lo v1.38.1/go.mod h1:+m/ZKRl6ClXCE2Lgf3MsQlWfh4bn1bz6CXEOxnEXnEA=
 github.com/satori/go.uuid v1.2.0 h1:0uYX9dsZ2yD7q2RtLRtPSdGDWzjeM3TbMJP9utgA0ww=
@@ -312,8 +311,8 @@ go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ=
 go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A=
 go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4=
-go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
-go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 go.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60=
 go.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
@@ -324,8 +323,8 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.7.0 h1:AvwMYaRytfdeVt3u6mLaxYtErKYjxA2OXjJ1HHq6t3A=
-golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
+golang.org/x/crypto v0.8.0 h1:pd9TJtTueMTVQXzk8E2XESSMQDj/U7OUu0PqJqPXQjQ=
+golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
 golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 h1:3MTrJm4PyNL9NBqvYDSj3DHl46qQakyfqfWo4jgfaEM=
 golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
@@ -348,8 +347,8 @@ golang.org/x/net v0.0.0-20211029224645-99673261e6eb/go.mod h1:9nx3DQGgdP8bBQD5qx
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.0.0-20221002022538-bcab6841153b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
+golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
+golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.6.0 h1:Lh8GPgSKBfWSwFvtuWOfeI3aAAnbXTSutYxJiOJFgIw=
 golang.org/x/oauth2 v0.6.0/go.mod h1:ycmewcwgD4Rpr3eZJLSB4Kyyljb3qDh40vJ8STE5HKw=
@@ -382,20 +381,22 @@ golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220928140112-f11e5e49a4ec/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
+golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.6.0 h1:clScbb1cHjoCkyRbWwBEUZ5H/tIFu5TAXIqaZD0Gcjw=
+golang.org/x/term v0.7.0 h1:BEvjmm5fURWqcfbSKTdpkDXYBrUS1c0m8agp14W48vQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68=
 golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
 golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
diff --git a/route/v1.go b/route/v1.go
index da317eb4..98117604 100644
--- a/route/v1.go
+++ b/route/v1.go
@@ -1,8 +1,10 @@
 package route
 
 import (
+	"crypto/ecdsa"
 	"os"
 
+	"github.com/IceWhaleTech/CasaOS-Common/external"
 	"github.com/IceWhaleTech/CasaOS-Common/middleware"
 	"github.com/IceWhaleTech/CasaOS-Common/utils/jwt"
 	"github.com/IceWhaleTech/CasaOS/pkg/config"
@@ -39,7 +41,11 @@ func InitV1Router() *gin.Engine {
 	r.GET("/v1/recover/:type", v1.GetRecoverStorage)
 	v1Group := r.Group("/v1")
 
-	v1Group.Use(jwt.ExceptLocalhost())
+	v1Group.Use(jwt.JWT(
+		func() (*ecdsa.PublicKey, error) {
+			return external.GetPublicKey(config.CommonInfo.RuntimePath)
+		},
+	))
 	{
 
 		v1SysGroup := v1Group.Group("/sys")
diff --git a/route/v2.go b/route/v2.go
index 4c4a1fb5..d07e0629 100644
--- a/route/v2.go
+++ b/route/v2.go
@@ -1,6 +1,7 @@
 package route
 
 import (
+	"crypto/ecdsa"
 	"log"
 	"net/http"
 	"net/url"
@@ -10,9 +11,10 @@ import (
 	"strings"
 
 	"github.com/IceWhaleTech/CasaOS/codegen"
+	"github.com/IceWhaleTech/CasaOS/pkg/config"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
 
-	"github.com/IceWhaleTech/CasaOS-Common/utils/common_err"
+	"github.com/IceWhaleTech/CasaOS-Common/external"
 	"github.com/IceWhaleTech/CasaOS-Common/utils/jwt"
 	v2Route "github.com/IceWhaleTech/CasaOS/route/v2"
 	"github.com/deepmap/oapi-codegen/pkg/middleware"
@@ -74,11 +76,14 @@ func InitV2Router() http.Handler {
 			// return true
 		},
 		ParseTokenFunc: func(token string, c echo.Context) (interface{}, error) {
-			claims, code := jwt.Validate(token) // TODO - needs JWT validation
-			if code != common_err.SUCCESS {
+			// claims, code := jwt.Validate(token) // TODO - needs JWT validation
+			// if code != common_err.SUCCESS {
+			// 	return nil, echo.ErrUnauthorized
+			// }
+			valid, claims, err := jwt.Validate(token, func() (*ecdsa.PublicKey, error) { return external.GetPublicKey(config.CommonInfo.RuntimePath) })
+			if err != nil || !valid {
 				return nil, echo.ErrUnauthorized
 			}
-
 			c.Request().Header.Set("user_id", strconv.Itoa(claims.ID))
 
 			return claims, nil",
"url": "https://github.com/IceWhaleTech/CasaOS/commit/705bf1facbffd2ca40b159b0303132b6fdf657ad.patch"
}
] |
CWE-287: Improper Authentication
|
GHSA-674g-g96j-pr63
| null |
[
{
"commit_message": "[PATCH] Check for overflow in BER decoder EOC scanning doc/security.rst | 11 ++++++++++- src/lib/asn1/ber_dec.cpp | 5 ++++- src/lib/utils/info.txt | 3 ++- src/lib/utils/safeint.h | 39 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 55 insertions(+), 3 deletions(-) create mode 100644 src/lib/utils/safeint.h",
"patch_text_b64": "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",
"url": "https://github.com/randombit/botan/commit/987ad747db6d0d7e36f840398f3cf02e2fbfd90f.patch"
}
] | null |
|
GHSA-8v2m-x872-56fc
| null |
[
{
"commit_message": "[PATCH] Fixed potential security exploit. git-svn-id: https://plugins.svn.wordpress.org/secure-files/trunk@3641 b8457f37-d9ea-0310-8a92-e5e31aec5664 secure-files.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSBjYWIwMjVlNWZjMmJjZGFkODAzMmQ4MzNlYmMzOGU2YmQyYTEzYzkyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiB0cmV2b3J0dXJrIDx0cmV2b3J0dXJrQGI4NDU3ZjM3LWQ5ZWEtMDMxMC04YTkyLWU1ZTMxYWVjNTY2ND4KRGF0ZTogTW9uLCAzIE9jdCAyMDA1IDA1OjQwOjI5ICswMDAwClN1YmplY3Q6IFtQQVRDSF0gRml4ZWQgcG90ZW50aWFsIHNlY3VyaXR5IGV4cGxvaXQuCgpnaXQtc3ZuLWlkOiBodHRwczovL3BsdWdpbnMuc3ZuLndvcmRwcmVzcy5vcmcvc2VjdXJlLWZpbGVzL3RydW5rQDM2NDEgYjg0NTdmMzctZDllYS0wMzEwLThhOTItZTVlMzFhZWM1NjY0Ci0tLQogc2VjdXJlLWZpbGVzLnBocCB8IDQgKystLQogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zZWN1cmUtZmlsZXMucGhwIGIvc2VjdXJlLWZpbGVzLnBocAppbmRleCBjNTVmYzNiLi41Y2Y3YmZlIDEwMDc1NQotLS0gYS9zZWN1cmUtZmlsZXMucGhwCisrKyBiL3NlY3VyZS1maWxlcy5waHAKQEAgLTQsNyArNCw3IEBACiBQbHVnaW4gVVJJOiBodHRwOi8vd3d3LmFsbW9zdGVmZm9ydGxlc3MuY29tL3dvcmRwcmVzcy8KIERlc2NyaXB0aW9uOiBUaGlzIHBsdWdpbiBhbGxvd3MgeW91IHRvIHVwbG9hZCBhbmQgZG93bmxvYWQgZmlsZXMgZnJvbSBvdXRzaWRlIG9mIHlvdXIgd2ViIGRvY3VtZW50IHJvb3QgZm9yIHNlY3VyaXR5IHB1cnBvc2VzLiBXaGVuIHVzZWQgaW4gY29uanVuY3Rpb24gd2l0aCBhIHBsdWdpbiB0aGF0IHJlcXVpcmVzIGEgdXNlciB0byBiZSBsb2dnZWQgaW4gdG8gc2VlIHlvdXIgc2l0ZSwgeW91IGNhbiByZXN0cmljdCBmaWxlIGRvd25sb2FkcyB0byB1c2VycyB0aGF0IGFyZSBsb2dnZWQgaW4uIEl0IGNhbiBiZSBmb3VuZCBpbiBNYW5hZ2UgLT4gU2VjdXJlIEZpbGVzLgogQXV0aG9yOiBUcmV2b3IgVHVyawotVmVyc2lvbjogMS4xCitWZXJzaW9uOiAxLjIKIEF1dGhvciBVUkk6IGh0dHA6Ly93d3cuYWxtb3N0ZWZmb3J0bGVzcy5jb20vCiAqLyAKIApAQCAtNjcsNyArNjcsNyBAQCBmdW5jdGlvbiBzZl9kb3dubG9hZHMoKSB7CiAJCWlmIChpc3NldCgkX0dFVFsiJHNmX3ByZWZpeCJdKSkgewogCQkJJGRvd25sb2FkZmlsZSA9ICRfR0VUWyIkc2ZfcHJlZml4Il07CiAJCQkkc2ZfZGlyZWN0b3J5ID0gZ2V0X29wdGlvbignc2ZfZGlyZWN0b3J5Jyk7Ci0JCQkkZG93bmxvYWRmaWxlID0gJHNmX2RpcmVjdG9yeSAuICRkb3dubG9hZGZpbGU7CisJCQkkZG93bmxvYWRmaWxlID0gJHNmX2RpcmVjdG9yeSAuIGJhc2VuYW1lKCRkb3dubG9hZGZpbGUpOwogCQkJaWYgKGlzX2ZpbGUoJGRvd25sb2FkZmlsZSkpIHsKIAkJCQloZWFkZXIoJ0NvbnRlbnQtRGVzY3JpcHRpb246IEZpbGUgVHJhbnNmZXInKTsgCiAJCQkJaGVhZGVyKCdDb250ZW50LVR5cGU6IGFwcGxpY2F0aW9uL2ZvcmNlLWRvd25sb2FkJyk7",
"url": "https://github.com/wp-plugins/secure-files/commit/cab025e5fc2bcdad8032d833ebc38e6bd2a13c92.patch"
}
] | null |
|
GHSA-5w65-6875-rhq8
|
Undefined Behavior in sailsjs-cacheman
| null |
[
{
"commit_message": "[PATCH] Fix config variable exposing to global scope lib/sailsCacheman.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA0YTQ1NmY0NDE0MWFlMmQ1YWVkOGNiMzJhODIwNjMzNTZkY2MzMThmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBQYXZsbyBaaHVrb3YgPHBhaGFuMzVAdXNlcnMubm9yZXBseS5naXRodWIuY29tPgpEYXRlOiBXZWQsIDI4IE5vdiAyMDE4IDIzOjAyOjQwICswMjAwClN1YmplY3Q6IFtQQVRDSF0gRml4IGNvbmZpZyB2YXJpYWJsZSBleHBvc2luZyB0byBnbG9iYWwgc2NvcGUKCi0tLQogbGliL3NhaWxzQ2FjaGVtYW4uanMgfCAyICstCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9saWIvc2FpbHNDYWNoZW1hbi5qcyBiL2xpYi9zYWlsc0NhY2hlbWFuLmpzCmluZGV4IDk1MDVkNzkuLmJjNGE2YWIgMTAwNjQ0Ci0tLSBhL2xpYi9zYWlsc0NhY2hlbWFuLmpzCisrKyBiL2xpYi9zYWlsc0NhY2hlbWFuLmpzCkBAIC04LDcgKzgsNyBAQCB2YXIgQ2FjaGUgPSBmdW5jdGlvbiAobmFtZSkgewogICAgdmFyIF8gPSByZXF1aXJlKCd1bmRlcnNjb3JlJyk7CiAgICB2YXIgb3B0aW9ucyA9IHt9OwogICAgLy8gR2V0IGNvbmZpZ3VyYXRpb24KLSAgIGNvbmZpZyA9IHNhaWxzLmNvbmZpZy5jYWNoZW1hbjsKKyAgIHZhciBjb25maWcgPSBzYWlscy5jb25maWcuY2FjaGVtYW47CiAgICBpZiAoY29uZmlnID09PSB1bmRlZmluZWQpIHsKICAgICAgICAgdGhyb3cgbmV3IEVycm9yKCdObyBjb25maWd1cmF0aW9uIGZpbGUgZm91bmQuIFBsZWFzZSBhZGQgdGhlIGNvbmZpZ3VyYXRpb24gYXBwL2NvbmZpZy9jYWNoZW1hbi5qcycpOwogICAgfQ==",
"url": "https://github.com/gayanhewa/sailsjs-cacheman/commit/4a456f44141ae2d5aed8cb32a82063356dcc318f.patch"
}
] | null |
GHSA-f655-xhvm-cwp4
|
Cross-site Scripting in Jenkins GitLab Plugin
| null |
[
{
"commit_message": "[PATCH] [SECURITY-2316] .../gitlabjenkins/cause/GitLabWebHookCause/description.jelly | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSAyNGU5YTk5ZDgxNTFiNTM0NTEwOWVmMTJjZGRjMWFiMzIzYmFhNGVlIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5pZWwgQmVjayA8ZGFuaWVsLWJlY2tAdXNlcnMubm9yZXBseS5naXRodWIuY29tPgpEYXRlOiBXZWQsIDI5IEp1biAyMDIyIDE3OjE1OjE2ICswMjAwClN1YmplY3Q6IFtQQVRDSF0gW1NFQ1VSSVRZLTIzMTZdCgotLS0KIC4uLi9naXRsYWJqZW5raW5zL2NhdXNlL0dpdExhYldlYkhvb2tDYXVzZS9kZXNjcmlwdGlvbi5qZWxseSAgIHwgMyArKy0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9zcmMvbWFpbi9yZXNvdXJjZXMvY29tL2RhYnNxdWFyZWQvZ2l0bGFiamVua2lucy9jYXVzZS9HaXRMYWJXZWJIb29rQ2F1c2UvZGVzY3JpcHRpb24uamVsbHkgYi9zcmMvbWFpbi9yZXNvdXJjZXMvY29tL2RhYnNxdWFyZWQvZ2l0bGFiamVua2lucy9jYXVzZS9HaXRMYWJXZWJIb29rQ2F1c2UvZGVzY3JpcHRpb24uamVsbHkKaW5kZXggMzdlODVlZjM3Li4xYzAyNDRiMGQgMTAwNjQ0Ci0tLSBhL3NyYy9tYWluL3Jlc291cmNlcy9jb20vZGFic3F1YXJlZC9naXRsYWJqZW5raW5zL2NhdXNlL0dpdExhYldlYkhvb2tDYXVzZS9kZXNjcmlwdGlvbi5qZWxseQorKysgYi9zcmMvbWFpbi9yZXNvdXJjZXMvY29tL2RhYnNxdWFyZWQvZ2l0bGFiamVua2lucy9jYXVzZS9HaXRMYWJXZWJIb29rQ2F1c2UvZGVzY3JpcHRpb24uamVsbHkKQEAgLTEsNCArMSw1IEBACiA8P2plbGx5IGVzY2FwZS1ieS1kZWZhdWx0PSd0cnVlJz8+CiA8ajpqZWxseSB4bWxuczpqPSJqZWxseTpjb3JlIj4KLSAgPHNwYW4+PGo6b3V0IHZhbHVlPSIke2l0LnNob3J0RGVzY3JpcHRpb259IiAvPjwvc3Bhbj4KKyAgPCEtLSBTRUNVUklUWS0yMzE2OiBUaGlzIHVzZWQgdG8gc2hvdyB0aGUgSFRNTC1mb3JtYXR0ZWQgaXQuc2hvcnREZXNjcmlwdGlvbiwgYnV0IHRoYXQgZG9lcyBub3QgcHJvcGVybHkgbmV1dHJhbGl6ZSB1c2VyLXByb3ZpZGVkIGlucHV0IC0tPgorICA8c3Bhbj5UcmlnZ2VyZWQgYnkgR2l0TGFiIFdlYmhvb2s8L3NwYW4+CiA8L2o6amVsbHk+",
"url": "https://github.com/jenkinsci/gitlab-plugin/commit/24e9a99d8151b5345109ef12cddc1ab323baa4ee.patch"
}
] | null |
GHSA-48h7-cvhw-3w6x
| null |
[
{
"commit_message": "[PATCH] Bluetooth: L2CAP: Fix attempting to access uninitialized memory MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit On l2cap_parse_conf_req the variable efs is only initialized if remote_efs has been set. CVE: CVE-2022-42895 CC: stable@vger.kernel.org Reported-by: Tamás Koczka <poprdi@google.com> Signed-off-by: Luiz Augusto von Dentz <luiz.von.dentz@intel.com> Reviewed-by: Tedd Ho-Jeong An <tedd.an@intel.com> net/bluetooth/l2cap_core.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSBiMWEyY2Q1MGMwMzU3ZjI0M2I3NDM1YTczMmI0ZTYyYmEzMTU3YTJlIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBMdWl6IEF1Z3VzdG8gdm9uIERlbnR6IDxsdWl6LnZvbi5kZW50ekBpbnRlbC5jb20+CkRhdGU6IE1vbiwgMzEgT2N0IDIwMjIgMTY6MTA6NTIgLTA3MDAKU3ViamVjdDogW1BBVENIXSBCbHVldG9vdGg6IEwyQ0FQOiBGaXggYXR0ZW1wdGluZyB0byBhY2Nlc3MgdW5pbml0aWFsaXplZAogbWVtb3J5Ck1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CgpPbiBsMmNhcF9wYXJzZV9jb25mX3JlcSB0aGUgdmFyaWFibGUgZWZzIGlzIG9ubHkgaW5pdGlhbGl6ZWQgaWYKcmVtb3RlX2VmcyBoYXMgYmVlbiBzZXQuCgpDVkU6IENWRS0yMDIyLTQyODk1CkNDOiBzdGFibGVAdmdlci5rZXJuZWwub3JnClJlcG9ydGVkLWJ5OiBUYW3DoXMgS29jemthIDxwb3ByZGlAZ29vZ2xlLmNvbT4KU2lnbmVkLW9mZi1ieTogTHVpeiBBdWd1c3RvIHZvbiBEZW50eiA8bHVpei52b24uZGVudHpAaW50ZWwuY29tPgpSZXZpZXdlZC1ieTogVGVkZCBIby1KZW9uZyBBbiA8dGVkZC5hbkBpbnRlbC5jb20+Ci0tLQogbmV0L2JsdWV0b290aC9sMmNhcF9jb3JlLmMgfCAzICsrLQogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL25ldC9ibHVldG9vdGgvbDJjYXBfY29yZS5jIGIvbmV0L2JsdWV0b290aC9sMmNhcF9jb3JlLmMKaW5kZXggNGQ4YTFkODYyZjZiYjAuLjljMjQ5NDdhYTQxZWYwIDEwMDY0NAotLS0gYS9uZXQvYmx1ZXRvb3RoL2wyY2FwX2NvcmUuYworKysgYi9uZXQvYmx1ZXRvb3RoL2wyY2FwX2NvcmUuYwpAQCAtMzc2NCw3ICszNzY0LDggQEAgc3RhdGljIGludCBsMmNhcF9wYXJzZV9jb25mX3JlcShzdHJ1Y3QgbDJjYXBfY2hhbiAqY2hhbiwgdm9pZCAqZGF0YSwgc2l6ZV90IGRhdGEKIAkJCWwyY2FwX2FkZF9jb25mX29wdCgmcHRyLCBMMkNBUF9DT05GX1JGQywKIAkJCQkJICAgc2l6ZW9mKHJmYyksICh1bnNpZ25lZCBsb25nKSAmcmZjLCBlbmRwdHIgLSBwdHIpOwogCi0JCQlpZiAodGVzdF9iaXQoRkxBR19FRlNfRU5BQkxFLCAmY2hhbi0+ZmxhZ3MpKSB7CisJCQlpZiAocmVtb3RlX2VmcyAmJgorCQkJICAgIHRlc3RfYml0KEZMQUdfRUZTX0VOQUJMRSwgJmNoYW4tPmZsYWdzKSkgewogCQkJCWNoYW4tPnJlbW90ZV9pZCA9IGVmcy5pZDsKIAkJCQljaGFuLT5yZW1vdGVfc3R5cGUgPSBlZnMuc3R5cGU7CiAJCQkJY2hhbi0+cmVtb3RlX21zZHUgPSBsZTE2X3RvX2NwdShlZnMubXNkdSk7",
"url": "https://github.com/torvalds/linux/commit/b1a2cd50c0357f243b7435a732b4e62ba3157a2e.patch"
}
] | null |
|
CVE-2022-3234
|
Heap-based Buffer Overflow in vim/vim
|
Heap-based Buffer Overflow in GitHub repository vim/vim prior to 9.0.0483.
|
[
{
"commit_message": "[PATCH] patch 9.0.0483: illegal memory access when replacing in virtualedit mode Problem: Illegal memory access when replacing in virtualedit mode. Solution: Check for replacing NUL after Tab. src/ops.c | 12 ++++++++++-- src/testdir/test_virtualedit.vim | 14 ++++++++++++++ src/version.c | 2 ++ 3 files changed, 26 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSBjMjQ5OTEzZWRjMzVjMGU2NjZkNzgzYmZjMjE1OTVjZjlmN2Q5ZTBkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCcmFtIE1vb2xlbmFhciA8QnJhbUB2aW0ub3JnPgpEYXRlOiBGcmksIDE2IFNlcCAyMDIyIDIyOjE2OjU5ICswMTAwClN1YmplY3Q6IFtQQVRDSF0gcGF0Y2ggOS4wLjA0ODM6IGlsbGVnYWwgbWVtb3J5IGFjY2VzcyB3aGVuIHJlcGxhY2luZyBpbgogdmlydHVhbGVkaXQgbW9kZQoKUHJvYmxlbTogICAgSWxsZWdhbCBtZW1vcnkgYWNjZXNzIHdoZW4gcmVwbGFjaW5nIGluIHZpcnR1YWxlZGl0IG1vZGUuClNvbHV0aW9uOiAgIENoZWNrIGZvciByZXBsYWNpbmcgTlVMIGFmdGVyIFRhYi4KLS0tCiBzcmMvb3BzLmMgICAgICAgICAgICAgICAgICAgICAgICB8IDEyICsrKysrKysrKystLQogc3JjL3Rlc3RkaXIvdGVzdF92aXJ0dWFsZWRpdC52aW0gfCAxNCArKysrKysrKysrKysrKwogc3JjL3ZlcnNpb24uYyAgICAgICAgICAgICAgICAgICAgfCAgMiArKwogMyBmaWxlcyBjaGFuZ2VkLCAyNiBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9vcHMuYyBiL3NyYy9vcHMuYwppbmRleCA4OGQ4NWY4ZTBiMzEyNi4uOTlhNWQ1Y2RmZDRkN2UgMTAwNjQ0Ci0tLSBhL3NyYy9vcHMuYworKysgYi9zcmMvb3BzLmMKQEAgLTExNzMsNiArMTE3Myw4IEBAIG9wX3JlcGxhY2Uob3BhcmdfVCAqb2FwLCBpbnQgYykKIAogCXdoaWxlIChMVE9SRVFfUE9TKGN1cndpbi0+d19jdXJzb3IsIG9hcC0+ZW5kKSkKIAl7CisJICAgIGludCBkb25lID0gRkFMU0U7CisKIAkgICAgbiA9IGdjaGFyX2N1cnNvcigpOwogCSAgICBpZiAobiAhPSBOVUwpCiAJICAgIHsKQEAgLTExODYsNiArMTE4OCw3IEBAIG9wX3JlcGxhY2Uob3BhcmdfVCAqb2FwLCBpbnQgYykKIAkJICAgIGlmIChjdXJ3aW4tPndfY3Vyc29yLmxudW0gPT0gb2FwLT5lbmQubG51bSkKIAkJCW9hcC0+ZW5kLmNvbCArPSBuZXdfYnl0ZV9sZW4gLSBvbGRfYnl0ZV9sZW47CiAJCSAgICByZXBsYWNlX2NoYXJhY3RlcihjKTsKKwkJICAgIGRvbmUgPSBUUlVFOwogCQl9CiAJCWVsc2UKIAkJewpAQCAtMTIwNCwxMCArMTIwNywxNSBAQCBvcF9yZXBsYWNlKG9wYXJnX1QgKm9hcCwgaW50IGMpCiAJCQlpZiAoY3Vyd2luLT53X2N1cnNvci5sbnVtID09IG9hcC0+ZW5kLmxudW0pCiAJCQkgICAgZ2V0dnBvcygmb2FwLT5lbmQsIGVuZF92Y29sKTsKIAkJICAgIH0KLQkJICAgIFBCWVRFKGN1cndpbi0+d19jdXJzb3IsIGMpOworCQkgICAgLy8gd2l0aCAiY29sYWRkIiBzZXQgbWF5IG1vdmUgdG8ganVzdCBhZnRlciBhIFRBQgorCQkgICAgaWYgKGdjaGFyX2N1cnNvcigpICE9IE5VTCkKKwkJICAgIHsKKwkJCVBCWVRFKGN1cndpbi0+d19jdXJzb3IsIGMpOworCQkJZG9uZSA9IFRSVUU7CisJCSAgICB9CiAJCX0KIAkgICAgfQotCSAgICBlbHNlIGlmICh2aXJ0dWFsX29wICYmIGN1cndpbi0+d19jdXJzb3IubG51bSA9PSBvYXAtPmVuZC5sbnVtKQorCSAgICBpZiAoIWRvbmUgJiYgdmlydHVhbF9vcCAmJiBjdXJ3aW4tPndfY3Vyc29yLmxudW0gPT0gb2FwLT5lbmQubG51bSkKIAkgICAgewogCQlpbnQgdmlydGNvbHMgPSBvYXAtPmVuZC5jb2xhZGQ7CiAKZGlmZiAtLWdpdCBhL3NyYy90ZXN0ZGlyL3Rlc3RfdmlydHVhbGVkaXQudmltIGIvc3JjL3Rlc3RkaXIvdGVzdF92aXJ0dWFsZWRpdC52aW0KaW5kZXggOGZkNmQ5ODQ0NzBmNGQuLjhjYTgxYTc3N2QyNjIyIDEwMDY0NAotLS0gYS9zcmMvdGVzdGRpci90ZXN0X3ZpcnR1YWxlZGl0LnZpbQorKysgYi9zcmMvdGVzdGRpci90ZXN0X3ZpcnR1YWxlZGl0LnZpbQpAQCAtNTcyLDQgKzU3MiwxOCBAQCBmdW5jIFRlc3RfdmlydHVhbGVkaXRfbW91c2UoKQogICBzZXQgdmlydHVhbGVkaXQmCiBlbmRmdW5jCiAKKyIgdGhpcyB3YXMgcmVwbGFjaW5nIHRoZSBOVUwgYXQgdGhlIGVuZCBvZiB0aGUgbGluZSAKK2Z1bmMgVGVzdF92aXJ0dWFsZWRpdF9yZXBsYWNlX2FmdGVyX3RhYigpCisgIG5ldworICBzL1x2LwkwCisgIHNldCB2ZT1hbGwKKyAgbGV0IEAiID0gJycKKyAgc2lsISBub3JtIHZQdnIwCisgIAorICBjYWxsIGFzc2VydF9lcXVhbCgiXHQwIiwgZ2V0bGluZSgxKSkKKyAgc2V0IHZlJgorICBid2lwZSEKK2VuZGZ1bmMKKworCiAiIHZpbTogc2hpZnR3aWR0aD0yIHN0cz0yIGV4cGFuZHRhYgpkaWZmIC0tZ2l0IGEvc3JjL3ZlcnNpb24uYyBiL3NyYy92ZXJzaW9uLmMKaW5kZXggMTlmOWUwMGVjOTdkMjguLjhiNjM2N2FjOTM3MzAyIDEwMDY0NAotLS0gYS9zcmMvdmVyc2lvbi5jCisrKyBiL3NyYy92ZXJzaW9uLmMKQEAgLTcwMyw2ICs3MDMsOCBAQCBzdGF0aWMgY2hhciAqKGZlYXR1cmVzW10pID0KIAogc3RhdGljIGludCBpbmNsdWRlZF9wYXRjaGVzW10gPQogeyAgIC8qIEFkZCBuZXcgcGF0Y2ggbnVtYmVyIGJlbG93IHRoaXMgbGluZSAqLworLyoqLworICAgIDQ4MywKIC8qKi8KICAgICA0ODIsCiAvKiov",
"url": "https://github.com/vim/vim/commit/c249913edc35c0e666d783bfc21595cf9f7d9e0d.patch"
}
] |
CWE-122 Heap-based Buffer Overflow
|
GHSA-gwvm-45gx-3cf8
|
Authorization Header forwarded on redirect
| null |
[
{
"commit_message": "[PATCH] Remove Authorization headers regardless of case on cross-origin redirects (#1511) CHANGES.rst | 2 ++ CONTRIBUTORS.txt | 3 +++ src/urllib3/poolmanager.py | 7 +++++-- src/urllib3/util/retry.py | 3 ++- test/test_retry.py | 4 ++-- test/with_dummyserver/test_poolmanager.py | 25 +++++++++++++++++++++++ 6 files changed, 39 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/urllib3/urllib3/commit/adb358f8e06865406d1f05e581a16cbea2136fbc.patch"
}
] | null |
GHSA-cm22-4g7w-348p
|
serve-static vulnerable to template injection that can lead to XSS
| null |
[
{
"commit_message": "[PATCH] Merge commit from fork Co-authored-by: Chris de Almeida <ctcpip@users.noreply.github.com> index.js | 3 +-- test/test.js | 4 ++-- 2 files changed, 3 insertions(+), 4 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/expressjs/serve-static/commit/0c11fad159898cdc69fd9ab63269b72468ecaf6b.patch"
},
{
"commit_message": "[PATCH] Merge commit from fork Co-authored-by: Chris de Almeida <ctcpip@users.noreply.github.com> index.js | 3 +-- test/test.js | 4 ++-- 2 files changed, 3 insertions(+), 4 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/expressjs/serve-static/commit/ce730896fddce1588111d9ef6fdf20896de5c6fa.patch"
}
] | null |
GHSA-hv87-47h9-jcvq
|
Uncontrolled recursion in rust-yaml
| null |
[
{
"commit_message": "[PATCH] Prevent too deep recursion src/scanner.rs | 10 ++++++---- src/yaml.rs | 12 ++++++++++++ 2 files changed, 18 insertions(+), 4 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/chyh1990/yaml-rust/commit/d61b49cb90391fc4f7f72a1abe597476c8651a07.patch"
}
] | null |
CVE-2024-22193
|
vantage6 unencrypted task can be created in encrypted collaboration
|
The vantage6 technology enables to manage and deploy privacy enhancing technologies like Federated Learning (FL) and Multi-Party Computation (MPC). There are no checks on whether the input is encrypted if a task is created in an encrypted collaboration. Therefore, a user may accidentally create a task with sensitive input data that will then be stored unencrypted in a database. Users should ensure they set the encryption setting correctly. This vulnerability is patched in 4.2.0.
|
[
{
"commit_message": "[PATCH] Fix that tasks are not created if the input encryption status does not match the expectation of encryption in the collaboration .../vantage6/server/resource/task.py | 66 ++++++++++++++++++- 1 file changed, 63 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/vantage6/vantage6/commit/6383283733b81abfcacfec7538dc4dc882e98074.patch"
}
] |
CWE-922: Insecure Storage of Sensitive Information
|
GHSA-pm9p-9926-w68m
|
Denial of Service in ecstatic
| null |
[
{
"commit_message": "[PATCH] Remove stripping of null bytes This was at one point necessary because of an old bug in url.parse See: https://github.com/jfhbrook/node-ecstatic/issues/16#issuecomment-3039914 See: https://github.com/jfhbrook/node-ecstatic/commit/43f7e72a31524f88f47e367c3cc3af710e67c9f4 But this opens up a regex dos attack vector! D: Based on some research (ie asking #node-dev if this is still an issue), it's *probably* not an issue. :) lib/ecstatic.js | 12 ++++++++++++ 1 file changed, 12 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/jfhbrook/node-ecstatic/commit/71ce93988ead4b561a8592168c72143907189f01.patch"
},
{
"commit_message": "[PATCH] Remove stripping of null bytes This was at one point necessary because of an old bug in url.parse See: https://github.com/jfhbrook/node-ecstatic/issues/16#issuecomment-3039914 See: https://github.com/jfhbrook/node-ecstatic/commit/43f7e72a31524f88f47e367c3cc3af710e67c9f4 But this opens up a regex dos attack vector! D: Based on some research (ie asking #node-dev if this is still an issue), it's *probably* not an issue. :) lib/ecstatic.js | 12 ++++++++++++ 1 file changed, 12 insertions(+)",
"patch_text_b64": "RnJvbSA3MWNlOTM5ODhlYWQ0YjU2MWE4NTkyMTY4YzcyMTQzOTA3MTg5ZjAxIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBKb3NodWEgSG9sYnJvb2sgPGpvc2guaG9sYnJvb2tAZ21haWwuY29tPgpEYXRlOiBUdWUsIDkgQXVnIDIwMTYgMTI6Mzc6MzkgLTA0MDAKU3ViamVjdDogW1BBVENIXSBSZW1vdmUgc3RyaXBwaW5nIG9mIG51bGwgYnl0ZXMKClRoaXMgd2FzIGF0IG9uZSBwb2ludCBuZWNlc3NhcnkgYmVjYXVzZSBvZiBhbiBvbGQgYnVnIGluIHVybC5wYXJzZQoKU2VlOiBodHRwczovL2dpdGh1Yi5jb20vamZoYnJvb2svbm9kZS1lY3N0YXRpYy9pc3N1ZXMvMTYjaXNzdWVjb21tZW50LTMwMzk5MTQKU2VlOiBodHRwczovL2dpdGh1Yi5jb20vamZoYnJvb2svbm9kZS1lY3N0YXRpYy9jb21taXQvNDNmN2U3MmEzMTUyNGY4OGY0N2UzNjdjM2NjM2FmNzEwZTY3YzlmNAoKQnV0IHRoaXMgb3BlbnMgdXAgYSByZWdleCBkb3MgYXR0YWNrIHZlY3RvciEgRDoKCkJhc2VkIG9uIHNvbWUgcmVzZWFyY2ggKGllIGFza2luZyAjbm9kZS1kZXYgaWYgdGhpcyBpcyBzdGlsbCBhbiBpc3N1ZSksCml0J3MgKnByb2JhYmx5KiBub3QgYW4gaXNzdWUuIDopCi0tLQogbGliL2Vjc3RhdGljLmpzIHwgMTIgKysrKysrKysrKysrCiAxIGZpbGUgY2hhbmdlZCwgMTIgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2xpYi9lY3N0YXRpYy5qcyBiL2xpYi9lY3N0YXRpYy5qcwppbmRleCAxMTVkZTk5Li5lZmMzMzNlIDEwMDc1NQotLS0gYS9saWIvZWNzdGF0aWMuanMKKysrIGIvbGliL2Vjc3RhdGljLmpzCkBAIC01Miw5ICs1MiwyMSBAQCB2YXIgZWNzdGF0aWMgPSBtb2R1bGUuZXhwb3J0cyA9IGZ1bmN0aW9uIChkaXIsIG9wdGlvbnMpIHsKICAgcmV0dXJuIGZ1bmN0aW9uIG1pZGRsZXdhcmUgKHJlcSwgcmVzLCBuZXh0KSB7CiAKICAgICAvLyBTdHJpcCBhbnkgbnVsbCBieXRlcyBmcm9tIHRoZSB1cmwKKyAgICAvLyBUaGlzIHdhcyBhdCBvbmUgcG9pbnQgbmVjZXNzYXJ5IGJlY2F1c2Ugb2YgYW4gb2xkIGJ1ZyBpbiB1cmwucGFyc2UKKyAgICAvLworICAgIC8vIFNlZTogaHR0cHM6Ly9naXRodWIuY29tL2pmaGJyb29rL25vZGUtZWNzdGF0aWMvaXNzdWVzLzE2I2lzc3VlY29tbWVudC0zMDM5OTE0CisgICAgLy8gU2VlOiBodHRwczovL2dpdGh1Yi5jb20vamZoYnJvb2svbm9kZS1lY3N0YXRpYy9jb21taXQvNDNmN2U3MmEzMTUyNGY4OGY0N2UzNjdjM2NjM2FmNzEwZTY3YzlmNAorICAgIC8vCisgICAgLy8gQnV0IHRoaXMgb3BlbnMgdXAgYSByZWdleCBkb3MgYXR0YWNrIHZlY3RvciEgRDoKKyAgICAvLworICAgIC8vIEJhc2VkIG9uIHNvbWUgcmVzZWFyY2ggKGllIGFza2luZyAjbm9kZS1kZXYgaWYgdGhpcyBpcyBzdGlsbCBhbiBpc3N1ZSksCisgICAgLy8gaXQncyAqcHJvYmFibHkqIG5vdCBhbiBpc3N1ZS4gOikKKyAgICAvKgogICAgIHdoaWxlKHJlcS51cmwuaW5kZXhPZignJTAwJykgIT09IC0xKSB7CiAgICAgICByZXEudXJsID0gcmVxLnVybC5yZXBsYWNlKC9cJTAwL2csICcnKTsKICAgICB9CisgICAgKi8KKwogICAgIC8vIEZpZ3VyZSBvdXQgdGhlIHBhdGggZm9yIHRoZSBmaWxlIGZyb20gdGhlIGdpdmVuIHVybAogICAgIHZhciBwYXJzZWQgPSB1cmwucGFyc2UocmVxLnVybCk7CiAgICAgdHJ5IHs=",
"url": "https://github.com/jfhbrook/node-ecstatic/commit/71ce93988ead4b561a8592168c72143907189f01.patch"
}
] | null |
CVE-2016-7103
|
Cross-site scripting (XSS) vulnerability in jQuery UI before 1.12.0 might allow remote attackers to inject arbitrary web script or HTML via the closeText parameter of the dialog function.
|
[
{
"commit_message": "[PATCH] Dialog: Escape closeText option before passing it to button Ref gh-1632 Fixes jquery/api.jqueryui.com#281 tests/unit/dialog/options.js | 7 ++++++- ui/widgets/dialog.js | 4 ++-- 2 files changed, 8 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/jquery/jquery-ui/commit/9644e7bae9116edaf8d37c5b38cb32b892f10ff6.patch"
}
] |
n/a
|
|
GHSA-c86q-rj37-8f85
|
LibreNMS has a stored XSS in ExamplePlugin with Device's Notes
| null |
[
{
"commit_message": "[PATCH] Filter ExamplePlugin output (#16562) Filter device notes markdown output in ExamplePlugin Don't enable the ExamplePlugin, it does nothing... .../ExamplePlugin/resources/views/device-overview.blade.php | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)",
"patch_text_b64": "RnJvbSAyNGIxNDJkNzUzODk4ZTI3M2VjMjBiNTQyYTI3ZGQ2ZWI1MzBjN2Q4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb255IE11cnJheSA8bXVycmF5dG9ueUBnbWFpbC5jb20+CkRhdGU6IFdlZCwgMjMgT2N0IDIwMjQgMTU6MTA6MzAgLTA1MDAKU3ViamVjdDogW1BBVENIXSBGaWx0ZXIgRXhhbXBsZVBsdWdpbiBvdXRwdXQgKCMxNjU2MikKCkZpbHRlciBkZXZpY2Ugbm90ZXMgbWFya2Rvd24gb3V0cHV0IGluIEV4YW1wbGVQbHVnaW4KCkRvbid0IGVuYWJsZSB0aGUgRXhhbXBsZVBsdWdpbiwgaXQgZG9lcyBub3RoaW5nLi4uCi0tLQogLi4uL0V4YW1wbGVQbHVnaW4vcmVzb3VyY2VzL3ZpZXdzL2RldmljZS1vdmVydmlldy5ibGFkZS5waHAgICB8IDQgKy0tLQogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2FwcC9QbHVnaW5zL0V4YW1wbGVQbHVnaW4vcmVzb3VyY2VzL3ZpZXdzL2RldmljZS1vdmVydmlldy5ibGFkZS5waHAgYi9hcHAvUGx1Z2lucy9FeGFtcGxlUGx1Z2luL3Jlc291cmNlcy92aWV3cy9kZXZpY2Utb3ZlcnZpZXcuYmxhZGUucGhwCmluZGV4IDk3N2JlYzFkNGUzNy4uMmNhYzVjZjc1NzY4IDEwMDY0NAotLS0gYS9hcHAvUGx1Z2lucy9FeGFtcGxlUGx1Z2luL3Jlc291cmNlcy92aWV3cy9kZXZpY2Utb3ZlcnZpZXcuYmxhZGUucGhwCisrKyBiL2FwcC9QbHVnaW5zL0V4YW1wbGVQbHVnaW4vcmVzb3VyY2VzL3ZpZXdzL2RldmljZS1vdmVydmlldy5ibGFkZS5waHAKQEAgLTcsOSArNyw3IEBACiAgICAgICAgICAgICA8ZGl2IGNsYXNzPSJwYW5lbC1ib2R5Ij4KICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSJyb3ciPgogICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSJjb2wtc20tMTIiPgotICAgICAgICAgICAgICAgICAgICAgICAge3stLSBUaGlzIGlzIGEgY29tbWVudC4gIEJlbG93IHdlIG91dHB1dCB0aGUgbWFya2Rvd24gb3V0cHV0IHVuZXNjYXBlZCBiZWNhdXNlIHdlIHdhbnQgdGhlIHJhdyBodG1sCi0gICAgICAgICAgICAgICAgICAgICAgICAgdG8gYmUgb3V0cHV0IHRvIHRoZSBwYWdlLiAgQmUgY2FyZWZ1bCB3aXRoIHVuZXNjYXBlZCBvdXRwdXQgYXMgaXQgY2FuIGxlYWQgdG8gc2VjdXJpdHkgaXNzdWVzLiAtLX19Ci0gICAgICAgICAgICAgICAgICAgICAgICB7ISEgU3RyOjptYXJrZG93bigkZGV2aWNlLT5ub3RlcyA/PyAnJykgISF9CisgICAgICAgICAgICAgICAgICAgICAgICB7ISEgU3RyOjptYXJrZG93bigkZGV2aWNlLT5ub3RlcyA/PyAnJywgWydodG1sX2lucHV0JyA9PiAnc3RyaXAnLCAnYWxsb3dfdW5zYWZlX2xpbmtzJyA9PiBmYWxzZV0pICEhfQogICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgPC9kaXY+CiAgICAgICAgIDwvZGl2Pg==",
"url": "https://github.com/librenms/librenms/commit/24b142d753898e273ec20b542a27dd6eb530c7d8.patch"
}
] | null |
CVE-2016-8649
|
lxc-attach in LXC before 1.0.9 and 2.x before 2.0.6 allows an attacker inside of an unprivileged container to use an inherited file descriptor, of the host's /proc, to access the rest of the host's filesystem via the openat() family of syscalls.
|
[
{
"commit_message": "[PATCH] attach: do not send procfd to attached process So far, we opened a file descriptor refering to proc on the host inside the host namespace and handed that fd to the attached process in attach_child_main(). This was done to ensure that LSM labels were correctly setup. However, by exploiting a potential kernel bug, ptrace could be used to prevent the file descriptor from being closed which in turn could be used by an unprivileged container to gain access to the host namespace. Aside from this needing an upstream kernel fix, we should make sure that we don't pass the fd for proc itself to the attached process. However, we cannot completely prevent this, as the attached process needs to be able to change its apparmor profile by writing to /proc/self/attr/exec or /proc/self/attr/current. To minimize the attack surface, we only send the fd for /proc/self/attr/exec or /proc/self/attr/current to the attached process. To do this we introduce a little more IPC between the child and parent: * IPC mechanism: (X is receiver) * initial process intermediate attached * X <--- send pid of * attached proc, * then exit * send 0 ------------------------------------> X * [do initialization] * X <------------------------------------ send 1 * [add to cgroup, ...] * send 2 ------------------------------------> X *\t\t\t\t\t\t[set LXC_ATTACH_NO_NEW_PRIVS] * X <------------------------------------ send 3 * [open LSM label fd] * send 4 ------------------------------------> X * \t\t\t\t\t\t[set LSM label] * close socket close socket * run program The attached child tells the parent when it is ready to have its LSM labels set up. The parent then opens an approriate fd for the child PID to /proc/<pid>/attr/exec or /proc/<pid>/attr/current and sends it via SCM_RIGHTS to the child. The child can then set its LSM laben. Both sides then close the socket fds and the child execs the requested process. Signed-off-by: Christian Brauner <christian.brauner@canonical.com> src/lxc/attach.c | 184 ++++++++++++++++++++++++++++++++++------------- 1 file changed, 134 insertions(+), 50 deletions(-)",
"patch_text_b64": "From 81f466d05f2a89cb4f122ef7f593ff3f279b165c Mon Sep 17 00:00:00 2001
From: Christian Brauner <christian.brauner@canonical.com>
Date: Tue, 8 Nov 2016 19:21:19 +0100
Subject: [PATCH] attach: do not send procfd to attached process

So far, we opened a file descriptor refering to proc on the host inside the
host namespace and handed that fd to the attached process in
attach_child_main(). This was done to ensure that LSM labels were correctly
setup. However, by exploiting a potential kernel bug, ptrace could be used to
prevent the file descriptor from being closed which in turn could be used by an
unprivileged container to gain access to the host namespace. Aside from this
needing an upstream kernel fix, we should make sure that we don't pass the fd
for proc itself to the attached process. However, we cannot completely prevent
this, as the attached process needs to be able to change its apparmor profile
by writing to /proc/self/attr/exec or /proc/self/attr/current. To minimize the
attack surface, we only send the fd for /proc/self/attr/exec or
/proc/self/attr/current to the attached process. To do this we introduce a
little more IPC between the child and parent:

	 * IPC mechanism: (X is receiver)
	 *   initial process        intermediate          attached
	 *        X           <---  send pid of
	 *                          attached proc,
	 *                          then exit
	 *    send 0 ------------------------------------>    X
	 *                                              [do initialization]
	 *        X  <------------------------------------  send 1
	 *   [add to cgroup, ...]
	 *    send 2 ------------------------------------>    X
	 *						[set LXC_ATTACH_NO_NEW_PRIVS]
	 *        X  <------------------------------------  send 3
	 *   [open LSM label fd]
	 *    send 4 ------------------------------------>    X
	 *   						[set LSM label]
	 *   close socket                                 close socket
	 *                                                run program

The attached child tells the parent when it is ready to have its LSM labels set
up. The parent then opens an approriate fd for the child PID to
/proc/<pid>/attr/exec or /proc/<pid>/attr/current and sends it via SCM_RIGHTS
to the child. The child can then set its LSM laben. Both sides then close the
socket fds and the child execs the requested process.

Signed-off-by: Christian Brauner <christian.brauner@canonical.com>
---
 src/lxc/attach.c | 184 ++++++++++++++++++++++++++++++++++-------------
 1 file changed, 134 insertions(+), 50 deletions(-)

diff --git a/src/lxc/attach.c b/src/lxc/attach.c
index bfb2abf014..2f095b408f 100644
--- a/src/lxc/attach.c
+++ b/src/lxc/attach.c
@@ -53,6 +53,7 @@
 
 #include "namespace.h"
 #include "log.h"
+#include "af_unix.h"
 #include "attach.h"
 #include "caps.h"
 #include "config.h"
@@ -84,80 +85,103 @@
 
 lxc_log_define(lxc_attach, lxc);
 
-int lsm_set_label_at(int procfd, int on_exec, char* lsm_label) {
+static int lsm_openat(int procfd, pid_t pid, int on_exec)
+{
+	int ret = -1;
 	int labelfd = -1;
-	int ret = 0;
 	const char* name;
-	char* command = NULL;
+#define __LSMATTRLEN /* /proc */ (5 + /* /pid-to-str */ 21 + /* /current */ 7 + /* \0 */ 1)
+	char path[__LSMATTRLEN];
 
 	name = lsm_name();
 
 	if (strcmp(name, "nop") == 0)
-		goto out;
+		return 0;
 
 	if (strcmp(name, "none") == 0)
-		goto out;
+		return 0;
 
 	/* We don't support on-exec with AppArmor */
 	if (strcmp(name, "AppArmor") == 0)
 		on_exec = 0;
 
 	if (on_exec) {
-		labelfd = openat(procfd, "self/attr/exec", O_RDWR);
-	}
-	else {
-		labelfd = openat(procfd, "self/attr/current", O_RDWR);
+		ret = snprintf(path, __LSMATTRLEN, "%d/attr/exec", pid);
+		if (ret < 0 || ret >= __LSMATTRLEN)
+			return -1;
+		labelfd = openat(procfd, path, O_RDWR);
+	} else {
+		ret = snprintf(path, __LSMATTRLEN, "%d/attr/current", pid);
+		if (ret < 0 || ret >= __LSMATTRLEN)
+			return -1;
+		labelfd = openat(procfd, path, O_RDWR);
 	}
 
 	if (labelfd < 0) {
 		SYSERROR("Unable to open LSM label");
-		ret = -1;
-		goto out;
+		return -1;
 	}
 
+	return labelfd;
+}
+
+static int lsm_set_label_at(int lsm_labelfd, int on_exec, char *lsm_label)
+{
+	int fret = -1;
+	const char* name;
+	char *command = NULL;
+
+	name = lsm_name();
+
+	if (strcmp(name, "nop") == 0)
+		return 0;
+
+	if (strcmp(name, "none") == 0)
+		return 0;
+
+	/* We don't support on-exec with AppArmor */
+	if (strcmp(name, "AppArmor") == 0)
+		on_exec = 0;
+
 	if (strcmp(name, "AppArmor") == 0) {
 		int size;
 
 		command = malloc(strlen(lsm_label) + strlen("changeprofile ") + 1);
 		if (!command) {
 			SYSERROR("Failed to write apparmor profile");
-			ret = -1;
 			goto out;
 		}
 
 		size = sprintf(command, "changeprofile %s", lsm_label);
 		if (size < 0) {
 			SYSERROR("Failed to write apparmor profile");
-			ret = -1;
 			goto out;
 		}
 
-		if (write(labelfd, command, size + 1) < 0) {
-			SYSERROR("Unable to set LSM label");
-			ret = -1;
+		if (write(lsm_labelfd, command, size + 1) < 0) {
+			SYSERROR("Unable to set LSM label: %s.", command);
 			goto out;
 		}
-	}
-	else if (strcmp(name, "SELinux") == 0) {
-		if (write(labelfd, lsm_label, strlen(lsm_label) + 1) < 0) {
+		INFO("Set LSM label to: %s.", command);
+	} else if (strcmp(name, "SELinux") == 0) {
+		if (write(lsm_labelfd, lsm_label, strlen(lsm_label) + 1) < 0) {
 			SYSERROR("Unable to set LSM label");
-			ret = -1;
 			goto out;
 		}
-	}
-	else {
+		INFO("Set LSM label to: %s.", lsm_label);
+	} else {
 		ERROR("Unable to restore label for unknown LSM: %s", name);
-		ret = -1;
 		goto out;
 	}
+	fret = 0;
 
 out:
 	free(command);
 
-	if (labelfd != -1)
-		close(labelfd);
+	if (lsm_labelfd != -1)
+		close(lsm_labelfd);
 
-	return ret;
+	return fret;
 }
 
 static struct lxc_proc_context_info *lxc_proc_get_context_info(pid_t pid)
@@ -646,7 +670,6 @@ struct attach_clone_payload {
 	struct lxc_proc_context_info* init_ctx;
 	lxc_attach_exec_t exec_function;
 	void* exec_payload;
-	int procfd;
 };
 
 static int attach_child_main(void* data);
@@ -744,7 +767,6 @@ int lxc_attach(const char* name, const char* lxcpath, lxc_attach_exec_t exec_fun
 	char* cwd;
 	char* new_cwd;
 	int ipc_sockets[2];
-	int procfd;
 	signed long personality;
 
 	if (!options)
@@ -821,6 +843,11 @@ int lxc_attach(const char* name, const char* lxcpath, lxc_attach_exec_t exec_fun
 	 *        X  <------------------------------------  send 1
 	 *   [add to cgroup, ...]
 	 *    send 2 ------------------------------------>    X
+	 *						[set LXC_ATTACH_NO_NEW_PRIVS]
+	 *        X  <------------------------------------  send 3
+	 *   [open LSM label fd]
+	 *    send 4 ------------------------------------>    X
+	 *   						[set LSM label]
 	 *   close socket                                 close socket
 	 *                                                run program
 	 */
@@ -854,6 +881,7 @@ int lxc_attach(const char* name, const char* lxcpath, lxc_attach_exec_t exec_fun
 	}
 
 	if (pid) {
+		int procfd = -1;
 		pid_t to_cleanup_pid = pid;
 
 		/* initial thread, we close the socket that is for the
@@ -868,6 +896,15 @@ int lxc_attach(const char* name, const char* lxcpath, lxc_attach_exec_t exec_fun
 				goto cleanup_error;
 		}
 
+		/* Open /proc before setns() to the containers namespace so we
+		 * don't rely on any information from inside the container.
+		 */
+		procfd = open("/proc", O_DIRECTORY | O_RDONLY | O_CLOEXEC);
+		if (procfd < 0) {
+			SYSERROR("Unable to open /proc.");
+			goto cleanup_error;
+		}
+
 		/* Let the child process know to go ahead */
 		status = 0;
 		ret = lxc_write_nointr(ipc_sockets[0], &status, sizeof(status));
@@ -911,7 +948,8 @@ int lxc_attach(const char* name, const char* lxcpath, lxc_attach_exec_t exec_fun
 		ret = lxc_read_nointr_expect(ipc_sockets[0], &status, sizeof(status), &expected);
 		if (ret <= 0) {
 			if (ret != 0)
-				ERROR("error using IPC to receive notification from attached process (1)");
+				ERROR("error using IPC to receive notification "
+				      "from attached process (1)");
 			goto cleanup_error;
 		}
 
@@ -919,10 +957,40 @@ int lxc_attach(const char* name, const char* lxcpath, lxc_attach_exec_t exec_fun
 		status = 2;
 		ret = lxc_write_nointr(ipc_sockets[0], &status, sizeof(status));
 		if (ret <= 0) {
-			ERROR("error using IPC to notify attached process for initialization (2)");
+			ERROR("Error using IPC to notify attached process for "
+			      "initialization (2): %s.", strerror(errno));
 			goto cleanup_error;
 		}
 
+		/* Wait for the (grand)child to tell us that it's ready to set
+		 * up its LSM labels.
+		 */
+		expected = 3;
+		ret = lxc_read_nointr_expect(ipc_sockets[0], &status, sizeof(status), &expected);
+		if (ret <= 0) {
+			ERROR("Error using IPC for the child to tell us to open LSM fd (3): %s.",
+			      strerror(errno));
+			goto cleanup_error;
+		}
+
+		/* Open LSM fd and send it to child. */
+		if ((options->namespaces & CLONE_NEWNS) && (options->attach_flags & LXC_ATTACH_LSM) && init_ctx->lsm_label) {
+			int on_exec, labelfd;
+			on_exec = options->attach_flags & LXC_ATTACH_LSM_EXEC ? 1 : 0;
+			/* Open fd for the LSM security module. */
+			labelfd = lsm_openat(procfd, attached_pid, on_exec);
+			if (labelfd < 0)
+				goto cleanup_error;
+
+			/* Send child fd of the LSM security module to write to. */
+			ret = lxc_abstract_unix_send_fd(ipc_sockets[0], labelfd, NULL, 0);
+			if (ret <= 0) {
+				ERROR("Error using IPC to send child LSM fd (4): %s.",
+						strerror(errno));
+				goto cleanup_error;
+			}
+		}
+
 		/* now shut down communication with child, we're done */
 		shutdown(ipc_sockets[0], SHUT_RDWR);
 		close(ipc_sockets[0]);
@@ -940,6 +1008,8 @@ int lxc_attach(const char* name, const char* lxcpath, lxc_attach_exec_t exec_fun
 		/* first shut down the socket, then wait for the pid,
 		 * otherwise the pid we're waiting for may never exit
 		 */
+		if (procfd >= 0)
+			close(procfd);
 		shutdown(ipc_sockets[0], SHUT_RDWR);
 		close(ipc_sockets[0]);
 		if (to_cleanup_pid)
@@ -966,13 +1036,6 @@ int lxc_attach(const char* name, const char* lxcpath, lxc_attach_exec_t exec_fun
 	if ((options->attach_flags & LXC_ATTACH_MOVE_TO_CGROUP) && cgns_supported())
 		options->namespaces |= CLONE_NEWCGROUP;
 
-	procfd = open("/proc", O_DIRECTORY | O_RDONLY);
-	if (procfd < 0) {
-		SYSERROR("Unable to open /proc");
-		shutdown(ipc_sockets[1], SHUT_RDWR);
-		rexit(-1);
-	}
-
 	/* attach now, create another subprocess later, since pid namespaces
 	 * only really affect the children of the current process
 	 */
@@ -1001,7 +1064,6 @@ int lxc_attach(const char* name, const char* lxcpath, lxc_attach_exec_t exec_fun
 			.init_ctx = init_ctx,
 			.exec_function = exec_function,
 			.exec_payload = exec_payload,
-			.procfd = procfd
 		};
 		/* We use clone_parent here to make this subprocess a direct child of
 		 * the initial process. Then this intermediate process can exit and
@@ -1039,7 +1101,6 @@ static int attach_child_main(void* data)
 {
 	struct attach_clone_payload* payload = (struct attach_clone_payload*)data;
 	int ipc_socket = payload->ipc_socket;
-	int procfd = payload->procfd;
 	lxc_attach_options_t* options = payload->options;
 	struct lxc_proc_context_info* init_ctx = payload->init_ctx;
 #if HAVE_SYS_PERSONALITY_H
@@ -1050,6 +1111,7 @@ static int attach_child_main(void* data)
 	int expected;
 	long flags;
 	int fd;
+	int lsm_labelfd;
 	uid_t new_uid;
 	gid_t new_gid;
 
@@ -1060,7 +1122,7 @@ static int attach_child_main(void* data)
 	status = -1;
 	ret = lxc_read_nointr_expect(ipc_socket, &status, sizeof(status), &expected);
 	if (ret <= 0) {
-		ERROR("error using IPC to receive notification from initial process (0)");
+		ERROR("Error using IPC to receive notification from initial process (0): %s.", strerror(errno));
 		shutdown(ipc_socket, SHUT_RDWR);
 		rexit(-1);
 	}
@@ -1159,7 +1221,7 @@ static int attach_child_main(void* data)
 	status = 1;
 	ret = lxc_write_nointr(ipc_socket, &status, sizeof(status));
 	if (ret != sizeof(status)) {
-		ERROR("error using IPC to notify initial process for initialization (1)");
+		ERROR("Error using IPC to notify initial process for initialization (1): %s.", strerror(errno));
 		shutdown(ipc_socket, SHUT_RDWR);
 		rexit(-1);
 	}
@@ -1171,14 +1233,13 @@ static int attach_child_main(void* data)
 	status = -1;
 	ret = lxc_read_nointr_expect(ipc_socket, &status, sizeof(status), &expected);
 	if (ret <= 0) {
-		ERROR("error using IPC to receive final notification from initial process (2)");
+		ERROR("Error using IPC to receive message from initial process "
+		      "that it is done pre-initializing (2): %s",
+		      strerror(errno));
 		shutdown(ipc_socket, SHUT_RDWR);
 		rexit(-1);
 	}
 
-	shutdown(ipc_socket, SHUT_RDWR);
-	close(ipc_socket);
-
 	if ((init_ctx->container && init_ctx->container->lxc_conf &&
 	     init_ctx->container->lxc_conf->no_new_privs) ||
 	    (options->attach_flags & LXC_ATTACH_NO_NEW_PRIVS)) {
@@ -1186,27 +1247,53 @@ static int attach_child_main(void* data)
 			SYSERROR("PR_SET_NO_NEW_PRIVS could not be set. "
 				 "Process can use execve() gainable "
 				 "privileges.");
+			shutdown(ipc_socket, SHUT_RDWR);
 			rexit(-1);
 		}
 		INFO("PR_SET_NO_NEW_PRIVS is set. Process cannot use execve() "
 		     "gainable privileges.");
 	}
 
-	/* set new apparmor profile/selinux context */
+	/* Tell the (grand)parent to send us LSM label fd. */
+	status = 3;
+	ret = lxc_write_nointr(ipc_socket, &status, sizeof(status));
+	if (ret <= 0) {
+		ERROR("Error using IPC to tell parent to set up LSM labels (3): %s.", strerror(errno));
+		shutdown(ipc_socket, SHUT_RDWR);
+		rexit(-1);
+	}
+
 	if ((options->namespaces & CLONE_NEWNS) && (options->attach_flags & LXC_ATTACH_LSM) && init_ctx->lsm_label) {
 		int on_exec;
+		/* Receive fd for LSM security module. */
+		ret = lxc_abstract_unix_recv_fd(ipc_socket, &lsm_labelfd, NULL, 0);
+		if (ret <= 0) {
+			ERROR("Error using IPC for parent to tell us LSM label fd (4): %s.", strerror(errno));
+			shutdown(ipc_socket, SHUT_RDWR);
+			rexit(-1);
+		}
 
+		/* Change into our new LSM profile. */
 		on_exec = options->attach_flags & LXC_ATTACH_LSM_EXEC ? 1 : 0;
-		if (lsm_set_label_at(procfd, on_exec, init_ctx->lsm_label) < 0) {
+		if (lsm_set_label_at(lsm_labelfd, on_exec, init_ctx->lsm_label) < 0) {
+			SYSERROR("Failed to set LSM label.");
+			shutdown(ipc_socket, SHUT_RDWR);
+			close(lsm_labelfd);
 			rexit(-1);
 		}
+		close(lsm_labelfd);
 	}
+
 	if (init_ctx->container && init_ctx->container->lxc_conf &&
 	    init_ctx->container->lxc_conf->seccomp &&
 	    (lxc_seccomp_load(init_ctx->container->lxc_conf) != 0)) {
 		ERROR("Loading seccomp policy");
+		shutdown(ipc_socket, SHUT_RDWR);
 		rexit(-1);
 	}
+
+	shutdown(ipc_socket, SHUT_RDWR);
+	close(ipc_socket);
 	lxc_proc_put_context_info(init_ctx);
 
 	/* The following is done after the communication socket is
@@ -1245,9 +1332,6 @@ static int attach_child_main(void* data)
 				SYSERROR("Unable to clear CLOEXEC from fd");
 	}
 
-	/* we don't need proc anymore */
-	close(procfd);
-
 	/* we're done, so we can now do whatever the user intended us to do */
 	rexit(payload->exec_function(payload->exec_payload));
 }",
"url": "https://github.com/lxc/lxc/commit/81f466d05f2a89cb4f122ef7f593ff3f279b165c.patch"
}
] |
container bypass
|
|
CVE-2025-4754
|
Missing Session Revocation on Logout in ash_authentication_phoenix
|
Insufficient Session Expiration vulnerability in ash-project ash_authentication_phoenix allows Session Hijacking. This vulnerability is associated with program files lib/ash_authentication_phoenix/controller.ex.
This issue affects ash_authentication_phoenix until 2.10.0.
|
[
{
"commit_message": "[PATCH] improvement: revoke stored sessions on log out (#634) dev/dev_web/controllers/auth_controller.ex | 2 +- documentation/tutorials/get-started.md | 2 +- lib/ash_authentication_phoenix/controller.ex | 43 ++++++++++++++----- lib/ash_authentication_phoenix/plug.ex | 12 ++++++ .../ash_authentication_phoenix.install.ex | 7 +-- mix.exs | 2 +- mix.lock | 4 +- ...sh_authentication_phoenix.install_test.exs | 2 +- test/support/accounts/user.ex | 2 + test/support/auth_controller.ex | 2 +- 10 files changed, 57 insertions(+), 21 deletions(-)",
"patch_text_b64": "From a3253fb4fc7145aeb403537af1c24d3a8d51ffb1 Mon Sep 17 00:00:00 2001
From: Zach Daniel <zachary.s.daniel@gmail.com>
Date: Mon, 16 Jun 2025 20:17:42 -0400
Subject: [PATCH] improvement: revoke stored sessions on log out (#634)

---
 dev/dev_web/controllers/auth_controller.ex    |  2 +-
 documentation/tutorials/get-started.md        |  2 +-
 lib/ash_authentication_phoenix/controller.ex  | 43 ++++++++++++++-----
 lib/ash_authentication_phoenix/plug.ex        | 12 ++++++
 .../ash_authentication_phoenix.install.ex     |  7 +--
 mix.exs                                       |  2 +-
 mix.lock                                      |  4 +-
 ...sh_authentication_phoenix.install_test.exs |  2 +-
 test/support/accounts/user.ex                 |  2 +
 test/support/auth_controller.ex               |  2 +-
 10 files changed, 57 insertions(+), 21 deletions(-)

diff --git a/dev/dev_web/controllers/auth_controller.ex b/dev/dev_web/controllers/auth_controller.ex
index 3f70fa0a..77d18c69 100644
--- a/dev/dev_web/controllers/auth_controller.ex
+++ b/dev/dev_web/controllers/auth_controller.ex
@@ -26,7 +26,7 @@ defmodule DevWeb.AuthController do
   @impl true
   def sign_out(conn, _params) do
     conn
-    |> clear_session()
+    |> clear_session(:ash_authentication_phoenix)
     |> render("sign_out.html")
   end
 end
diff --git a/documentation/tutorials/get-started.md b/documentation/tutorials/get-started.md
index 46424a34..8d025777 100644
--- a/documentation/tutorials/get-started.md
+++ b/documentation/tutorials/get-started.md
@@ -116,7 +116,7 @@ defmodule ExampleWeb.AuthController do
     return_to = get_session(conn, :return_to) || ~p"/"
 
     conn
-    |> clear_session()
+    |> clear_session(:my_app)
     |> redirect(to: return_to)
   end
 end
diff --git a/lib/ash_authentication_phoenix/controller.ex b/lib/ash_authentication_phoenix/controller.ex
index 6da8126d..0a37462d 100644
--- a/lib/ash_authentication_phoenix/controller.ex
+++ b/lib/ash_authentication_phoenix/controller.ex
@@ -77,6 +77,7 @@ defmodule AshAuthentication.Phoenix.Controller do
   """
 
   alias AshAuthentication.Plug.Dispatcher
+  alias AshAuthentication.Plug.Helpers
   alias Plug.Conn
 
   @type t :: module
@@ -107,7 +108,7 @@ defmodule AshAuthentication.Phoenix.Controller do
       @behaviour AshAuthentication.Phoenix.Controller
       @behaviour AshAuthentication.Plug
       import Phoenix.Controller
-      import Plug.Conn
+      import Plug.Conn, except: [clear_session: 1]
       import AshAuthentication.Phoenix.Plug
       import AshAuthentication.Phoenix.Controller
 
@@ -137,15 +138,6 @@ defmodule AshAuthentication.Phoenix.Controller do
         |> render("failure.html")
       end
 
-      @doc false
-      @impl true
-      @spec sign_out(Conn.t(), map) :: Conn.t()
-      def sign_out(conn, _params) do
-        conn
-        |> clear_session()
-        |> render("sign_out.html")
-      end
-
       @doc false
       @impl true
       @spec call(Conn.t(), any) :: Conn.t()
@@ -203,7 +195,36 @@ defmodule AshAuthentication.Phoenix.Controller do
         end
       end
 
-      defoverridable success: 4, failure: 3, sign_out: 2
+      defoverridable success: 4, failure: 3
     end
   end
+
+  defmacro clear_session(_conn) do
+    raise """
+    Using clear_session/1 in your `auth_controller` is deprecated. Please use `clear_session/2` instead,
+    passing the conn and the otp_app.
+
+    For example:
+
+        conn
+        |> clear_session(conn, :my_app)
+
+
+    This ensures that session tokens & bearer tokens are revoked on logout.
+
+    If you wish to retain the old behavior (not advised), call `Plug.Conn.clear_session/1` directly.
+    """
+  end
+
+  @doc """
+  Clears the session and revokes bearer and session tokens.
+
+  This ensures that session tokens & bearer tokens are revoked on logout.
+  """
+  def clear_session(conn, otp_app) do
+    conn
+    |> Helpers.revoke_bearer_tokens(otp_app)
+    |> Helpers.revoke_session_tokens(otp_app)
+    |> Plug.Conn.clear_session()
+  end
 end
diff --git a/lib/ash_authentication_phoenix/plug.ex b/lib/ash_authentication_phoenix/plug.ex
index 69d9ef0e..7afd511b 100644
--- a/lib/ash_authentication_phoenix/plug.ex
+++ b/lib/ash_authentication_phoenix/plug.ex
@@ -49,6 +49,18 @@ defmodule AshAuthentication.Phoenix.Plug do
     Helpers.revoke_bearer_tokens(conn, otp_app)
   end
 
+  @doc """
+  Revoke all token(s) in the session.
+
+  A wrapper around `AshAuthentication.Plug.Helpers.revoke_session_tokens/2` with
+  the `otp_app` as extracted from the endpoint.
+  """
+  @spec revoke_session_tokens(Conn.t(), any) :: Conn.t()
+  def revoke_session_tokens(conn, _opts) do
+    otp_app = conn.private.phoenix_endpoint.config(:otp_app)
+    Helpers.revoke_session_tokens(conn, otp_app)
+  end
+
   @doc """
   Store the actor in the connections' session.
   """
diff --git a/lib/mix/tasks/ash_authentication_phoenix.install.ex b/lib/mix/tasks/ash_authentication_phoenix.install.ex
index 0c805631..d255fad4 100644
--- a/lib/mix/tasks/ash_authentication_phoenix.install.ex
+++ b/lib/mix/tasks/ash_authentication_phoenix.install.ex
@@ -98,6 +98,7 @@ if Code.ensure_loaded?(Igniter) do
       if router do
         web_module = Igniter.Libs.Phoenix.web_module(igniter)
         overrides = Igniter.Libs.Phoenix.web_module_name(igniter, "AuthOverrides")
+        otp_app = Igniter.Project.Application.app_name(igniter)
 
         igniter
         |> Igniter.Project.Formatter.import_dep(:ash_authentication_phoenix)
@@ -105,7 +106,7 @@ if Code.ensure_loaded?(Igniter) do
         |> setup_routes_alias()
         |> warn_on_missing_modules(options, argv, install?)
         |> do_or_explain_tailwind_changes()
-        |> create_auth_controller()
+        |> create_auth_controller(otp_app)
         |> create_overrides_module(overrides)
         |> add_auth_routes(overrides, options, router, web_module)
         |> create_live_user_auth(web_module)
@@ -318,7 +319,7 @@ if Code.ensure_loaded?(Igniter) do
       )
     end
 
-    defp create_auth_controller(igniter) do
+    defp create_auth_controller(igniter, otp_app) do
       Igniter.Project.Module.create_module(
         igniter,
         Igniter.Libs.Phoenix.web_module_name(igniter, "AuthController"),
@@ -372,7 +373,7 @@ if Code.ensure_loaded?(Igniter) do
           return_to = get_session(conn, :return_to) || ~p"/"
 
           conn
-          |> clear_session()
+          |> clear_session(:#{otp_app})
           |> put_flash(:info, "You are now signed out")
           |> redirect(to: return_to)
         end
diff --git a/mix.exs b/mix.exs
index 9eee0173..eb0e4f71 100644
--- a/mix.exs
+++ b/mix.exs
@@ -118,7 +118,7 @@ defmodule AshAuthentication.Phoenix.MixProject do
   # Run "mix help deps" to learn about dependencies.
   defp deps do
     [
-      {:ash_authentication, "~> 4.8"},
+      {:ash_authentication, "~> 4.9 and >= 4.9.1"},
       {:ash_phoenix, "~> 2.0"},
       {:ash, "~> 3.0"},
       {:jason, "~> 1.0"},
diff --git a/mix.lock b/mix.lock
index 7a2fb545..ca080b64 100644
--- a/mix.lock
+++ b/mix.lock
@@ -1,6 +1,6 @@
 %{
-  "ash": {:hex, :ash, "3.5.19", "defd1c6b94475352a7b69f430b792fb64e3a9f7ca030195737bb97dc0f1311b5", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ecto, "~> 3.7", [hex: :ecto, repo: "hexpm", optional: false]}, {:ets, "~> 0.8", [hex: :ets, repo: "hexpm", optional: false]}, {:igniter, ">= 0.6.4 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, ">= 1.0.0", [hex: :jason, repo: "hexpm", optional: false]}, {:picosat_elixir, "~> 0.2", [hex: :picosat_elixir, repo: "hexpm", optional: true]}, {:plug, ">= 0.0.0", [hex: :plug, repo: "hexpm", optional: true]}, {:reactor, "~> 0.11", [hex: :reactor, repo: "hexpm", optional: false]}, {:simple_sat, ">= 0.1.1 and < 1.0.0-0", [hex: :simple_sat, repo: "hexpm", optional: true]}, {:spark, ">= 2.2.65 and < 3.0.0-0", [hex: :spark, repo: "hexpm", optional: false]}, {:splode, ">= 0.2.6 and < 1.0.0-0", [hex: :splode, repo: "hexpm", optional: false]}, {:stream_data, "~> 1.0", [hex: :stream_data, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.1", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "ded976230b1ef823aeb25008cc62de6545bf3ad6208cf1f3badb598fa6c01375"},
-  "ash_authentication": {:hex, :ash_authentication, "4.9.0", "0286b5df6e5006d16811b18f0efcd691fa7895a0a3aa1b091986a61da31a2a8a", [:mix], [{:argon2_elixir, "~> 4.0", [hex: :argon2_elixir, repo: "hexpm", optional: true]}, {:ash, ">= 3.4.29 and < 4.0.0-0", [hex: :ash, repo: "hexpm", optional: false]}, {:ash_postgres, "~> 2.0", [hex: :ash_postgres, repo: "hexpm", optional: true]}, {:assent, "~> 0.2.13", [hex: :assent, repo: "hexpm", optional: false]}, {:bcrypt_elixir, "~> 3.0", [hex: :bcrypt_elixir, repo: "hexpm", optional: false]}, {:castore, "~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:finch, "~> 0.19", [hex: :finch, repo: "hexpm", optional: false]}, {:igniter, "~> 0.4", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}, {:joken, "~> 2.5", [hex: :joken, repo: "hexpm", optional: false]}, {:plug, "~> 1.13", [hex: :plug, repo: "hexpm", optional: false]}, {:spark, "~> 2.0", [hex: :spark, repo: "hexpm", optional: false]}, {:splode, "~> 0.2", [hex: :splode, repo: "hexpm", optional: false]}], "hexpm", "dde0c702b26e7354d81ea4a9bb334c27ce11a59876df8c5d4d5b0bebe4b7ad4e"},
+  "ash": {:hex, :ash, "3.5.21", "389303c193962d67fd59da18a3557f5015fdfdaeddaa77150db539bc7203d1a1", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ecto, "~> 3.7", [hex: :ecto, repo: "hexpm", optional: false]}, {:ets, "~> 0.8", [hex: :ets, repo: "hexpm", optional: false]}, {:igniter, ">= 0.6.4 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, ">= 1.0.0", [hex: :jason, repo: "hexpm", optional: false]}, {:picosat_elixir, "~> 0.2", [hex: :picosat_elixir, repo: "hexpm", optional: true]}, {:plug, ">= 0.0.0", [hex: :plug, repo: "hexpm", optional: true]}, {:reactor, "~> 0.11", [hex: :reactor, repo: "hexpm", optional: false]}, {:simple_sat, ">= 0.1.1 and < 1.0.0-0", [hex: :simple_sat, repo: "hexpm", optional: true]}, {:spark, ">= 2.2.65 and < 3.0.0-0", [hex: :spark, repo: "hexpm", optional: false]}, {:splode, ">= 0.2.6 and < 1.0.0-0", [hex: :splode, repo: "hexpm", optional: false]}, {:stream_data, "~> 1.0", [hex: :stream_data, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.1", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "cb90005d1972e22d0d2ae514394e43e0d67cce18c4485595aa3d3e4bbf25260f"},
+  "ash_authentication": {:hex, :ash_authentication, "4.9.1", "f5465abb973777ed7150c94f89902d0050d4debca1cf6ba8930e18e4de379a08", [:mix], [{:argon2_elixir, "~> 4.0", [hex: :argon2_elixir, repo: "hexpm", optional: true]}, {:ash, ">= 3.4.29 and < 4.0.0-0", [hex: :ash, repo: "hexpm", optional: false]}, {:ash_postgres, "~> 2.0", [hex: :ash_postgres, repo: "hexpm", optional: true]}, {:assent, "~> 0.2.13", [hex: :assent, repo: "hexpm", optional: false]}, {:bcrypt_elixir, "~> 3.0", [hex: :bcrypt_elixir, repo: "hexpm", optional: false]}, {:castore, "~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:finch, "~> 0.19", [hex: :finch, repo: "hexpm", optional: false]}, {:igniter, "~> 0.4", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}, {:joken, "~> 2.5", [hex: :joken, repo: "hexpm", optional: false]}, {:plug, "~> 1.13", [hex: :plug, repo: "hexpm", optional: false]}, {:spark, "~> 2.0", [hex: :spark, repo: "hexpm", optional: false]}, {:splode, "~> 0.2", [hex: :splode, repo: "hexpm", optional: false]}], "hexpm", "e5022a1d149c04fc529277a8174f0004b617d5530f080ce4e98a9452c5586970"},
   "ash_phoenix": {:hex, :ash_phoenix, "2.3.6", "c2bea1673af52f305b2fe0c04999bd1f0dc8e127d4757a3d7f42d0b9dea16a7a", [:mix], [{:ash, ">= 3.5.13 and < 4.0.0-0", [hex: :ash, repo: "hexpm", optional: false]}, {:igniter, "~> 0.6", [hex: :igniter, repo: "hexpm", optional: true]}, {:inertia, "~> 2.3", [hex: :inertia, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.5.6 or ~> 1.6", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.20.3 or ~> 1.0-rc.1", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:spark, ">= 2.2.29 and < 3.0.0-0", [hex: :spark, repo: "hexpm", optional: false]}], "hexpm", "6923dca70fe1d533864134999f4d9c5c59ef745a6b50982d42d60c18966474cd"},
   "assent": {:hex, :assent, "0.2.13", "11226365d2d8661d23e9a2cf94d3255e81054ff9d88ac877f28bfdf38fa4ef31", [:mix], [{:certifi, ">= 0.0.0", [hex: :certifi, repo: "hexpm", optional: true]}, {:finch, "~> 0.15", [hex: :finch, repo: "hexpm", optional: true]}, {:jose, "~> 1.8", [hex: :jose, repo: "hexpm", optional: true]}, {:mint, "~> 1.0", [hex: :mint, repo: "hexpm", optional: true]}, {:req, "~> 0.4", [hex: :req, repo: "hexpm", optional: true]}, {:ssl_verify_fun, ">= 0.0.0", [hex: :ssl_verify_fun, repo: "hexpm", optional: true]}], "hexpm", "bf9f351b01dd6bceea1d1f157f05438f6765ce606e6eb8d29296003d29bf6eab"},
   "bcrypt_elixir": {:hex, :bcrypt_elixir, "3.3.2", "d50091e3c9492d73e17fc1e1619a9b09d6a5ef99160eb4d736926fd475a16ca3", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "471be5151874ae7931911057d1467d908955f93554f7a6cd1b7d804cac8cef53"},
diff --git a/test/mix/tasks/ash_authentication_phoenix.install_test.exs b/test/mix/tasks/ash_authentication_phoenix.install_test.exs
index e501db95..454d4e00 100644
--- a/test/mix/tasks/ash_authentication_phoenix.install_test.exs
+++ b/test/mix/tasks/ash_authentication_phoenix.install_test.exs
@@ -142,7 +142,7 @@ defmodule Mix.Tasks.AshAuthenticationPhoenix.InstallTest do
         return_to = get_session(conn, :return_to) || ~p"/"
 
         conn
-        |> clear_session()
+        |> clear_session(:test)
         |> put_flash(:info, "You are now signed out")
         |> redirect(to: return_to)
       end
diff --git a/test/support/accounts/user.ex b/test/support/accounts/user.ex
index 4fbf603e..fbaee109 100644
--- a/test/support/accounts/user.ex
+++ b/test/support/accounts/user.ex
@@ -96,6 +96,8 @@ defmodule Example.Accounts.User do
   end
 
   authentication do
+    session_identifier(:jti)
+
     add_ons do
       confirmation :confirm do
         monitor_fields([:email])
diff --git a/test/support/auth_controller.ex b/test/support/auth_controller.ex
index 4b8dc2f0..a40e1d0c 100644
--- a/test/support/auth_controller.ex
+++ b/test/support/auth_controller.ex
@@ -26,7 +26,7 @@ defmodule AshAuthentication.Phoenix.Test.AuthController do
   @impl true
   def sign_out(conn, _params) do
     conn
-    |> clear_session()
+    |> clear_session(:ash_authentication_phoenix)
     |> render(:signed_out)
   end
 end",
"url": "https://github.com/team-alembic/ash_authentication_phoenix/commit/a3253fb4fc7145aeb403537af1c24d3a8d51ffb1.patch"
}
] |
CWE-613 Insufficient Session Expiration
|
GHSA-prc3-7f44-w48j
|
Missing XML Validation in Apache Tomcat
| null |
[
{
"commit_message": "[PATCH] Small optimisation. The resolver and the factory are only used when running under a security manager so only load them in this case. Also avoid a possible memory leak when creating these objects. This is part 1 of 7 of the fix for CVE-2014-0119 git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1588193 13f79535-47bb-0310-9956-ffa450edef68 .../catalina/security/SecurityClassLoad.java | 13 +++++++++++++ .../apache/catalina/servlets/DefaultServlet.java | 15 ++++++++++----- 2 files changed, 23 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/tomcat80/commit/d59fd4398c8ae6361e0b13c491f66b51e49a7441.patch"
},
{
"commit_message": "[PATCH] Parser uses lazy init so move creation of parser inside the block that uses the container class loader. This is part 5 of 7 of the fix for CVE-2014-0119 git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589985 13f79535-47bb-0310-9956-ffa450edef68 .../jasper/compiler/TagPluginManager.java | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/tomcat80/commit/7d33457de5fc5a652a88fb9bbc9ba4cbbda58f04.patch"
},
{
"commit_message": "[PATCH] More defensive coding around some XML activities that are triggered by web applications and are therefore at potential risk of a memory leak. This is part 6 of 7 of the fix for CVE-2014-0119 git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589990 13f79535-47bb-0310-9956-ffa450edef68 .../tomcat/util/descriptor/tld/TldParser.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/apache/tomcat80/commit/77e014cef5d5af619bcf77eaebf22c284d420802.patch"
},
{
"commit_message": "[PATCH] Add new constant missed in previous commit This is part 7 of 7 of the fix for CVE-2014-0119 git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589992 13f79535-47bb-0310-9956-ffa450edef68 java/org/apache/tomcat/util/descriptor/Constants.java | 1 + 1 file changed, 1 insertion(+)",
"patch_text_b64": "RnJvbSA2OWE4YTcyMjgzYzMzOTVlY2U4Yjg5OWNmODU2MmUxMjZkZTk3YTI3IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJrIFRob21hcyA8bWFya3RAYXBhY2hlLm9yZz4KRGF0ZTogRnJpLCAyNSBBcHIgMjAxNCAxMToxMDo1NSArMDAwMApTdWJqZWN0OiBbUEFUQ0hdIEFkZCBuZXcgY29uc3RhbnQgbWlzc2VkIGluIHByZXZpb3VzIGNvbW1pdCBUaGlzIGlzIHBhcnQgNyBvZgogNyBvZiB0aGUgZml4IGZvciBDVkUtMjAxNC0wMTE5CgpnaXQtc3ZuLWlkOiBodHRwczovL3N2bi5hcGFjaGUub3JnL3JlcG9zL2FzZi90b21jYXQvdHJ1bmtAMTU4OTk5MiAxM2Y3OTUzNS00N2JiLTAzMTAtOTk1Ni1mZmE0NTBlZGVmNjgKLS0tCiBqYXZhL29yZy9hcGFjaGUvdG9tY2F0L3V0aWwvZGVzY3JpcHRvci9Db25zdGFudHMuamF2YSB8IDEgKwogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspCgpkaWZmIC0tZ2l0IGEvamF2YS9vcmcvYXBhY2hlL3RvbWNhdC91dGlsL2Rlc2NyaXB0b3IvQ29uc3RhbnRzLmphdmEgYi9qYXZhL29yZy9hcGFjaGUvdG9tY2F0L3V0aWwvZGVzY3JpcHRvci9Db25zdGFudHMuamF2YQppbmRleCBlMGZlNWU1NGQuLjJhZDU5OTY2NiAxMDA2NDQKLS0tIGEvamF2YS9vcmcvYXBhY2hlL3RvbWNhdC91dGlsL2Rlc2NyaXB0b3IvQ29uc3RhbnRzLmphdmEKKysrIGIvamF2YS9vcmcvYXBhY2hlL3RvbWNhdC91dGlsL2Rlc2NyaXB0b3IvQ29uc3RhbnRzLmphdmEKQEAgLTIxLDQgKzIxLDUgQEAgcHVibGljIGNsYXNzIENvbnN0YW50cyB7CiAgICAgcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgUEFDS0FHRV9OQU1FID0KICAgICAgICAgICAgIENvbnN0YW50cy5jbGFzcy5nZXRQYWNrYWdlKCkuZ2V0TmFtZSgpOwogCisgICAgcHVibGljIHN0YXRpYyBmaW5hbCBib29sZWFuIElTX1NFQ1VSSVRZX0VOQUJMRUQgPSAoU3lzdGVtLmdldFNlY3VyaXR5TWFuYWdlcigpICE9IG51bGwpOwogfQ==",
"url": "https://github.com/apache/tomcat80/commit/69a8a72283c3395ece8b899cf8562e126de97a27.patch"
},
{
"commit_message": "[PATCH] More defensive coding around some XML activities that are triggered by web applications and are therefore at potential risk of a memory leak. This is part 3 of 7 of the fix for CVE-2014-0119 git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589980 13f79535-47bb-0310-9956-ffa450edef68 .../jasper/compiler/TagPluginManager.java | 32 ++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/tomcat80/commit/51e59532ad4c604f55575963dc7a7f0250cb420f.patch"
},
{
"commit_message": "[PATCH] Add some defensive coding around some XML activities that are triggered by web applications and are therefore at potential risk of a memory leak. This is part 2 of 7 of the fix for CVE-2014-0119 git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589837 13f79535-47bb-0310-9956-ffa450edef68 .../catalina/servlets/DefaultServlet.java | 30 +++++++- .../jasper/compiler/JspDocumentParser.java | 74 +++++++++++++------ res/checkstyle/org-import-control.xml | 1 + webapps/docs/changelog.xml | 5 ++ 4 files changed, 85 insertions(+), 25 deletions(-)",
"patch_text_b64": "From 4d90e355dc5ced4c53585c2b4700f71a52d8f447 Mon Sep 17 00:00:00 2001
From: Mark Thomas <markt@apache.org>
Date: Thu, 24 Apr 2014 19:16:21 +0000
Subject: [PATCH] Add some defensive coding around some XML activities that are
 triggered by web applications and are therefore at potential risk of a memory
 leak. This is part 2 of 7 of the fix for CVE-2014-0119

git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589837 13f79535-47bb-0310-9956-ffa450edef68
---
 .../catalina/servlets/DefaultServlet.java     | 30 +++++++-
 .../jasper/compiler/JspDocumentParser.java    | 74 +++++++++++++------
 res/checkstyle/org-import-control.xml         |  1 +
 webapps/docs/changelog.xml                    |  5 ++
 4 files changed, 85 insertions(+), 25 deletions(-)

diff --git a/java/org/apache/catalina/servlets/DefaultServlet.java b/java/org/apache/catalina/servlets/DefaultServlet.java
index 0c678ebc0..02a2900dd 100644
--- a/java/org/apache/catalina/servlets/DefaultServlet.java
+++ b/java/org/apache/catalina/servlets/DefaultServlet.java
@@ -31,6 +31,7 @@
 import java.io.Reader;
 import java.io.StringReader;
 import java.io.StringWriter;
+import java.security.AccessController;
 import java.util.ArrayList;
 import java.util.Enumeration;
 import java.util.Iterator;
@@ -68,6 +69,8 @@
 import org.apache.catalina.util.ServerInfo;
 import org.apache.catalina.util.URLEncoder;
 import org.apache.tomcat.util.res.StringManager;
+import org.apache.tomcat.util.security.PrivilegedGetTccl;
+import org.apache.tomcat.util.security.PrivilegedSetTccl;
 import org.w3c.dom.Document;
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
@@ -1309,11 +1312,27 @@ protected InputStream renderXml(String contextPath,
             sb.append("]]></readme>");
         }
 
-
         sb.append("</listing>");
 
-
+        // Prevent possible memory leak. Ensure Transformer and
+        // TransformerFactory are not loaded from the web application.
+        ClassLoader original;
+        if (Globals.IS_SECURITY_ENABLED) {
+            PrivilegedGetTccl pa = new PrivilegedGetTccl();
+            original = AccessController.doPrivileged(pa);
+        } else {
+            original = Thread.currentThread().getContextClassLoader();
+        }
         try {
+            if (Globals.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa =
+                        new PrivilegedSetTccl(DefaultServlet.class.getClassLoader());
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(
+                        DefaultServlet.class.getClassLoader());
+            }
+
             TransformerFactory tFactory = TransformerFactory.newInstance();
             Source xmlSource = new StreamSource(new StringReader(sb.toString()));
             Transformer transformer = tFactory.newTransformer(xsltSource);
@@ -1326,6 +1345,13 @@ protected InputStream renderXml(String contextPath,
             return (new ByteArrayInputStream(stream.toByteArray()));
         } catch (TransformerException e) {
             throw new ServletException("XSL transformer error", e);
+        } finally {
+            if (Globals.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa = new PrivilegedSetTccl(original);
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(original);
+            }
         }
     }
 
diff --git a/java/org/apache/jasper/compiler/JspDocumentParser.java b/java/org/apache/jasper/compiler/JspDocumentParser.java
index 2108767a2..ac08064e3 100644
--- a/java/org/apache/jasper/compiler/JspDocumentParser.java
+++ b/java/org/apache/jasper/compiler/JspDocumentParser.java
@@ -19,6 +19,7 @@
 import java.io.CharArrayWriter;
 import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.security.AccessController;
 import java.util.Collection;
 import java.util.Iterator;
 
@@ -35,6 +36,8 @@
 import org.apache.tomcat.util.descriptor.LocalResolver;
 import org.apache.tomcat.util.descriptor.tld.TldResourcePath;
 import org.apache.tomcat.util.scan.Jar;
+import org.apache.tomcat.util.security.PrivilegedGetTccl;
+import org.apache.tomcat.util.security.PrivilegedSetTccl;
 import org.xml.sax.Attributes;
 import org.xml.sax.InputSource;
 import org.xml.sax.Locator;
@@ -1452,33 +1455,58 @@ private static SAXParser getSAXParser(
         JspDocumentParser jspDocParser)
         throws Exception {
 
-        SAXParserFactory factory = SAXParserFactory.newInstance();
+        ClassLoader original;
+        if (Constants.IS_SECURITY_ENABLED) {
+            PrivilegedGetTccl pa = new PrivilegedGetTccl();
+            original = AccessController.doPrivileged(pa);
+        } else {
+            original = Thread.currentThread().getContextClassLoader();
+        }
+        try {
+            if (Constants.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa =
+                        new PrivilegedSetTccl(JspDocumentParser.class.getClassLoader());
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(
+                        JspDocumentParser.class.getClassLoader());
+            }
 
-        factory.setNamespaceAware(true);
-        // Preserve xmlns attributes
-        factory.setFeature(
-            "http://xml.org/sax/features/namespace-prefixes",
-            true);
+            SAXParserFactory factory = SAXParserFactory.newInstance();
 
-        factory.setValidating(validating);
-        if (validating) {
-            // Enable DTD validation
-            factory.setFeature(
-                    "http://xml.org/sax/features/validation",
-                    true);
-            // Enable schema validation
+            factory.setNamespaceAware(true);
+            // Preserve xmlns attributes
             factory.setFeature(
-                    "http://apache.org/xml/features/validation/schema",
-                    true);
-        }
-
-        // Configure the parser
-        SAXParser saxParser = factory.newSAXParser();
-        XMLReader xmlReader = saxParser.getXMLReader();
-        xmlReader.setProperty(LEXICAL_HANDLER_PROPERTY, jspDocParser);
-        xmlReader.setErrorHandler(jspDocParser);
+                "http://xml.org/sax/features/namespace-prefixes",
+                true);
+
+            factory.setValidating(validating);
+            if (validating) {
+                // Enable DTD validation
+                factory.setFeature(
+                        "http://xml.org/sax/features/validation",
+                        true);
+                // Enable schema validation
+                factory.setFeature(
+                        "http://apache.org/xml/features/validation/schema",
+                        true);
+            }
 
-        return saxParser;
+            // Configure the parser
+            SAXParser saxParser = factory.newSAXParser();
+            XMLReader xmlReader = saxParser.getXMLReader();
+            xmlReader.setProperty(LEXICAL_HANDLER_PROPERTY, jspDocParser);
+            xmlReader.setErrorHandler(jspDocParser);
+
+            return saxParser;
+        } finally {
+            if (Constants.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa = new PrivilegedSetTccl(original);
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(original);
+            }
+        }
     }
 
     /*
diff --git a/res/checkstyle/org-import-control.xml b/res/checkstyle/org-import-control.xml
index 40094ee64..ca96156f9 100644
--- a/res/checkstyle/org-import-control.xml
+++ b/res/checkstyle/org-import-control.xml
@@ -102,6 +102,7 @@
     <allow pkg="org.apache.tomcat" exact-match="true"/>
     <allow pkg="org.apache.tomcat.util.descriptor"/>
     <allow pkg="org.apache.tomcat.util.scan"/>
+    <allow pkg="org.apache.tomcat.util.security"/>
     <allow pkg="org.apache.tools.ant"/>
     <allow pkg="org.eclipse.jdt"/>
   </subpackage>
diff --git a/webapps/docs/changelog.xml b/webapps/docs/changelog.xml
index 2423496b6..7aa6c9bab 100644
--- a/webapps/docs/changelog.xml
+++ b/webapps/docs/changelog.xml
@@ -131,6 +131,11 @@
         patterns of the form <code>*.a.b</code> which are not valid patterns for
         extension mappings. (markt)
       </add>
+      <add>
+        Extend XML factory, parser etc. memory leak protection to cover some
+        additional locations where, theoretically, a memory leak could occur.
+        (markt)
+      </add>
     </changelog>
   </subsection>
   <subsection name="Coyote">",
"url": "https://github.com/apache/tomcat80/commit/4d90e355dc5ced4c53585c2b4700f71a52d8f447.patch"
},
{
"commit_message": "[PATCH] Fix indents and copy/paste errors This is part 4 of 7 of the fix for CVE-2014-0119 git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589983 13f79535-47bb-0310-9956-ffa450edef68 java/org/apache/jasper/compiler/TagPluginManager.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)",
"patch_text_b64": "RnJvbSAyNTI1MWRlNzkxYTZhN2JlMTNmMmYzZDNhNjYxMTlhNzcwMjUyNzJkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJrIFRob21hcyA8bWFya3RAYXBhY2hlLm9yZz4KRGF0ZTogRnJpLCAyNSBBcHIgMjAxNCAxMDo0NDowNSArMDAwMApTdWJqZWN0OiBbUEFUQ0hdIEZpeCBpbmRlbnRzIGFuZCBjb3B5L3Bhc3RlIGVycm9ycyBUaGlzIGlzIHBhcnQgNCBvZiA3IG9mIHRoZQogZml4IGZvciBDVkUtMjAxNC0wMTE5CgpnaXQtc3ZuLWlkOiBodHRwczovL3N2bi5hcGFjaGUub3JnL3JlcG9zL2FzZi90b21jYXQvdHJ1bmtAMTU4OTk4MyAxM2Y3OTUzNS00N2JiLTAzMTAtOTk1Ni1mZmE0NTBlZGVmNjgKLS0tCiBqYXZhL29yZy9hcGFjaGUvamFzcGVyL2NvbXBpbGVyL1RhZ1BsdWdpbk1hbmFnZXIuamF2YSB8IDEwICsrKysrLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCA1IGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvamF2YS9vcmcvYXBhY2hlL2phc3Blci9jb21waWxlci9UYWdQbHVnaW5NYW5hZ2VyLmphdmEgYi9qYXZhL29yZy9hcGFjaGUvamFzcGVyL2NvbXBpbGVyL1RhZ1BsdWdpbk1hbmFnZXIuamF2YQppbmRleCAzZDJmMjA1ZmUuLjAwNzIzMGQ5MyAxMDA2NDQKLS0tIGEvamF2YS9vcmcvYXBhY2hlL2phc3Blci9jb21waWxlci9UYWdQbHVnaW5NYW5hZ2VyLmphdmEKKysrIGIvamF2YS9vcmcvYXBhY2hlL2phc3Blci9jb21waWxlci9UYWdQbHVnaW5NYW5hZ2VyLmphdmEKQEAgLTc5LDE3ICs3OSwxNyBAQCBwcml2YXRlIHZvaWQgaW5pdChFcnJvckRpc3BhdGNoZXIgZXJyKSB0aHJvd3MgSmFzcGVyRXhjZXB0aW9uIHsKICAgICAgICAgaWYgKENvbnN0YW50cy5JU19TRUNVUklUWV9FTkFCTEVEKSB7CiAgICAgICAgICAgICBQcml2aWxlZ2VkR2V0VGNjbCBwYSA9IG5ldyBQcml2aWxlZ2VkR2V0VGNjbCgpOwogICAgICAgICAgICAgb3JpZ2luYWwgPSBBY2Nlc3NDb250cm9sbGVyLmRvUHJpdmlsZWdlZChwYSk7Ci0gICAgICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgICAgIG9yaWdpbmFsID0gVGhyZWFkLmN1cnJlbnRUaHJlYWQoKS5nZXRDb250ZXh0Q2xhc3NMb2FkZXIoKTsKLSAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIG9yaWdpbmFsID0gVGhyZWFkLmN1cnJlbnRUaHJlYWQoKS5nZXRDb250ZXh0Q2xhc3NMb2FkZXIoKTsKKyAgICAgICAgfQogICAgICAgICB0cnkgewogICAgICAgICAgICAgaWYgKENvbnN0YW50cy5JU19TRUNVUklUWV9FTkFCTEVEKSB7CiAgICAgICAgICAgICAgICAgUHJpdmlsZWdlZFNldFRjY2wgcGEgPQotICAgICAgICAgICAgICAgICAgICAgICAgbmV3IFByaXZpbGVnZWRTZXRUY2NsKEpzcERvY3VtZW50UGFyc2VyLmNsYXNzLmdldENsYXNzTG9hZGVyKCkpOworICAgICAgICAgICAgICAgICAgICAgICAgbmV3IFByaXZpbGVnZWRTZXRUY2NsKFRhZ1BsdWdpbk1hbmFnZXIuY2xhc3MuZ2V0Q2xhc3NMb2FkZXIoKSk7CiAgICAgICAgICAgICAgICAgQWNjZXNzQ29udHJvbGxlci5kb1ByaXZpbGVnZWQocGEpOwogICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICBUaHJlYWQuY3VycmVudFRocmVhZCgpLnNldENvbnRleHRDbGFzc0xvYWRlcigKLSAgICAgICAgICAgICAgICAgICAgICAgIEpzcERvY3VtZW50UGFyc2VyLmNsYXNzLmdldENsYXNzTG9hZGVyKCkpOworICAgICAgICAgICAgICAgICAgICAgICAgVGFnUGx1Z2luTWFuYWdlci5jbGFzcy5nZXRDbGFzc0xvYWRlcigpKTsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgcGFyc2VyID0gbmV3IFRhZ1BsdWdpblBhcnNlcihjdHh0LCBibG9ja0V4dGVybmFsKTs=",
"url": "https://github.com/apache/tomcat80/commit/25251de791a6a7be13f2f3d3a66119a77025272d.patch"
},
{
"commit_message": "[PATCH] Small optimisation. The resolver and the factory are only used when running under a security manager so only load them in this case. Also avoid a possible memory leak when creating these objects. git-svn-id: https://svn.apache.org/repos/asf/tomcat/tc7.0.x/trunk@1588199 13f79535-47bb-0310-9956-ffa450edef68 .../catalina/security/SecurityClassLoad.java | 13 +++++++++++++ .../apache/catalina/servlets/DefaultServlet.java | 15 ++++++++++----- webapps/docs/changelog.xml | 4 ++++ 3 files changed, 27 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/tomcat/commit/f8b316acbbf9fabf87cc137e9777e912eda0d834.patch"
},
{
"commit_message": "[PATCH] Parser uses lazy init so move creation of parser inside the block that uses the container class loader. git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589985 13f79535-47bb-0310-9956-ffa450edef68 .../jasper/compiler/TagPluginManager.java | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/tomcat/commit/ebe5c16f18ce1559e8462a94b3876a98525980d2.patch"
},
{
"commit_message": "[PATCH] Ensure TLD parser obtained from cache has correct value of blockExternal git-svn-id: https://svn.apache.org/repos/asf/tomcat/tc7.0.x/trunk@1590036 13f79535-47bb-0310-9956-ffa450edef68 .../apache/catalina/startup/TldConfig.java | 20 ++++++++++++++++--- webapps/docs/changelog.xml | 4 ++++ 2 files changed, 21 insertions(+), 3 deletions(-)",
"patch_text_b64": "RnJvbSAwODA4NzhlYTUxOWQ4Yzc0YzUzNzIxYTllYmY3YmU2ZmNmNmYxZjJmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJrIEVtbHluIERhdmlkIFRob21hcyA8bWFya3RAYXBhY2hlLm9yZz4KRGF0ZTogRnJpLCAyNSBBcHIgMjAxNCAxNDoxMjo1OSArMDAwMApTdWJqZWN0OiBbUEFUQ0hdIEVuc3VyZSBUTEQgcGFyc2VyIG9idGFpbmVkIGZyb20gY2FjaGUgaGFzIGNvcnJlY3QgdmFsdWUgb2YKIGJsb2NrRXh0ZXJuYWwKCmdpdC1zdm4taWQ6IGh0dHBzOi8vc3ZuLmFwYWNoZS5vcmcvcmVwb3MvYXNmL3RvbWNhdC90YzcuMC54L3RydW5rQDE1OTAwMzYgMTNmNzk1MzUtNDdiYi0wMzEwLTk5NTYtZmZhNDUwZWRlZjY4Ci0tLQogLi4uL2FwYWNoZS9jYXRhbGluYS9zdGFydHVwL1RsZENvbmZpZy5qYXZhICAgIHwgMjAgKysrKysrKysrKysrKysrKy0tLQogd2ViYXBwcy9kb2NzL2NoYW5nZWxvZy54bWwgICAgICAgICAgICAgICAgICAgIHwgIDQgKysrKwogMiBmaWxlcyBjaGFuZ2VkLCAyMSBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2phdmEvb3JnL2FwYWNoZS9jYXRhbGluYS9zdGFydHVwL1RsZENvbmZpZy5qYXZhIGIvamF2YS9vcmcvYXBhY2hlL2NhdGFsaW5hL3N0YXJ0dXAvVGxkQ29uZmlnLmphdmEKaW5kZXggNTdmZDVkYmEzYTBmLi4zMDA5YmM5NThkY2IgMTAwNjQ0Ci0tLSBhL2phdmEvb3JnL2FwYWNoZS9jYXRhbGluYS9zdGFydHVwL1RsZENvbmZpZy5qYXZhCisrKyBiL2phdmEvb3JnL2FwYWNoZS9jYXRhbGluYS9zdGFydHVwL1RsZENvbmZpZy5qYXZhCkBAIC03OSw3ICs3OSw3IEBAIHB1YmxpYyBmaW5hbCBjbGFzcyBUbGRDb25maWcgIGltcGxlbWVudHMgTGlmZWN5Y2xlTGlzdGVuZXIgewogICAgIC8qKgogICAgICAqIFRoZSA8Y29kZT5EaWdlc3RlcjwvY29kZT5zIGF2YWlsYWJsZSB0byBwcm9jZXNzIHRsZCBmaWxlcy4KICAgICAgKi8KLSAgICBwcml2YXRlIHN0YXRpYyBEaWdlc3RlcltdIHRsZERpZ2VzdGVycyA9IG5ldyBEaWdlc3RlclsyXTsKKyAgICBwcml2YXRlIHN0YXRpYyBEaWdlc3RlcltdIHRsZERpZ2VzdGVycyA9IG5ldyBEaWdlc3Rlcls0XTsKIAogICAgIC8qKgogICAgICAqIENyZWF0ZSAoaWYgbmVjZXNzYXJ5KSBhbmQgcmV0dXJuIGEgRGlnZXN0ZXIgY29uZmlndXJlZCB0byBwcm9jZXNzIHRoZQpAQCAtODksMjAgKzg5LDM0IEBAIHByaXZhdGUgc3RhdGljIERpZ2VzdGVyIGNyZWF0ZVRsZERpZ2VzdGVyKGJvb2xlYW4gdmFsaWRhdGlvbiwKICAgICAgICAgICAgIGJvb2xlYW4gYmxvY2tFeHRlcm5hbCkgewogICAgICAgICAKICAgICAgICAgRGlnZXN0ZXIgZGlnZXN0ZXIgPSBudWxsOwotICAgICAgICBpZiAoIXZhbGlkYXRpb24pIHsKKyAgICAgICAgaWYgKCF2YWxpZGF0aW9uICYmICFibG9ja0V4dGVybmFsKSB7CiAgICAgICAgICAgICBpZiAodGxkRGlnZXN0ZXJzWzBdID09IG51bGwpIHsKICAgICAgICAgICAgICAgICB0bGREaWdlc3RlcnNbMF0gPSBEaWdlc3RlckZhY3RvcnkubmV3RGlnZXN0ZXIodmFsaWRhdGlvbiwKICAgICAgICAgICAgICAgICAgICAgICAgIHRydWUsIG5ldyBUbGRSdWxlU2V0KCksIGJsb2NrRXh0ZXJuYWwpOwogICAgICAgICAgICAgICAgIHRsZERpZ2VzdGVyc1swXS5nZXRQYXJzZXIoKTsKICAgICAgICAgICAgIH0KICAgICAgICAgICAgIGRpZ2VzdGVyID0gdGxkRGlnZXN0ZXJzWzBdOwotICAgICAgICB9IGVsc2UgeworICAgICAgICB9IGVsc2UgaWYgKCF2YWxpZGF0aW9uICYmIGJsb2NrRXh0ZXJuYWwpIHsKICAgICAgICAgICAgIGlmICh0bGREaWdlc3RlcnNbMV0gPT0gbnVsbCkgewogICAgICAgICAgICAgICAgIHRsZERpZ2VzdGVyc1sxXSA9IERpZ2VzdGVyRmFjdG9yeS5uZXdEaWdlc3Rlcih2YWxpZGF0aW9uLAogICAgICAgICAgICAgICAgICAgICAgICAgdHJ1ZSwgbmV3IFRsZFJ1bGVTZXQoKSwgYmxvY2tFeHRlcm5hbCk7CiAgICAgICAgICAgICAgICAgdGxkRGlnZXN0ZXJzWzFdLmdldFBhcnNlcigpOwogICAgICAgICAgICAgfQogICAgICAgICAgICAgZGlnZXN0ZXIgPSB0bGREaWdlc3RlcnNbMV07CisgICAgICAgIH0gZWxzZSBpZiAodmFsaWRhdGlvbiAmJiAhYmxvY2tFeHRlcm5hbCkgeworICAgICAgICAgICAgaWYgKHRsZERpZ2VzdGVyc1syXSA9PSBudWxsKSB7CisgICAgICAgICAgICAgICAgdGxkRGlnZXN0ZXJzWzJdID0gRGlnZXN0ZXJGYWN0b3J5Lm5ld0RpZ2VzdGVyKHZhbGlkYXRpb24sCisgICAgICAgICAgICAgICAgICAgICAgICB0cnVlLCBuZXcgVGxkUnVsZVNldCgpLCBibG9ja0V4dGVybmFsKTsKKyAgICAgICAgICAgICAgICB0bGREaWdlc3RlcnNbMl0uZ2V0UGFyc2VyKCk7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBkaWdlc3RlciA9IHRsZERpZ2VzdGVyc1syXTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIGlmICh0bGREaWdlc3RlcnNbM10gPT0gbnVsbCkgeworICAgICAgICAgICAgICAgIHRsZERpZ2VzdGVyc1szXSA9IERpZ2VzdGVyRmFjdG9yeS5uZXdEaWdlc3Rlcih2YWxpZGF0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgdHJ1ZSwgbmV3IFRsZFJ1bGVTZXQoKSwgYmxvY2tFeHRlcm5hbCk7CisgICAgICAgICAgICAgICAgdGxkRGlnZXN0ZXJzWzNdLmdldFBhcnNlcigpOworICAgICAgICAgICAgfQorICAgICAgICAgICAgZGlnZXN0ZXIgPSB0bGREaWdlc3RlcnNbM107CiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIGRpZ2VzdGVyOwogICAgIH0KZGlmZiAtLWdpdCBhL3dlYmFwcHMvZG9jcy9jaGFuZ2Vsb2cueG1sIGIvd2ViYXBwcy9kb2NzL2NoYW5nZWxvZy54bWwKaW5kZXggYzkxYjg3MmFmY2Y5Li42ODZhODRkMGM0MDIgMTAwNjQ0Ci0tLSBhL3dlYmFwcHMvZG9jcy9jaGFuZ2Vsb2cueG1sCisrKyBiL3dlYmFwcHMvZG9jcy9jaGFuZ2Vsb2cueG1sCkBAIC0xMjEsNiArMTIxLDEwIEBACiAgICAgICAgIGFkZGl0aW9uYWwgbG9jYXRpb25zIHdoZXJlLCB0aGVvcmV0aWNhbGx5LCBhIG1lbW9yeSBsZWFrIGNvdWxkIG9jY3VyLgogICAgICAgICAobWFya3QpCiAgICAgICA8L2FkZD4KKyAgICAgIDxmaXg+CisgICAgICAgIEVuc3VyZSB0aGF0IGEgVExEIHBhcnNlciBvYnRhaW5lZCBmcm9tIHRoZSBjYWNoZSBoYXMgdGhlIGNvcnJlY3QgdmFsdWUKKyAgICAgICAgb2YgPGNvZGU+YmxvY2tFeHRlcm5hbDwvY29kZT4uIChtYXJrdCkKKyAgICAgIDwvZml4PgogICAgIDwvY2hhbmdlbG9nPgogICA8L3N1YnNlY3Rpb24+CiAgIDxzdWJzZWN0aW9uIG5hbWU9IkNveW90ZSI+",
"url": "https://github.com/apache/tomcat/commit/080878ea519d8c74c53721a9ebf7be6fcf6f1f2f.patch"
},
{
"commit_message": "[PATCH] Add new constant missed in previous commit git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589992 13f79535-47bb-0310-9956-ffa450edef68 java/org/apache/tomcat/util/descriptor/Constants.java | 1 + 1 file changed, 1 insertion(+)",
"patch_text_b64": "RnJvbSA1MDMxMWJlZDhkODdlNDUyZmYwZTY5ODM4YmEzMTJjNGZlODk5YjJkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJrIEVtbHluIERhdmlkIFRob21hcyA8bWFya3RAYXBhY2hlLm9yZz4KRGF0ZTogRnJpLCAyNSBBcHIgMjAxNCAxMToxMDo1NSArMDAwMApTdWJqZWN0OiBbUEFUQ0hdIEFkZCBuZXcgY29uc3RhbnQgbWlzc2VkIGluIHByZXZpb3VzIGNvbW1pdAoKZ2l0LXN2bi1pZDogaHR0cHM6Ly9zdm4uYXBhY2hlLm9yZy9yZXBvcy9hc2YvdG9tY2F0L3RydW5rQDE1ODk5OTIgMTNmNzk1MzUtNDdiYi0wMzEwLTk5NTYtZmZhNDUwZWRlZjY4Ci0tLQogamF2YS9vcmcvYXBhY2hlL3RvbWNhdC91dGlsL2Rlc2NyaXB0b3IvQ29uc3RhbnRzLmphdmEgfCAxICsKIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKQoKZGlmZiAtLWdpdCBhL2phdmEvb3JnL2FwYWNoZS90b21jYXQvdXRpbC9kZXNjcmlwdG9yL0NvbnN0YW50cy5qYXZhIGIvamF2YS9vcmcvYXBhY2hlL3RvbWNhdC91dGlsL2Rlc2NyaXB0b3IvQ29uc3RhbnRzLmphdmEKaW5kZXggZTBmZTVlNTRkYzQxLi4yYWQ1OTk2NjZhNjkgMTAwNjQ0Ci0tLSBhL2phdmEvb3JnL2FwYWNoZS90b21jYXQvdXRpbC9kZXNjcmlwdG9yL0NvbnN0YW50cy5qYXZhCisrKyBiL2phdmEvb3JnL2FwYWNoZS90b21jYXQvdXRpbC9kZXNjcmlwdG9yL0NvbnN0YW50cy5qYXZhCkBAIC0yMSw0ICsyMSw1IEBAIHB1YmxpYyBjbGFzcyBDb25zdGFudHMgewogICAgIHB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFBBQ0tBR0VfTkFNRSA9CiAgICAgICAgICAgICBDb25zdGFudHMuY2xhc3MuZ2V0UGFja2FnZSgpLmdldE5hbWUoKTsKIAorICAgIHB1YmxpYyBzdGF0aWMgZmluYWwgYm9vbGVhbiBJU19TRUNVUklUWV9FTkFCTEVEID0gKFN5c3RlbS5nZXRTZWN1cml0eU1hbmFnZXIoKSAhPSBudWxsKTsKIH0=",
"url": "https://github.com/apache/tomcat/commit/50311bed8d87e452ff0e69838ba312c4fe899b2d.patch"
},
{
"commit_message": "[PATCH] More defensive coding around some XML activities that are triggered by web applications and are therefore at potential risk of a memory leak. git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589980 13f79535-47bb-0310-9956-ffa450edef68 .../jasper/compiler/TagPluginManager.java | 32 ++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/tomcat/commit/5517c5517e8a7ddb994504f0c5c05001a376b10c.patch"
},
{
"commit_message": "[PATCH] More defensive coding around some XML activities that are triggered by web applications and are therefore at potential risk of a memory leak. git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589990 13f79535-47bb-0310-9956-ffa450edef68 .../tomcat/util/descriptor/tld/TldParser.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+)",
"patch_text_b64": "RnJvbSA1YWFlMTMyM2MzMWQ2NDNhZmE5ZjJkYjgwNzEzYjhlOTdiNTEyM2FmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJrIEVtbHluIERhdmlkIFRob21hcyA8bWFya3RAYXBhY2hlLm9yZz4KRGF0ZTogRnJpLCAyNSBBcHIgMjAxNCAxMTowNDoyNCArMDAwMApTdWJqZWN0OiBbUEFUQ0hdIE1vcmUgZGVmZW5zaXZlIGNvZGluZyBhcm91bmQgc29tZSBYTUwgYWN0aXZpdGllcyB0aGF0IGFyZQogdHJpZ2dlcmVkIGJ5IHdlYiBhcHBsaWNhdGlvbnMgYW5kIGFyZSB0aGVyZWZvcmUgYXQgcG90ZW50aWFsIHJpc2sgb2YgYSBtZW1vcnkKIGxlYWsuCgpnaXQtc3ZuLWlkOiBodHRwczovL3N2bi5hcGFjaGUub3JnL3JlcG9zL2FzZi90b21jYXQvdHJ1bmtAMTU4OTk5MCAxM2Y3OTUzNS00N2JiLTAzMTAtOTk1Ni1mZmE0NTBlZGVmNjgKLS0tCiAuLi4vdG9tY2F0L3V0aWwvZGVzY3JpcHRvci90bGQvVGxkUGFyc2VyLmphdmEgfCAyMyArKysrKysrKysrKysrKysrKysrCiAxIGZpbGUgY2hhbmdlZCwgMjMgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2phdmEvb3JnL2FwYWNoZS90b21jYXQvdXRpbC9kZXNjcmlwdG9yL3RsZC9UbGRQYXJzZXIuamF2YSBiL2phdmEvb3JnL2FwYWNoZS90b21jYXQvdXRpbC9kZXNjcmlwdG9yL3RsZC9UbGRQYXJzZXIuamF2YQppbmRleCA5MTY2ZDhjMTE5ZWEuLjdlMmM3M2YxYTVhNyAxMDA2NDQKLS0tIGEvamF2YS9vcmcvYXBhY2hlL3RvbWNhdC91dGlsL2Rlc2NyaXB0b3IvdGxkL1RsZFBhcnNlci5qYXZhCisrKyBiL2phdmEvb3JnL2FwYWNoZS90b21jYXQvdXRpbC9kZXNjcmlwdG9yL3RsZC9UbGRQYXJzZXIuamF2YQpAQCAtMTgsMTMgKzE4LDE3IEBACiAKIGltcG9ydCBqYXZhLmlvLklPRXhjZXB0aW9uOwogaW1wb3J0IGphdmEuaW8uSW5wdXRTdHJlYW07CitpbXBvcnQgamF2YS5zZWN1cml0eS5BY2Nlc3NDb250cm9sbGVyOwogCiBpbXBvcnQgb3JnLmFwYWNoZS5qdWxpLmxvZ2dpbmcuTG9nOwogaW1wb3J0IG9yZy5hcGFjaGUuanVsaS5sb2dnaW5nLkxvZ0ZhY3Rvcnk7CitpbXBvcnQgb3JnLmFwYWNoZS50b21jYXQudXRpbC5kZXNjcmlwdG9yLkNvbnN0YW50czsKIGltcG9ydCBvcmcuYXBhY2hlLnRvbWNhdC51dGlsLmRlc2NyaXB0b3IuRGlnZXN0ZXJGYWN0b3J5OwogaW1wb3J0IG9yZy5hcGFjaGUudG9tY2F0LnV0aWwuZGVzY3JpcHRvci5YbWxFcnJvckhhbmRsZXI7CiBpbXBvcnQgb3JnLmFwYWNoZS50b21jYXQudXRpbC5kaWdlc3Rlci5EaWdlc3RlcjsKIGltcG9ydCBvcmcuYXBhY2hlLnRvbWNhdC51dGlsLmRpZ2VzdGVyLlJ1bGVTZXQ7CitpbXBvcnQgb3JnLmFwYWNoZS50b21jYXQudXRpbC5zZWN1cml0eS5Qcml2aWxlZ2VkR2V0VGNjbDsKK2ltcG9ydCBvcmcuYXBhY2hlLnRvbWNhdC51dGlsLnNlY3VyaXR5LlByaXZpbGVnZWRTZXRUY2NsOwogaW1wb3J0IG9yZy54bWwuc2F4LklucHV0U291cmNlOwogaW1wb3J0IG9yZy54bWwuc2F4LlNBWEV4Y2VwdGlvbjsKIApAQCAtNDcsNyArNTEsMjAgQEAgcHVibGljIFRsZFBhcnNlcihib29sZWFuIG5hbWVzcGFjZUF3YXJlLCBib29sZWFuIHZhbGlkYXRpb24sIFJ1bGVTZXQgcnVsZVNldCwKICAgICB9CiAKICAgICBwdWJsaWMgVGFnbGliWG1sIHBhcnNlKFRsZFJlc291cmNlUGF0aCBwYXRoKSB0aHJvd3MgSU9FeGNlcHRpb24sIFNBWEV4Y2VwdGlvbiB7CisgICAgICAgIENsYXNzTG9hZGVyIG9yaWdpbmFsOworICAgICAgICBpZiAoQ29uc3RhbnRzLklTX1NFQ1VSSVRZX0VOQUJMRUQpIHsKKyAgICAgICAgICAgIFByaXZpbGVnZWRHZXRUY2NsIHBhID0gbmV3IFByaXZpbGVnZWRHZXRUY2NsKCk7CisgICAgICAgICAgICBvcmlnaW5hbCA9IEFjY2Vzc0NvbnRyb2xsZXIuZG9Qcml2aWxlZ2VkKHBhKTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIG9yaWdpbmFsID0gVGhyZWFkLmN1cnJlbnRUaHJlYWQoKS5nZXRDb250ZXh0Q2xhc3NMb2FkZXIoKTsKKyAgICAgICAgfQogICAgICAgICB0cnkgKElucHV0U3RyZWFtIGlzID0gcGF0aC5vcGVuU3RyZWFtKCkpIHsKKyAgICAgICAgICAgIGlmIChDb25zdGFudHMuSVNfU0VDVVJJVFlfRU5BQkxFRCkgeworICAgICAgICAgICAgICAgIFByaXZpbGVnZWRTZXRUY2NsIHBhID0gbmV3IFByaXZpbGVnZWRTZXRUY2NsKFRsZFBhcnNlci5jbGFzcy5nZXRDbGFzc0xvYWRlcigpKTsKKyAgICAgICAgICAgICAgICBBY2Nlc3NDb250cm9sbGVyLmRvUHJpdmlsZWdlZChwYSk7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIFRocmVhZC5jdXJyZW50VGhyZWFkKCkuc2V0Q29udGV4dENsYXNzTG9hZGVyKFRsZFBhcnNlci5jbGFzcy5nZXRDbGFzc0xvYWRlcigpKTsKKyAgICAgICAgICAgIH0KICAgICAgICAgICAgIFhtbEVycm9ySGFuZGxlciBoYW5kbGVyID0gbmV3IFhtbEVycm9ySGFuZGxlcigpOwogICAgICAgICAgICAgZGlnZXN0ZXIuc2V0RXJyb3JIYW5kbGVyKGhhbmRsZXIpOwogCkBAIC02Nyw2ICs4NCwxMiBAQCBwdWJsaWMgVGFnbGliWG1sIHBhcnNlKFRsZFJlc291cmNlUGF0aCBwYXRoKSB0aHJvd3MgSU9FeGNlcHRpb24sIFNBWEV4Y2VwdGlvbiB7CiAgICAgICAgICAgICByZXR1cm4gdGFnbGliWG1sOwogICAgICAgICB9IGZpbmFsbHkgewogICAgICAgICAgICAgZGlnZXN0ZXIucmVzZXQoKTsKKyAgICAgICAgICAgIGlmIChDb25zdGFudHMuSVNfU0VDVVJJVFlfRU5BQkxFRCkgeworICAgICAgICAgICAgICAgIFByaXZpbGVnZWRTZXRUY2NsIHBhID0gbmV3IFByaXZpbGVnZWRTZXRUY2NsKG9yaWdpbmFsKTsKKyAgICAgICAgICAgICAgICBBY2Nlc3NDb250cm9sbGVyLmRvUHJpdmlsZWdlZChwYSk7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIFRocmVhZC5jdXJyZW50VGhyZWFkKCkuc2V0Q29udGV4dENsYXNzTG9hZGVyKG9yaWdpbmFsKTsKKyAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0=",
"url": "https://github.com/apache/tomcat/commit/5aae1323c31d643afa9f2db80713b8e97b5123af.patch"
},
{
"commit_message": "[PATCH] More defensive coding around some XML activities that are triggered by web applications and are therefore at potential risk of a memory leak. git-svn-id: https://svn.apache.org/repos/asf/tomcat/tc7.0.x/trunk@1589997 13f79535-47bb-0310-9956-ffa450edef68 .../apache/jasper/xmlparser/ParserUtils.java | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/apache/tomcat/commit/6246d8307fb5f2b4ff0b0f4d6d1b0250dff01a81.patch"
},
{
"commit_message": "[PATCH] Add some defensive coding around some XML activities that are triggered by web applications and are therefore at potential risk of a memory leak. git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589837 13f79535-47bb-0310-9956-ffa450edef68 .../catalina/servlets/DefaultServlet.java | 30 +++++++- .../jasper/compiler/JspDocumentParser.java | 74 +++++++++++++------ res/checkstyle/org-import-control.xml | 1 + webapps/docs/changelog.xml | 5 ++ 4 files changed, 85 insertions(+), 25 deletions(-)",
"patch_text_b64": "From 769477b9bc8442db3f571385fa0c3e206242cbf1 Mon Sep 17 00:00:00 2001
From: Mark Emlyn David Thomas <markt@apache.org>
Date: Thu, 24 Apr 2014 19:16:21 +0000
Subject: [PATCH] Add some defensive coding around some XML activities that are
 triggered by web applications and are therefore at potential risk of a memory
 leak.

git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589837 13f79535-47bb-0310-9956-ffa450edef68
---
 .../catalina/servlets/DefaultServlet.java     | 30 +++++++-
 .../jasper/compiler/JspDocumentParser.java    | 74 +++++++++++++------
 res/checkstyle/org-import-control.xml         |  1 +
 webapps/docs/changelog.xml                    |  5 ++
 4 files changed, 85 insertions(+), 25 deletions(-)

diff --git a/java/org/apache/catalina/servlets/DefaultServlet.java b/java/org/apache/catalina/servlets/DefaultServlet.java
index 0c678ebc0690..02a2900ddd98 100644
--- a/java/org/apache/catalina/servlets/DefaultServlet.java
+++ b/java/org/apache/catalina/servlets/DefaultServlet.java
@@ -31,6 +31,7 @@
 import java.io.Reader;
 import java.io.StringReader;
 import java.io.StringWriter;
+import java.security.AccessController;
 import java.util.ArrayList;
 import java.util.Enumeration;
 import java.util.Iterator;
@@ -68,6 +69,8 @@
 import org.apache.catalina.util.ServerInfo;
 import org.apache.catalina.util.URLEncoder;
 import org.apache.tomcat.util.res.StringManager;
+import org.apache.tomcat.util.security.PrivilegedGetTccl;
+import org.apache.tomcat.util.security.PrivilegedSetTccl;
 import org.w3c.dom.Document;
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
@@ -1309,11 +1312,27 @@ protected InputStream renderXml(String contextPath,
             sb.append("]]></readme>");
         }
 
-
         sb.append("</listing>");
 
-
+        // Prevent possible memory leak. Ensure Transformer and
+        // TransformerFactory are not loaded from the web application.
+        ClassLoader original;
+        if (Globals.IS_SECURITY_ENABLED) {
+            PrivilegedGetTccl pa = new PrivilegedGetTccl();
+            original = AccessController.doPrivileged(pa);
+        } else {
+            original = Thread.currentThread().getContextClassLoader();
+        }
         try {
+            if (Globals.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa =
+                        new PrivilegedSetTccl(DefaultServlet.class.getClassLoader());
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(
+                        DefaultServlet.class.getClassLoader());
+            }
+
             TransformerFactory tFactory = TransformerFactory.newInstance();
             Source xmlSource = new StreamSource(new StringReader(sb.toString()));
             Transformer transformer = tFactory.newTransformer(xsltSource);
@@ -1326,6 +1345,13 @@ protected InputStream renderXml(String contextPath,
             return (new ByteArrayInputStream(stream.toByteArray()));
         } catch (TransformerException e) {
             throw new ServletException("XSL transformer error", e);
+        } finally {
+            if (Globals.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa = new PrivilegedSetTccl(original);
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(original);
+            }
         }
     }
 
diff --git a/java/org/apache/jasper/compiler/JspDocumentParser.java b/java/org/apache/jasper/compiler/JspDocumentParser.java
index 2108767a2792..ac08064e39c2 100644
--- a/java/org/apache/jasper/compiler/JspDocumentParser.java
+++ b/java/org/apache/jasper/compiler/JspDocumentParser.java
@@ -19,6 +19,7 @@
 import java.io.CharArrayWriter;
 import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.security.AccessController;
 import java.util.Collection;
 import java.util.Iterator;
 
@@ -35,6 +36,8 @@
 import org.apache.tomcat.util.descriptor.LocalResolver;
 import org.apache.tomcat.util.descriptor.tld.TldResourcePath;
 import org.apache.tomcat.util.scan.Jar;
+import org.apache.tomcat.util.security.PrivilegedGetTccl;
+import org.apache.tomcat.util.security.PrivilegedSetTccl;
 import org.xml.sax.Attributes;
 import org.xml.sax.InputSource;
 import org.xml.sax.Locator;
@@ -1452,33 +1455,58 @@ private static SAXParser getSAXParser(
         JspDocumentParser jspDocParser)
         throws Exception {
 
-        SAXParserFactory factory = SAXParserFactory.newInstance();
+        ClassLoader original;
+        if (Constants.IS_SECURITY_ENABLED) {
+            PrivilegedGetTccl pa = new PrivilegedGetTccl();
+            original = AccessController.doPrivileged(pa);
+        } else {
+            original = Thread.currentThread().getContextClassLoader();
+        }
+        try {
+            if (Constants.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa =
+                        new PrivilegedSetTccl(JspDocumentParser.class.getClassLoader());
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(
+                        JspDocumentParser.class.getClassLoader());
+            }
 
-        factory.setNamespaceAware(true);
-        // Preserve xmlns attributes
-        factory.setFeature(
-            "http://xml.org/sax/features/namespace-prefixes",
-            true);
+            SAXParserFactory factory = SAXParserFactory.newInstance();
 
-        factory.setValidating(validating);
-        if (validating) {
-            // Enable DTD validation
-            factory.setFeature(
-                    "http://xml.org/sax/features/validation",
-                    true);
-            // Enable schema validation
+            factory.setNamespaceAware(true);
+            // Preserve xmlns attributes
             factory.setFeature(
-                    "http://apache.org/xml/features/validation/schema",
-                    true);
-        }
-
-        // Configure the parser
-        SAXParser saxParser = factory.newSAXParser();
-        XMLReader xmlReader = saxParser.getXMLReader();
-        xmlReader.setProperty(LEXICAL_HANDLER_PROPERTY, jspDocParser);
-        xmlReader.setErrorHandler(jspDocParser);
+                "http://xml.org/sax/features/namespace-prefixes",
+                true);
+
+            factory.setValidating(validating);
+            if (validating) {
+                // Enable DTD validation
+                factory.setFeature(
+                        "http://xml.org/sax/features/validation",
+                        true);
+                // Enable schema validation
+                factory.setFeature(
+                        "http://apache.org/xml/features/validation/schema",
+                        true);
+            }
 
-        return saxParser;
+            // Configure the parser
+            SAXParser saxParser = factory.newSAXParser();
+            XMLReader xmlReader = saxParser.getXMLReader();
+            xmlReader.setProperty(LEXICAL_HANDLER_PROPERTY, jspDocParser);
+            xmlReader.setErrorHandler(jspDocParser);
+
+            return saxParser;
+        } finally {
+            if (Constants.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa = new PrivilegedSetTccl(original);
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(original);
+            }
+        }
     }
 
     /*
diff --git a/res/checkstyle/org-import-control.xml b/res/checkstyle/org-import-control.xml
index 40094ee64877..ca96156f9a86 100644
--- a/res/checkstyle/org-import-control.xml
+++ b/res/checkstyle/org-import-control.xml
@@ -102,6 +102,7 @@
     <allow pkg="org.apache.tomcat" exact-match="true"/>
     <allow pkg="org.apache.tomcat.util.descriptor"/>
     <allow pkg="org.apache.tomcat.util.scan"/>
+    <allow pkg="org.apache.tomcat.util.security"/>
     <allow pkg="org.apache.tools.ant"/>
     <allow pkg="org.eclipse.jdt"/>
   </subpackage>
diff --git a/webapps/docs/changelog.xml b/webapps/docs/changelog.xml
index 2423496b6bd7..7aa6c9bab579 100644
--- a/webapps/docs/changelog.xml
+++ b/webapps/docs/changelog.xml
@@ -131,6 +131,11 @@
         patterns of the form <code>*.a.b</code> which are not valid patterns for
         extension mappings. (markt)
       </add>
+      <add>
+        Extend XML factory, parser etc. memory leak protection to cover some
+        additional locations where, theoretically, a memory leak could occur.
+        (markt)
+      </add>
     </changelog>
   </subsection>
   <subsection name="Coyote">",
"url": "https://github.com/apache/tomcat/commit/769477b9bc8442db3f571385fa0c3e206242cbf1.patch"
},
{
"commit_message": "[PATCH] Defensive coding around some XML activities that are triggered by web applications and are therefore at potential risk of a memory leak. git-svn-id: https://svn.apache.org/repos/asf/tomcat/tc7.0.x/trunk@1590028 13f79535-47bb-0310-9956-ffa450edef68 .../catalina/servlets/DefaultServlet.java | 30 +++++++- .../jasper/compiler/JspDocumentParser.java | 74 +++++++++++++------ webapps/docs/changelog.xml | 5 ++ 3 files changed, 84 insertions(+), 25 deletions(-)",
"patch_text_b64": "From 934f884f330dad192d2c5dc950e28f4cd281461b Mon Sep 17 00:00:00 2001
From: Mark Emlyn David Thomas <markt@apache.org>
Date: Fri, 25 Apr 2014 13:49:02 +0000
Subject: [PATCH] Defensive coding around some XML activities that are
 triggered by web applications and are therefore at potential risk of a memory
 leak.

git-svn-id: https://svn.apache.org/repos/asf/tomcat/tc7.0.x/trunk@1590028 13f79535-47bb-0310-9956-ffa450edef68
---
 .../catalina/servlets/DefaultServlet.java     | 30 +++++++-
 .../jasper/compiler/JspDocumentParser.java    | 74 +++++++++++++------
 webapps/docs/changelog.xml                    |  5 ++
 3 files changed, 84 insertions(+), 25 deletions(-)

diff --git a/java/org/apache/catalina/servlets/DefaultServlet.java b/java/org/apache/catalina/servlets/DefaultServlet.java
index 14feeea160bb..62f56d2f1af9 100644
--- a/java/org/apache/catalina/servlets/DefaultServlet.java
+++ b/java/org/apache/catalina/servlets/DefaultServlet.java
@@ -32,6 +32,7 @@
 import java.io.Reader;
 import java.io.StringReader;
 import java.io.StringWriter;
+import java.security.AccessController;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.Locale;
@@ -74,6 +75,8 @@
 import org.apache.naming.resources.Resource;
 import org.apache.naming.resources.ResourceAttributes;
 import org.apache.tomcat.util.res.StringManager;
+import org.apache.tomcat.util.security.PrivilegedGetTccl;
+import org.apache.tomcat.util.security.PrivilegedSetTccl;
 import org.w3c.dom.Document;
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
@@ -1367,11 +1370,27 @@ protected InputStream renderXml(String contextPath,
             sb.append("]]></readme>");
         }
 
-
         sb.append("</listing>");
 
-
+        // Prevent possible memory leak. Ensure Transformer and
+        // TransformerFactory are not loaded from the web application.
+        ClassLoader original;
+        if (Globals.IS_SECURITY_ENABLED) {
+            PrivilegedGetTccl pa = new PrivilegedGetTccl();
+            original = AccessController.doPrivileged(pa);
+        } else {
+            original = Thread.currentThread().getContextClassLoader();
+        }
         try {
+            if (Globals.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa =
+                        new PrivilegedSetTccl(DefaultServlet.class.getClassLoader());
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(
+                        DefaultServlet.class.getClassLoader());
+            }
+
             TransformerFactory tFactory = TransformerFactory.newInstance();
             Source xmlSource = new StreamSource(new StringReader(sb.toString()));
             Transformer transformer = tFactory.newTransformer(xsltSource);
@@ -1384,6 +1403,13 @@ protected InputStream renderXml(String contextPath,
             return (new ByteArrayInputStream(stream.toByteArray()));
         } catch (TransformerException e) {
             throw new ServletException("XSL transformer error", e);
+        } finally {
+            if (Globals.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa = new PrivilegedSetTccl(original);
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(original);
+            }
         }
     }
 
diff --git a/java/org/apache/jasper/compiler/JspDocumentParser.java b/java/org/apache/jasper/compiler/JspDocumentParser.java
index ad8439f6ac5d..f3ccb798fa0c 100644
--- a/java/org/apache/jasper/compiler/JspDocumentParser.java
+++ b/java/org/apache/jasper/compiler/JspDocumentParser.java
@@ -20,6 +20,7 @@
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
+import java.security.AccessController;
 import java.util.Iterator;
 import java.util.List;
 import java.util.jar.JarFile;
@@ -35,6 +36,8 @@
 import org.apache.jasper.JspCompilationContext;
 import org.apache.tomcat.util.descriptor.DigesterFactory;
 import org.apache.tomcat.util.descriptor.LocalResolver;
+import org.apache.tomcat.util.security.PrivilegedGetTccl;
+import org.apache.tomcat.util.security.PrivilegedSetTccl;
 import org.xml.sax.Attributes;
 import org.xml.sax.InputSource;
 import org.xml.sax.Locator;
@@ -1464,33 +1467,58 @@ private static SAXParser getSAXParser(
         JspDocumentParser jspDocParser)
         throws Exception {
 
-        SAXParserFactory factory = SAXParserFactory.newInstance();
+        ClassLoader original;
+        if (Constants.IS_SECURITY_ENABLED) {
+            PrivilegedGetTccl pa = new PrivilegedGetTccl();
+            original = AccessController.doPrivileged(pa);
+        } else {
+            original = Thread.currentThread().getContextClassLoader();
+        }
+        try {
+            if (Constants.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa =
+                        new PrivilegedSetTccl(JspDocumentParser.class.getClassLoader());
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(
+                        JspDocumentParser.class.getClassLoader());
+            }
 
-        factory.setNamespaceAware(true);
-        // Preserve xmlns attributes
-        factory.setFeature(
-            "http://xml.org/sax/features/namespace-prefixes",
-            true);
+            SAXParserFactory factory = SAXParserFactory.newInstance();
 
-        factory.setValidating(validating);
-        if (validating) {
-            // Enable DTD validation
-            factory.setFeature(
-                    "http://xml.org/sax/features/validation",
-                    true);
-            // Enable schema validation
+            factory.setNamespaceAware(true);
+            // Preserve xmlns attributes
             factory.setFeature(
-                    "http://apache.org/xml/features/validation/schema",
-                    true);
-        }
-
-        // Configure the parser
-        SAXParser saxParser = factory.newSAXParser();
-        XMLReader xmlReader = saxParser.getXMLReader();
-        xmlReader.setProperty(LEXICAL_HANDLER_PROPERTY, jspDocParser);
-        xmlReader.setErrorHandler(jspDocParser);
+                "http://xml.org/sax/features/namespace-prefixes",
+                true);
+
+            factory.setValidating(validating);
+            if (validating) {
+                // Enable DTD validation
+                factory.setFeature(
+                        "http://xml.org/sax/features/validation",
+                        true);
+                // Enable schema validation
+                factory.setFeature(
+                        "http://apache.org/xml/features/validation/schema",
+                        true);
+            }
 
-        return saxParser;
+            // Configure the parser
+            SAXParser saxParser = factory.newSAXParser();
+            XMLReader xmlReader = saxParser.getXMLReader();
+            xmlReader.setProperty(LEXICAL_HANDLER_PROPERTY, jspDocParser);
+            xmlReader.setErrorHandler(jspDocParser);
+
+            return saxParser;
+        } finally {
+            if (Constants.IS_SECURITY_ENABLED) {
+                PrivilegedSetTccl pa = new PrivilegedSetTccl(original);
+                AccessController.doPrivileged(pa);
+            } else {
+                Thread.currentThread().setContextClassLoader(original);
+            }
+        }
     }
 
     /*
diff --git a/webapps/docs/changelog.xml b/webapps/docs/changelog.xml
index 25b9810dc317..c91b872afcf9 100644
--- a/webapps/docs/changelog.xml
+++ b/webapps/docs/changelog.xml
@@ -116,6 +116,11 @@
         patterns of the form <code>*.a.b</code> which are not valid patterns for
         extension mappings. (markt)
       </add>
+      <add>
+        Extend XML factory, parser etc. memory leak protection to cover some
+        additional locations where, theoretically, a memory leak could occur.
+        (markt)
+      </add>
     </changelog>
   </subsection>
   <subsection name="Coyote">",
"url": "https://github.com/apache/tomcat/commit/934f884f330dad192d2c5dc950e28f4cd281461b.patch"
},
{
"commit_message": "[PATCH] Fix indents and copy/paste errors git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1589983 13f79535-47bb-0310-9956-ffa450edef68 java/org/apache/jasper/compiler/TagPluginManager.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/tomcat/commit/ad3b34a290a0255d2a4c356a3611ab41ed9d04f5.patch"
},
{
"commit_message": "[PATCH] Small optimisation. The resolver and the factory are only used when running under a security manager so only load them in this case. Also avoid a possible memory leak when creating these objects. git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1588193 13f79535-47bb-0310-9956-ffa450edef68 .../catalina/security/SecurityClassLoad.java | 13 +++++++++++++ .../apache/catalina/servlets/DefaultServlet.java | 15 ++++++++++----- 2 files changed, 23 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/tomcat/commit/ce70ee6b8fe437a498a375215011056702b0c481.patch"
}
] | null |
GHSA-w392-75q8-vr67
|
Guardrails has an arbitrary code execution vulnerability
| null |
[
{
"commit_message": "[PATCH] safe eval guardrails/utils/validator_utils.py | 3 ++- tests/unit_tests/test_datatypes.py | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/guardrails-ai/guardrails/commit/ab12701e8c3ef41273ff9b3912f2e4e28ae8306f.patch"
}
] | null |
CVE-2025-55150
|
Stirling-PDF SSRF vulnerability on /api/v1/convert/html/pdf
|
Stirling-PDF is a locally hosted web application that performs various operations on PDF files. Prior to version 1.1.0, when using the /api/v1/convert/html/pdf endpoint to convert HTML to PDF, the backend calls a third-party tool to process it and includes a sanitizer for security sanitization which can be bypassed and result in SSRF. This issue has been patched in version 1.1.0.
|
[
{
"commit_message": "[PATCH] url fixes for access issues (#4013) # Description of Changes This pull request introduces a new SSRF (Server-Side Request Forgery) protection mechanism for URL handling in the application. Key changes include adding a dedicated `SsrfProtectionService`, integrating SSRF-safe policies into HTML sanitization, and extending application settings to support configurable URL security options. ### SSRF Protection Implementation: * **`SsrfProtectionService`**: Added a new service to handle SSRF protection with configurable levels (`OFF`, `MEDIUM`, `MAX`) and checks for private networks, localhost, link-local addresses, and cloud metadata endpoints (`app/common/src/main/java/stirling/software/common/service/SsrfProtectionService.java`). ### Application Configuration Enhancements: * **`ApplicationProperties`**: Introduced a new `Html` configuration class with nested `UrlSecurity` settings, allowing fine-grained control over URL security, including allowed/blocked domains and internal TLDs (`app/common/src/main/java/stirling/software/common/model/ApplicationProperties.java`). [[1]](diffhunk://#diff-1c357db0a3e88cf5bedd4a5852415fadad83b8b3b9eb56e67059d8b9d8b10702R293) [[2]](diffhunk://#diff-1c357db0a3e88cf5bedd4a5852415fadad83b8b3b9eb56e67059d8b9d8b10702R346-R364) * **`settings.yml.template`**: Updated the configuration template to include the new `html.urlSecurity` settings, enabling users to customize SSRF protection behavior (`app/core/src/main/resources/settings.yml.template`). ### HTML Sanitization Updates: * **`CustomHtmlSanitizer`**: Integrated SSRF-safe URL validation into the HTML sanitizer by using the `SsrfProtectionService`. Added a custom policy for validating `img` tags' `src` attributes (`app/common/src/main/java/stirling/software/common/util/CustomHtmlSanitizer.java`). ## Checklist ### General - [ ] I have read the [Contribution Guidelines](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/CONTRIBUTING.md) - [ ] I have read the [Stirling-PDF Developer Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/DeveloperGuide.md) (if applicable) - [ ] I have read the [How to add new languages to Stirling-PDF](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/HowToAddNewLanguage.md) (if applicable) - [ ] I have performed a self-review of my own code - [ ] My changes generate no new warnings ### Documentation - [ ] I have updated relevant docs on [Stirling-PDF's doc repo](https://github.com/Stirling-Tools/Stirling-Tools.github.io/blob/main/docs/) (if functionality has heavily changed) - [ ] I have read the section [Add New Translation Tags](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/HowToAddNewLanguage.md#add-new-translation-tags) (for new translation tags only) ### UI Changes (if applicable) - [ ] Screenshots or videos demonstrating the UI changes are attached (e.g., as comments or direct attachments in the PR) ### Testing (if applicable) - [ ] I have tested my changes locally. Refer to the [Testing Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/DeveloperGuide.md#6-testing) for more details. Co-authored-by: a <a> Co-authored-by: pixeebot[bot] <104101892+pixeebot[bot]@users.noreply.github.com> Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> .../common/model/ApplicationProperties.java | 20 ++ .../common/service/SsrfProtectionService.java | 208 ++++++++++++++++++ .../common/util/CustomHtmlSanitizer.java | 60 ++++- .../software/common/util/EmlToPdf.java | 22 +- .../software/common/util/FileToPdf.java | 21 +- .../common/util/CustomHtmlSanitizerTest.java | 53 +++-- .../software/common/util/EmlToPdfTest.java | 63 ++++-- .../software/common/util/FileToPdfTest.java | 25 ++- .../api/converters/ConvertEmlToPDF.java | 6 +- .../api/converters/ConvertHtmlToPDF.java | 13 +- .../api/converters/ConvertMarkdownToPdf.java | 13 +- .../converters/ConvertOfficeController.java | 15 +- .../src/main/resources/settings.yml.template | 11 + testing/allEndpointsRemovedSettings.yml | 16 +- 14 files changed, 462 insertions(+), 84 deletions(-) create mode 100644 app/common/src/main/java/stirling/software/common/service/SsrfProtectionService.java",
"patch_text_b64": "From 7d6b70871bad2a3ff810825f7382c49f55293943 Mon Sep 17 00:00:00 2001
From: Anthony Stirling <77850077+Frooodle@users.noreply.github.com>
Date: Thu, 24 Jul 2025 13:53:21 +0100
Subject: [PATCH] url fixes for access issues (#4013)

# Description of Changes


This pull request introduces a new SSRF (Server-Side Request Forgery)
protection mechanism for URL handling in the application. Key changes
include adding a dedicated `SsrfProtectionService`, integrating
SSRF-safe policies into HTML sanitization, and extending application
settings to support configurable URL security options.

### SSRF Protection Implementation:
* **`SsrfProtectionService`**: Added a new service to handle SSRF
protection with configurable levels (`OFF`, `MEDIUM`, `MAX`) and checks
for private networks, localhost, link-local addresses, and cloud
metadata endpoints
(`app/common/src/main/java/stirling/software/common/service/SsrfProtectionService.java`).

### Application Configuration Enhancements:
* **`ApplicationProperties`**: Introduced a new `Html` configuration
class with nested `UrlSecurity` settings, allowing fine-grained control
over URL security, including allowed/blocked domains and internal TLDs
(`app/common/src/main/java/stirling/software/common/model/ApplicationProperties.java`).
[[1]](diffhunk://#diff-1c357db0a3e88cf5bedd4a5852415fadad83b8b3b9eb56e67059d8b9d8b10702R293)
[[2]](diffhunk://#diff-1c357db0a3e88cf5bedd4a5852415fadad83b8b3b9eb56e67059d8b9d8b10702R346-R364)
* **`settings.yml.template`**: Updated the configuration template to
include the new `html.urlSecurity` settings, enabling users to customize
SSRF protection behavior
(`app/core/src/main/resources/settings.yml.template`).

### HTML Sanitization Updates:
* **`CustomHtmlSanitizer`**: Integrated SSRF-safe URL validation into
the HTML sanitizer by using the `SsrfProtectionService`. Added a custom
policy for validating `img` tags' `src` attributes
(`app/common/src/main/java/stirling/software/common/util/CustomHtmlSanitizer.java`).

---

## Checklist

### General

- [ ] I have read the [Contribution
Guidelines](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/CONTRIBUTING.md)
- [ ] I have read the [Stirling-PDF Developer
Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/DeveloperGuide.md)
(if applicable)
- [ ] I have read the [How to add new languages to
Stirling-PDF](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/HowToAddNewLanguage.md)
(if applicable)
- [ ] I have performed a self-review of my own code
- [ ] My changes generate no new warnings

### Documentation

- [ ] I have updated relevant docs on [Stirling-PDF's doc
repo](https://github.com/Stirling-Tools/Stirling-Tools.github.io/blob/main/docs/)
(if functionality has heavily changed)
- [ ] I have read the section [Add New Translation
Tags](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/HowToAddNewLanguage.md#add-new-translation-tags)
(for new translation tags only)

### UI Changes (if applicable)

- [ ] Screenshots or videos demonstrating the UI changes are attached
(e.g., as comments or direct attachments in the PR)

### Testing (if applicable)

- [ ] I have tested my changes locally. Refer to the [Testing
Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/DeveloperGuide.md#6-testing)
for more details.

---------

Co-authored-by: a <a>
Co-authored-by: pixeebot[bot] <104101892+pixeebot[bot]@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 .../common/model/ApplicationProperties.java   |  20 ++
 .../common/service/SsrfProtectionService.java | 208 ++++++++++++++++++
 .../common/util/CustomHtmlSanitizer.java      |  60 ++++-
 .../software/common/util/EmlToPdf.java        |  22 +-
 .../software/common/util/FileToPdf.java       |  21 +-
 .../common/util/CustomHtmlSanitizerTest.java  |  53 +++--
 .../software/common/util/EmlToPdfTest.java    |  63 ++++--
 .../software/common/util/FileToPdfTest.java   |  25 ++-
 .../api/converters/ConvertEmlToPDF.java       |   6 +-
 .../api/converters/ConvertHtmlToPDF.java      |  13 +-
 .../api/converters/ConvertMarkdownToPdf.java  |  13 +-
 .../converters/ConvertOfficeController.java   |  15 +-
 .../src/main/resources/settings.yml.template  |  11 +
 testing/allEndpointsRemovedSettings.yml       |  16 +-
 14 files changed, 462 insertions(+), 84 deletions(-)
 create mode 100644 app/common/src/main/java/stirling/software/common/service/SsrfProtectionService.java

diff --git a/app/common/src/main/java/stirling/software/common/model/ApplicationProperties.java b/app/common/src/main/java/stirling/software/common/model/ApplicationProperties.java
index e4edf2baa67..91b32875927 100644
--- a/app/common/src/main/java/stirling/software/common/model/ApplicationProperties.java
+++ b/app/common/src/main/java/stirling/software/common/model/ApplicationProperties.java
@@ -290,6 +290,7 @@ public static class System {
         private Datasource datasource;
         private Boolean disableSanitize;
         private Boolean enableUrlToPDF;
+        private Html html = new Html();
         private CustomPaths customPaths = new CustomPaths();
         private String fileUploadLimit;
         private TempFileManagement tempFileManagement = new TempFileManagement();
@@ -342,6 +343,25 @@ public String getLibreofficeDir() {
         }
     }
 
+    @Data
+    public static class Html {
+        private UrlSecurity urlSecurity = new UrlSecurity();
+
+        @Data
+        public static class UrlSecurity {
+            private boolean enabled = true;
+            private String level = "MEDIUM"; // MAX, MEDIUM, OFF
+            private List<String> allowedDomains = new ArrayList<>();
+            private List<String> blockedDomains = new ArrayList<>();
+            private List<String> internalTlds =
+                    Arrays.asList(".local", ".internal", ".corp", ".home");
+            private boolean blockPrivateNetworks = true;
+            private boolean blockLocalhost = true;
+            private boolean blockLinkLocal = true;
+            private boolean blockCloudMetadata = true;
+        }
+    }
+
     @Data
     public static class Datasource {
         private boolean enableCustomDatabase;
diff --git a/app/common/src/main/java/stirling/software/common/service/SsrfProtectionService.java b/app/common/src/main/java/stirling/software/common/service/SsrfProtectionService.java
new file mode 100644
index 00000000000..97c2da12eb5
--- /dev/null
+++ b/app/common/src/main/java/stirling/software/common/service/SsrfProtectionService.java
@@ -0,0 +1,208 @@
+package stirling.software.common.service;
+
+import java.net.InetAddress;
+import java.net.URI;
+import java.net.UnknownHostException;
+import java.util.regex.Pattern;
+
+import org.springframework.stereotype.Service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import stirling.software.common.model.ApplicationProperties;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class SsrfProtectionService {
+
+    private final ApplicationProperties applicationProperties;
+
+    private static final Pattern DATA_URL_PATTERN =
+            Pattern.compile("^data:.*", Pattern.CASE_INSENSITIVE);
+    private static final Pattern FRAGMENT_PATTERN = Pattern.compile("^#.*");
+
+    public enum SsrfProtectionLevel {
+        OFF, // No SSRF protection - allows all URLs
+        MEDIUM, // Block internal networks but allow external URLs
+        MAX // Block all external URLs - only data: and fragments
+    }
+
+    public boolean isUrlAllowed(String url) {
+        ApplicationProperties.Html.UrlSecurity config =
+                applicationProperties.getSystem().getHtml().getUrlSecurity();
+
+        if (!config.isEnabled()) {
+            return true;
+        }
+
+        if (url == null || url.trim().isEmpty()) {
+            return false;
+        }
+
+        String trimmedUrl = url.trim();
+
+        // Always allow data URLs and fragments
+        if (DATA_URL_PATTERN.matcher(trimmedUrl).matches()
+                || FRAGMENT_PATTERN.matcher(trimmedUrl).matches()) {
+            return true;
+        }
+
+        SsrfProtectionLevel level = parseProtectionLevel(config.getLevel());
+
+        switch (level) {
+            case OFF:
+                return true;
+            case MAX:
+                return isMaxSecurityAllowed(trimmedUrl, config);
+            case MEDIUM:
+                return isMediumSecurityAllowed(trimmedUrl, config);
+            default:
+                return false;
+        }
+    }
+
+    private SsrfProtectionLevel parseProtectionLevel(String level) {
+        try {
+            return SsrfProtectionLevel.valueOf(level.toUpperCase());
+        } catch (IllegalArgumentException e) {
+            log.warn("Invalid SSRF protection level '{}', defaulting to MEDIUM", level);
+            return SsrfProtectionLevel.MEDIUM;
+        }
+    }
+
+    private boolean isMaxSecurityAllowed(
+            String url, ApplicationProperties.Html.UrlSecurity config) {
+        // MAX security: only allow explicitly whitelisted domains
+        try {
+            URI uri = new URI(url);
+            String host = uri.getHost();
+
+            if (host == null) {
+                return false;
+            }
+
+            return config.getAllowedDomains().contains(host.toLowerCase());
+
+        } catch (Exception e) {
+            log.debug("Failed to parse URL for MAX security check: {}", url, e);
+            return false;
+        }
+    }
+
+    private boolean isMediumSecurityAllowed(
+            String url, ApplicationProperties.Html.UrlSecurity config) {
+        try {
+            URI uri = new URI(url);
+            String host = uri.getHost();
+
+            if (host == null) {
+                return false;
+            }
+
+            String hostLower = host.toLowerCase();
+
+            // Check explicit blocked domains
+            if (config.getBlockedDomains().contains(hostLower)) {
+                log.debug("URL blocked by explicit domain blocklist: {}", url);
+                return false;
+            }
+
+            // Check internal TLD patterns
+            for (String tld : config.getInternalTlds()) {
+                if (hostLower.endsWith(tld.toLowerCase())) {
+                    log.debug("URL blocked by internal TLD pattern '{}': {}", tld, url);
+                    return false;
+                }
+            }
+
+            // If allowedDomains is specified, only allow those
+            if (!config.getAllowedDomains().isEmpty()) {
+                boolean isAllowed =
+                        config.getAllowedDomains().stream()
+                                .anyMatch(
+                                        domain ->
+                                                hostLower.equals(domain.toLowerCase())
+                                                        || hostLower.endsWith(
+                                                                "." + domain.toLowerCase()));
+
+                if (!isAllowed) {
+                    log.debug("URL not in allowed domains list: {}", url);
+                    return false;
+                }
+            }
+
+            // Resolve hostname to IP address for network-based checks
+            try {
+                InetAddress address = InetAddress.getByName(host);
+
+                if (config.isBlockPrivateNetworks() && isPrivateAddress(address)) {
+                    log.debug("URL blocked - private network address: {}", url);
+                    return false;
+                }
+
+                if (config.isBlockLocalhost() && address.isLoopbackAddress()) {
+                    log.debug("URL blocked - localhost address: {}", url);
+                    return false;
+                }
+
+                if (config.isBlockLinkLocal() && address.isLinkLocalAddress()) {
+                    log.debug("URL blocked - link-local address: {}", url);
+                    return false;
+                }
+
+                if (config.isBlockCloudMetadata()
+                        && isCloudMetadataAddress(address.getHostAddress())) {
+                    log.debug("URL blocked - cloud metadata endpoint: {}", url);
+                    return false;
+                }
+
+            } catch (UnknownHostException e) {
+                log.debug("Failed to resolve hostname for SSRF check: {}", host, e);
+                return false;
+            }
+
+            return true;
+
+        } catch (Exception e) {
+            log.debug("Failed to parse URL for MEDIUM security check: {}", url, e);
+            return false;
+        }
+    }
+
+    private boolean isPrivateAddress(InetAddress address) {
+        return address.isSiteLocalAddress()
+                || address.isAnyLocalAddress()
+                || isPrivateIPv4Range(address.getHostAddress());
+    }
+
+    private boolean isPrivateIPv4Range(String ip) {
+        return ip.startsWith("10.")
+                || ip.startsWith("192.168.")
+                || (ip.startsWith("172.") && isInRange172(ip))
+                || ip.startsWith("127.")
+                || "0.0.0.0".equals(ip);
+    }
+
+    private boolean isInRange172(String ip) {
+        String[] parts = ip.split("\\.");
+        if (parts.length >= 2) {
+            try {
+                int secondOctet = Integer.parseInt(parts[1]);
+                return secondOctet >= 16 && secondOctet <= 31;
+            } catch (NumberFormatException e) {
+                return false;
+            }
+        }
+        return false;
+    }
+
+    private boolean isCloudMetadataAddress(String ip) {
+        // Cloud metadata endpoints for AWS, GCP, Azure, Oracle Cloud, and IBM Cloud
+        return ip.startsWith("169.254.169.254") // AWS/GCP/Azure
+                || ip.startsWith("fd00:ec2::254") // AWS IPv6
+                || ip.startsWith("169.254.169.253") // Oracle Cloud
+                || ip.startsWith("169.254.169.250"); // IBM Cloud
+    }
+}
diff --git a/app/common/src/main/java/stirling/software/common/util/CustomHtmlSanitizer.java b/app/common/src/main/java/stirling/software/common/util/CustomHtmlSanitizer.java
index e5fe0436a6c..05d9b73a613 100644
--- a/app/common/src/main/java/stirling/software/common/util/CustomHtmlSanitizer.java
+++ b/app/common/src/main/java/stirling/software/common/util/CustomHtmlSanitizer.java
@@ -1,21 +1,71 @@
 package stirling.software.common.util;
 
+import org.owasp.html.AttributePolicy;
 import org.owasp.html.HtmlPolicyBuilder;
 import org.owasp.html.PolicyFactory;
 import org.owasp.html.Sanitizers;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
 
+import stirling.software.common.model.ApplicationProperties;
+import stirling.software.common.service.SsrfProtectionService;
+
+@Component
 public class CustomHtmlSanitizer {
-    private static final PolicyFactory POLICY =
+
+    private final SsrfProtectionService ssrfProtectionService;
+    private final ApplicationProperties applicationProperties;
+
+    @Autowired
+    public CustomHtmlSanitizer(
+            SsrfProtectionService ssrfProtectionService,
+            ApplicationProperties applicationProperties) {
+        this.ssrfProtectionService = ssrfProtectionService;
+        this.applicationProperties = applicationProperties;
+    }
+
+    private final AttributePolicy SSRF_SAFE_URL_POLICY =
+            new AttributePolicy() {
+                @Override
+                public String apply(String elementName, String attributeName, String value) {
+                    if (value == null || value.trim().isEmpty()) {
+                        return null;
+                    }
+
+                    String trimmedValue = value.trim();
+
+                    // Use the SSRF protection service to validate the URL
+                    if (ssrfProtectionService != null
+                            && !ssrfProtectionService.isUrlAllowed(trimmedValue)) {
+                        return null;
+                    }
+
+                    return trimmedValue;
+                }
+            };
+
+    private final PolicyFactory SSRF_SAFE_IMAGES_POLICY =
+            new HtmlPolicyBuilder()
+                    .allowElements("img")
+                    .allowAttributes("alt", "width", "height", "title")
+                    .onElements("img")
+                    .allowAttributes("src")
+                    .matching(SSRF_SAFE_URL_POLICY)
+                    .onElements("img")
+                    .toFactory();
+
+    private final PolicyFactory POLICY =
             Sanitizers.FORMATTING
                     .and(Sanitizers.BLOCKS)
                     .and(Sanitizers.STYLES)
                     .and(Sanitizers.LINKS)
                     .and(Sanitizers.TABLES)
-                    .and(Sanitizers.IMAGES)
+                    .and(SSRF_SAFE_IMAGES_POLICY)
                     .and(new HtmlPolicyBuilder().disallowElements("noscript").toFactory());
 
-    public static String sanitize(String html) {
-        String htmlAfter = POLICY.sanitize(html);
-        return htmlAfter;
+    public String sanitize(String html) {
+        boolean disableSanitize =
+                Boolean.TRUE.equals(applicationProperties.getSystem().getDisableSanitize());
+        return disableSanitize ? html : POLICY.sanitize(html);
     }
 }
diff --git a/app/common/src/main/java/stirling/software/common/util/EmlToPdf.java b/app/common/src/main/java/stirling/software/common/util/EmlToPdf.java
index 05e9cec5cc6..6b28dc6839b 100644
--- a/app/common/src/main/java/stirling/software/common/util/EmlToPdf.java
+++ b/app/common/src/main/java/stirling/software/common/util/EmlToPdf.java
@@ -133,9 +133,9 @@ public static byte[] convertEmlToPdf(
             EmlToPdfRequest request,
             byte[] emlBytes,
             String fileName,
-            boolean disableSanitize,
             stirling.software.common.service.CustomPDFDocumentFactory pdfDocumentFactory,
-            TempFileManager tempFileManager)
+            TempFileManager tempFileManager,
+            CustomHtmlSanitizer customHtmlSanitizer)
             throws IOException, InterruptedException {
 
         validateEmlInput(emlBytes);
@@ -155,7 +155,11 @@ public static byte[] convertEmlToPdf(
             // Convert HTML to PDF
             byte[] pdfBytes =
                     convertHtmlToPdf(
-                            weasyprintPath, request, htmlContent, disableSanitize, tempFileManager);
+                            weasyprintPath,
+                            request,
+                            htmlContent,
+                            tempFileManager,
+                            customHtmlSanitizer);
 
             // Attach files if available and requested
             if (shouldAttachFiles(emailContent, request)) {
@@ -196,8 +200,8 @@ private static byte[] convertHtmlToPdf(
             String weasyprintPath,
             EmlToPdfRequest request,
             String htmlContent,
-            boolean disableSanitize,
-            TempFileManager tempFileManager)
+            TempFileManager tempFileManager,
+            CustomHtmlSanitizer customHtmlSanitizer)
             throws IOException, InterruptedException {
 
         HTMLToPdfRequest htmlRequest = createHtmlRequest(request);
@@ -208,8 +212,8 @@ private static byte[] convertHtmlToPdf(
                     htmlRequest,
                     htmlContent.getBytes(StandardCharsets.UTF_8),
                     "email.html",
-                    disableSanitize,
-                    tempFileManager);
+                    tempFileManager,
+                    customHtmlSanitizer);
         } catch (IOException | InterruptedException e) {
             log.warn("Initial HTML to PDF conversion failed, trying with simplified HTML");
             String simplifiedHtml = simplifyHtmlContent(htmlContent);
@@ -218,8 +222,8 @@ private static byte[] convertHtmlToPdf(
                     htmlRequest,
                     simplifiedHtml.getBytes(StandardCharsets.UTF_8),
                     "email.html",
-                    disableSanitize,
-                    tempFileManager);
+                    tempFileManager,
+                    customHtmlSanitizer);
         }
     }
 
diff --git a/app/common/src/main/java/stirling/software/common/util/FileToPdf.java b/app/common/src/main/java/stirling/software/common/util/FileToPdf.java
index c735e5287cf..799f91e050c 100644
--- a/app/common/src/main/java/stirling/software/common/util/FileToPdf.java
+++ b/app/common/src/main/java/stirling/software/common/util/FileToPdf.java
@@ -26,8 +26,8 @@ public static byte[] convertHtmlToPdf(
             HTMLToPdfRequest request,
             byte[] fileBytes,
             String fileName,
-            boolean disableSanitize,
-            TempFileManager tempFileManager)
+            TempFileManager tempFileManager,
+            CustomHtmlSanitizer customHtmlSanitizer)
             throws IOException, InterruptedException {
 
         try (TempFile tempOutputFile = new TempFile(tempFileManager, ".pdf")) {
@@ -39,14 +39,15 @@ public static byte[] convertHtmlToPdf(
                 if (fileName.toLowerCase().endsWith(".html")) {
                     String sanitizedHtml =
                             sanitizeHtmlContent(
-                                    new String(fileBytes, StandardCharsets.UTF_8), disableSanitize);
+                                    new String(fileBytes, StandardCharsets.UTF_8),
+                                    customHtmlSanitizer);
                     Files.write(
                             tempInputFile.getPath(),
                             sanitizedHtml.getBytes(StandardCharsets.UTF_8));
                 } else if (fileName.toLowerCase().endsWith(".zip")) {
                     Files.write(tempInputFile.getPath(), fileBytes);
                     sanitizeHtmlFilesInZip(
-                            tempInputFile.getPath(), disableSanitize, tempFileManager);
+                            tempInputFile.getPath(), tempFileManager, customHtmlSanitizer);
                 } else {
                     throw ExceptionUtils.createHtmlFileRequiredException();
                 }
@@ -78,12 +79,15 @@ public static byte[] convertHtmlToPdf(
         } // tempOutputFile auto-closed
     }
 
-    private static String sanitizeHtmlContent(String htmlContent, boolean disableSanitize) {
-        return (!disableSanitize) ? CustomHtmlSanitizer.sanitize(htmlContent) : htmlContent;
+    private static String sanitizeHtmlContent(
+            String htmlContent, CustomHtmlSanitizer customHtmlSanitizer) {
+        return customHtmlSanitizer.sanitize(htmlContent);
     }
 
     private static void sanitizeHtmlFilesInZip(
-            Path zipFilePath, boolean disableSanitize, TempFileManager tempFileManager)
+            Path zipFilePath,
+            TempFileManager tempFileManager,
+            CustomHtmlSanitizer customHtmlSanitizer)
             throws IOException {
         try (TempDirectory tempUnzippedDir = new TempDirectory(tempFileManager)) {
             try (ZipInputStream zipIn =
@@ -99,7 +103,8 @@ private static void sanitizeHtmlFilesInZip(
                                 || entry.getName().toLowerCase().endsWith(".htm")) {
                             String content =
                                     new String(zipIn.readAllBytes(), StandardCharsets.UTF_8);
-                            String sanitizedContent = sanitizeHtmlContent(content, disableSanitize);
+                            String sanitizedContent =
+                                    sanitizeHtmlContent(content, customHtmlSanitizer);
                             Files.write(
                                     filePath, sanitizedContent.getBytes(StandardCharsets.UTF_8));
                         } else {
diff --git a/app/common/src/test/java/stirling/software/common/util/CustomHtmlSanitizerTest.java b/app/common/src/test/java/stirling/software/common/util/CustomHtmlSanitizerTest.java
index 65bffe05e88..59e5f81b1e0 100644
--- a/app/common/src/test/java/stirling/software/common/util/CustomHtmlSanitizerTest.java
+++ b/app/common/src/test/java/stirling/software/common/util/CustomHtmlSanitizerTest.java
@@ -3,21 +3,42 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 import java.util.stream.Stream;
 
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import stirling.software.common.service.SsrfProtectionService;
+
 class CustomHtmlSanitizerTest {
 
+    private CustomHtmlSanitizer customHtmlSanitizer;
+
+    @BeforeEach
+    void setUp() {
+        SsrfProtectionService mockSsrfProtectionService = mock(SsrfProtectionService.class);
+        stirling.software.common.model.ApplicationProperties mockApplicationProperties = mock(stirling.software.common.model.ApplicationProperties.class);
+        stirling.software.common.model.ApplicationProperties.System mockSystem = mock(stirling.software.common.model.ApplicationProperties.System.class);
+        
+        // Allow all URLs by default for basic tests
+        when(mockSsrfProtectionService.isUrlAllowed(org.mockito.ArgumentMatchers.anyString())).thenReturn(true);
+        when(mockApplicationProperties.getSystem()).thenReturn(mockSystem);
+        when(mockSystem.getDisableSanitize()).thenReturn(false); // Enable sanitization for tests
+        
+        customHtmlSanitizer = new CustomHtmlSanitizer(mockSsrfProtectionService, mockApplicationProperties);
+    }
+
     @ParameterizedTest
     @MethodSource("provideHtmlTestCases")
     void testSanitizeHtml(String inputHtml, String[] expectedContainedTags) {
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(inputHtml);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(inputHtml);
 
         // Assert
         for (String tag : expectedContainedTags) {
@@ -58,7 +79,7 @@ void testSanitizeAllowsStyles() {
                 "<p style=\"color: blue; font-size: 16px; margin-top: 10px;\">Styled text</p>";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithStyles);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithStyles);
 
         // Assert
         // The OWASP HTML Sanitizer might filter some specific styles, so we only check that
@@ -75,7 +96,7 @@ void testSanitizeAllowsLinks() {
                 "<a href=\"https://example.com\" title=\"Example Site\">Example Link</a>";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithLink);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithLink);
 
         // Assert
         // The most important aspect is that the link content is preserved
@@ -97,7 +118,7 @@ void testSanitizeDisallowsJavaScriptLinks() {
         String htmlWithJsLink = "<a href=\"javascript:alert('XSS')\">Malicious Link</a>";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithJsLink);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithJsLink);
 
         // Assert
         assertFalse(sanitizedHtml.contains("javascript:"), "JavaScript URLs should be removed");
@@ -116,7 +137,7 @@ void testSanitizeAllowsTables() {
                         + "</table>";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithTable);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithTable);
 
         // Assert
         assertTrue(sanitizedHtml.contains("<table"), "Table should be preserved");
@@ -143,7 +164,7 @@ void testSanitizeAllowsImages() {
                 "<img src=\"image.jpg\" alt=\"An image\" width=\"100\" height=\"100\">";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithImage);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithImage);
 
         // Assert
         assertTrue(sanitizedHtml.contains("<img"), "Image tag should be preserved");
@@ -160,7 +181,7 @@ void testSanitizeDisallowsDataUrlImages() {
                 "<img src=\"data:image/svg+xml;base64,PHN2ZyBvbmxvYWQ9ImFsZXJ0KDEpIj48L3N2Zz4=\" alt=\"SVG with XSS\">";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithDataUrlImage);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithDataUrlImage);
 
         // Assert
         assertFalse(
@@ -175,7 +196,7 @@ void testSanitizeRemovesJavaScriptInAttributes() {
                 "<a href=\"#\" onclick=\"alert('XSS')\" onmouseover=\"alert('XSS')\">Click me</a>";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithJsEvent);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithJsEvent);
 
         // Assert
         assertFalse(
@@ -192,7 +213,7 @@ void testSanitizeRemovesScriptTags() {
         String htmlWithScript = "<p>Safe content</p><script>alert('XSS');</script>";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithScript);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithScript);
 
         // Assert
         assertFalse(sanitizedHtml.contains("<script>"), "Script tags should be removed");
@@ -206,7 +227,7 @@ void testSanitizeRemovesNoScriptTags() {
         String htmlWithNoscript = "<p>Safe content</p><noscript>JavaScript is disabled</noscript>";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithNoscript);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithNoscript);
 
         // Assert
         assertFalse(sanitizedHtml.contains("<noscript>"), "Noscript tags should be removed");
@@ -220,7 +241,7 @@ void testSanitizeRemovesIframes() {
         String htmlWithIframe = "<p>Safe content</p><iframe src=\"https://example.com\"></iframe>";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithIframe);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithIframe);
 
         // Assert
         assertFalse(sanitizedHtml.contains("<iframe"), "Iframe tags should be removed");
@@ -237,7 +258,7 @@ void testSanitizeRemovesObjectAndEmbed() {
                         + "<embed src=\"embed.swf\" type=\"application/x-shockwave-flash\">";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithObjects);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithObjects);
 
         // Assert
         assertFalse(sanitizedHtml.contains("<object"), "Object tags should be removed");
@@ -256,7 +277,7 @@ void testSanitizeRemovesMetaAndBaseAndLink() {
                         + "<link rel=\"stylesheet\" href=\"evil.css\">";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(htmlWithMetaTags);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(htmlWithMetaTags);
 
         // Assert
         assertFalse(sanitizedHtml.contains("<meta"), "Meta tags should be removed");
@@ -283,7 +304,7 @@ void testSanitizeHandlesComplexHtml() {
                         + "</div>";
 
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(complexHtml);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(complexHtml);
 
         // Assert
         assertTrue(sanitizedHtml.contains("<div"), "Div should be preserved");
@@ -314,7 +335,7 @@ void testSanitizeHandlesComplexHtml() {
     @Test
     void testSanitizeHandlesEmpty() {
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize("");
+        String sanitizedHtml = customHtmlSanitizer.sanitize("");
 
         // Assert
         assertEquals("", sanitizedHtml, "Empty input should result in empty string");
@@ -323,7 +344,7 @@ void testSanitizeHandlesEmpty() {
     @Test
     void testSanitizeHandlesNull() {
         // Act
-        String sanitizedHtml = CustomHtmlSanitizer.sanitize(null);
+        String sanitizedHtml = customHtmlSanitizer.sanitize(null);
 
         // Assert
         assertEquals("", sanitizedHtml, "Null input should result in empty string");
diff --git a/app/common/src/test/java/stirling/software/common/util/EmlToPdfTest.java b/app/common/src/test/java/stirling/software/common/util/EmlToPdfTest.java
index db7b0db7e18..5cb4f4a8163 100644
--- a/app/common/src/test/java/stirling/software/common/util/EmlToPdfTest.java
+++ b/app/common/src/test/java/stirling/software/common/util/EmlToPdfTest.java
@@ -13,6 +13,7 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -24,17 +25,36 @@
 import static org.mockito.ArgumentMatchers.anyString;
 import org.mockito.Mock;
 import org.mockito.MockedStatic;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 import org.mockito.junit.jupiter.MockitoExtension;
+import org.junit.jupiter.api.BeforeEach;
 
 import stirling.software.common.model.api.converters.EmlToPdfRequest;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.service.SsrfProtectionService;
+import stirling.software.common.util.CustomHtmlSanitizer;
 
 @DisplayName("EML to PDF Conversion tests")
 class EmlToPdfTest {
 
+    private CustomHtmlSanitizer customHtmlSanitizer;
+
+    @BeforeEach
+    void setUp() {
+        SsrfProtectionService mockSsrfProtectionService = mock(SsrfProtectionService.class);
+        stirling.software.common.model.ApplicationProperties mockApplicationProperties = mock(stirling.software.common.model.ApplicationProperties.class);
+        stirling.software.common.model.ApplicationProperties.System mockSystem = mock(stirling.software.common.model.ApplicationProperties.System.class);
+        
+        when(mockSsrfProtectionService.isUrlAllowed(org.mockito.ArgumentMatchers.anyString())).thenReturn(true);
+        when(mockApplicationProperties.getSystem()).thenReturn(mockSystem);
+        when(mockSystem.getDisableSanitize()).thenReturn(false);
+        
+        customHtmlSanitizer = new CustomHtmlSanitizer(mockSsrfProtectionService, mockApplicationProperties);
+    }
+
     // Focus on testing EML to HTML conversion functionality since the PDF conversion relies on WeasyPrint
     // But HTML to PDF conversion is also briefly tested at PdfConversionTests class.
     private void testEmailConversion(String emlContent, String[] expectedContent, boolean includeAttachments) throws IOException {
@@ -506,6 +526,7 @@ class PdfConversionTests {
         @Mock private TempFileManager mockTempFileManager;
 
         @Test
+        @Disabled("Complex static mocking - temporarily disabled while refactoring")
         @DisplayName("Should convert EML to PDF without attachments when not requested")
         void convertEmlToPdfWithoutAttachments() throws Exception {
             String emlContent =
@@ -523,7 +544,7 @@ void convertEmlToPdfWithoutAttachments() throws Exception {
             when(mockPdfDocumentFactory.load(any(byte[].class))).thenReturn(mockPdDocument);
             when(mockPdDocument.getNumberOfPages()).thenReturn(1);
 
-            try (MockedStatic<FileToPdf> fileToPdf = mockStatic(FileToPdf.class)) {
+            try (MockedStatic<FileToPdf> fileToPdf = mockStatic(FileToPdf.class, org.mockito.Mockito.withSettings().lenient())) {
                 fileToPdf
                     .when(
                         () ->
@@ -532,8 +553,8 @@ void convertEmlToPdfWithoutAttachments() throws Exception {
                                 any(),
                                 any(byte[].class),
                                 anyString(),
-                                anyBoolean(),
-                                any(TempFileManager.class)))
+                                any(TempFileManager.class),
+                                any(CustomHtmlSanitizer.class)))
                     .thenReturn(fakePdfBytes);
 
                 byte[] resultPdf =
@@ -542,9 +563,9 @@ void convertEmlToPdfWithoutAttachments() throws Exception {
                         request,
                         emlBytes,
                         "test.eml",
-                        false,
                         mockPdfDocumentFactory,
-                        mockTempFileManager);
+                        mockTempFileManager,
+                        customHtmlSanitizer);
 
                 assertArrayEquals(fakePdfBytes, resultPdf);
 
@@ -560,13 +581,14 @@ void convertEmlToPdfWithoutAttachments() throws Exception {
                             any(),
                             any(byte[].class),
                             anyString(),
-                            anyBoolean(),
-                            any(TempFileManager.class)));
+                            any(TempFileManager.class),
+                            any(CustomHtmlSanitizer.class)));
                 verify(mockPdfDocumentFactory).load(resultPdf);
             }
         }
 
         @Test
+        @Disabled("Complex static mocking - temporarily disabled while refactoring") 
         @DisplayName("Should convert EML to PDF with attachments when requested")
         void convertEmlToPdfWithAttachments() throws Exception {
             String boundary = "----=_Part_1234567890";
@@ -591,7 +613,7 @@ void convertEmlToPdfWithAttachments() throws Exception {
             when(mockPdfDocumentFactory.load(any(byte[].class))).thenReturn(mockPdDocument);
             when(mockPdDocument.getNumberOfPages()).thenReturn(1);
 
-            try (MockedStatic<FileToPdf> fileToPdf = mockStatic(FileToPdf.class)) {
+            try (MockedStatic<FileToPdf> fileToPdf = mockStatic(FileToPdf.class, org.mockito.Mockito.withSettings().lenient())) {
                 fileToPdf
                     .when(
                         () ->
@@ -600,8 +622,8 @@ void convertEmlToPdfWithAttachments() throws Exception {
                                 any(),
                                 any(byte[].class),
                                 anyString(),
-                                anyBoolean(),
-                                any(TempFileManager.class)))
+                                any(TempFileManager.class),
+                                any(CustomHtmlSanitizer.class)))
                     .thenReturn(fakePdfBytes);
 
                 try (MockedStatic<EmlToPdf> ignored =
@@ -621,9 +643,9 @@ void convertEmlToPdfWithAttachments() throws Exception {
                             request,
                             emlBytes,
                             "test.eml",
-                            false,
                             mockPdfDocumentFactory,
-                            mockTempFileManager);
+                            mockTempFileManager,
+                            customHtmlSanitizer);
 
                     assertArrayEquals(fakePdfBytes, resultPdf);
 
@@ -639,8 +661,8 @@ void convertEmlToPdfWithAttachments() throws Exception {
                                 any(),
                                 any(byte[].class),
                                 anyString(),
-                                anyBoolean(),
-                                any(TempFileManager.class)));
+                                any(TempFileManager.class),
+                                any(CustomHtmlSanitizer.class)));
 
                     verify(mockPdfDocumentFactory).load(resultPdf);
                 }
@@ -648,7 +670,8 @@ void convertEmlToPdfWithAttachments() throws Exception {
         }
 
         @Test
-        @DisplayName("Should handle errors during EML to PDF conversion")
+        @Disabled("Complex static mocking - temporarily disabled while refactoring")
+        @DisplayName("Should handle errors during EML to PDF conversion") 
         void handleErrorsDuringConversion() {
             String emlContent =
                 createSimpleTextEmail("from@test.com", "to@test.com", "Subject", "Body");
@@ -656,7 +679,7 @@ void handleErrorsDuringConversion() {
             EmlToPdfRequest request = createBasicRequest();
             String errorMessage = "Conversion failed";
 
-            try (MockedStatic<FileToPdf> fileToPdf = mockStatic(FileToPdf.class)) {
+            try (MockedStatic<FileToPdf> fileToPdf = mockStatic(FileToPdf.class, org.mockito.Mockito.withSettings().lenient())) {
                 fileToPdf
                     .when(
                         () ->
@@ -665,8 +688,8 @@ void handleErrorsDuringConversion() {
                                 any(),
                                 any(byte[].class),
                                 anyString(),
-                                anyBoolean(),
-                                any(TempFileManager.class)))
+                                any(TempFileManager.class),
+                                any(CustomHtmlSanitizer.class)))
                     .thenThrow(new IOException(errorMessage));
 
                 IOException exception = assertThrows(
@@ -676,9 +699,9 @@ void handleErrorsDuringConversion() {
                         request,
                         emlBytes,
                         "test.eml",
-                        false,
                         mockPdfDocumentFactory,
-                        mockTempFileManager));
+                        mockTempFileManager,
+                        customHtmlSanitizer));
 
                 assertTrue(exception.getMessage().contains(errorMessage));
             }
diff --git a/app/common/src/test/java/stirling/software/common/util/FileToPdfTest.java b/app/common/src/test/java/stirling/software/common/util/FileToPdfTest.java
index 96def4fa38a..d939d0a1fd1 100644
--- a/app/common/src/test/java/stirling/software/common/util/FileToPdfTest.java
+++ b/app/common/src/test/java/stirling/software/common/util/FileToPdfTest.java
@@ -1,5 +1,6 @@
 package stirling.software.common.util;
 
+import java.nio.file.Files;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -10,12 +11,29 @@
 import java.io.File;
 import java.io.IOException;
 
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import stirling.software.common.model.api.converters.HTMLToPdfRequest;
+import stirling.software.common.service.SsrfProtectionService;
 
 public class FileToPdfTest {
 
+    private CustomHtmlSanitizer customHtmlSanitizer;
+
+    @BeforeEach
+    void setUp() {
+        SsrfProtectionService mockSsrfProtectionService = mock(SsrfProtectionService.class);
+        stirling.software.common.model.ApplicationProperties mockApplicationProperties = mock(stirling.software.common.model.ApplicationProperties.class);
+        stirling.software.common.model.ApplicationProperties.System mockSystem = mock(stirling.software.common.model.ApplicationProperties.System.class);
+        
+        when(mockSsrfProtectionService.isUrlAllowed(org.mockito.ArgumentMatchers.anyString())).thenReturn(true);
+        when(mockApplicationProperties.getSystem()).thenReturn(mockSystem);
+        when(mockSystem.getDisableSanitize()).thenReturn(false);
+        
+        customHtmlSanitizer = new CustomHtmlSanitizer(mockSsrfProtectionService, mockApplicationProperties);
+    }
+
     /**
      * Test the HTML to PDF conversion. This test expects an IOException when an empty HTML input is
      * provided.
@@ -25,14 +43,13 @@ public void testConvertHtmlToPdf() {
         HTMLToPdfRequest request = new HTMLToPdfRequest();
         byte[] fileBytes = new byte[0]; // Sample file bytes (empty input)
         String fileName = "test.html"; // Sample file name indicating an HTML file
-        boolean disableSanitize = false; // Flag to control sanitization
         TempFileManager tempFileManager = mock(TempFileManager.class); // Mock TempFileManager
 
         // Mock the temp file creation to return real temp files
         try {
             when(tempFileManager.createTempFile(anyString()))
-                .thenReturn(File.createTempFile("test", ".pdf"))
-                .thenReturn(File.createTempFile("test", ".html"));
+                .thenReturn(Files.createTempFile("test", ".pdf").toFile())
+                .thenReturn(Files.createTempFile("test", ".html").toFile());
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
@@ -43,7 +60,7 @@ public void testConvertHtmlToPdf() {
                         Exception.class,
                         () ->
                                 FileToPdf.convertHtmlToPdf(
-                                        "/path/", request, fileBytes, fileName, disableSanitize, tempFileManager));
+                                        "/path/", request, fileBytes, fileName, tempFileManager, customHtmlSanitizer));
         assertNotNull(thrown);
     }
 
diff --git a/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertEmlToPDF.java b/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertEmlToPDF.java
index 33d51a2a13f..0f657cb4707 100644
--- a/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertEmlToPDF.java
+++ b/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertEmlToPDF.java
@@ -23,6 +23,7 @@
 import stirling.software.common.configuration.RuntimePathConfig;
 import stirling.software.common.model.api.converters.EmlToPdfRequest;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.util.CustomHtmlSanitizer;
 import stirling.software.common.util.EmlToPdf;
 import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;
@@ -37,6 +38,7 @@ public class ConvertEmlToPDF {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final RuntimePathConfig runtimePathConfig;
     private final TempFileManager tempFileManager;
+    private final CustomHtmlSanitizer customHtmlSanitizer;
 
     @PostMapping(consumes = "multipart/form-data", value = "/eml/pdf")
     @Operation(
@@ -103,9 +105,9 @@ public ResponseEntity<byte[]> convertEmlToPdf(@ModelAttribute EmlToPdfRequest re
                                 request,
                                 fileBytes,
                                 originalFilename,
-                                false,
                                 pdfDocumentFactory,
-                                tempFileManager);
+                                tempFileManager,
+                                customHtmlSanitizer);
 
                 if (pdfBytes == null || pdfBytes.length == 0) {
                     log.error("PDF conversion failed - empty output for {}", originalFilename);
diff --git a/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertHtmlToPDF.java b/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertHtmlToPDF.java
index 9b3b645064c..9a589860e54 100644
--- a/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertHtmlToPDF.java
+++ b/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertHtmlToPDF.java
@@ -14,9 +14,9 @@
 import lombok.RequiredArgsConstructor;
 
 import stirling.software.common.configuration.RuntimePathConfig;
-import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.model.api.converters.HTMLToPdfRequest;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.util.CustomHtmlSanitizer;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.FileToPdf;
 import stirling.software.common.util.TempFileManager;
@@ -30,12 +30,12 @@ public class ConvertHtmlToPDF {
 
     private final CustomPDFDocumentFactory pdfDocumentFactory;
 
-    private final ApplicationProperties applicationProperties;
-
     private final RuntimePathConfig runtimePathConfig;
 
     private final TempFileManager tempFileManager;
 
+    private final CustomHtmlSanitizer customHtmlSanitizer;
+
     @PostMapping(consumes = "multipart/form-data", value = "/html/pdf")
     @Operation(
             summary = "Convert an HTML or ZIP (containing HTML and CSS) to PDF",
@@ -57,17 +57,14 @@ public ResponseEntity<byte[]> HtmlToPdf(@ModelAttribute HTMLToPdfRequest request
                     "error.fileFormatRequired", "File must be in {0} format", ".html or .zip");
         }
 
-        boolean disableSanitize =
-                Boolean.TRUE.equals(applicationProperties.getSystem().getDisableSanitize());
-
         byte[] pdfBytes =
                 FileToPdf.convertHtmlToPdf(
                         runtimePathConfig.getWeasyPrintPath(),
                         request,
                         fileInput.getBytes(),
                         originalFilename,
-                        disableSanitize,
-                        tempFileManager);
+                        tempFileManager,
+                        customHtmlSanitizer);
 
         pdfBytes = pdfDocumentFactory.createNewBytesBasedOnOldDocument(pdfBytes);
 
diff --git a/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertMarkdownToPdf.java b/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertMarkdownToPdf.java
index 6cb22be7e76..945599a9343 100644
--- a/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertMarkdownToPdf.java
+++ b/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertMarkdownToPdf.java
@@ -24,9 +24,9 @@
 import lombok.RequiredArgsConstructor;
 
 import stirling.software.common.configuration.RuntimePathConfig;
-import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.model.api.GeneralFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.util.CustomHtmlSanitizer;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.FileToPdf;
 import stirling.software.common.util.TempFileManager;
@@ -39,12 +39,12 @@
 public class ConvertMarkdownToPdf {
 
     private final CustomPDFDocumentFactory pdfDocumentFactory;
-
-    private final ApplicationProperties applicationProperties;
     private final RuntimePathConfig runtimePathConfig;
 
     private final TempFileManager tempFileManager;
 
+    private final CustomHtmlSanitizer customHtmlSanitizer;
+
     @PostMapping(consumes = "multipart/form-data", value = "/markdown/pdf")
     @Operation(
             summary = "Convert a Markdown file to PDF",
@@ -79,17 +79,14 @@ public ResponseEntity<byte[]> markdownToPdf(@ModelAttribute GeneralFile generalF
 
         String htmlContent = renderer.render(document);
 
-        boolean disableSanitize =
-                Boolean.TRUE.equals(applicationProperties.getSystem().getDisableSanitize());
-
         byte[] pdfBytes =
                 FileToPdf.convertHtmlToPdf(
                         runtimePathConfig.getWeasyPrintPath(),
                         null,
                         htmlContent.getBytes(),
                         "converted.html",
-                        disableSanitize,
-                        tempFileManager);
+                        tempFileManager,
+                        customHtmlSanitizer);
         pdfBytes = pdfDocumentFactory.createNewBytesBasedOnOldDocument(pdfBytes);
         String outputFilename =
                 originalFilename.replaceFirst("[.][^.]+$", "")
diff --git a/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertOfficeController.java b/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertOfficeController.java
index d81e3843f30..651444c6937 100644
--- a/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertOfficeController.java
+++ b/app/core/src/main/java/stirling/software/SPDF/controller/api/converters/ConvertOfficeController.java
@@ -2,6 +2,7 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
@@ -26,6 +27,7 @@
 import stirling.software.common.configuration.RuntimePathConfig;
 import stirling.software.common.model.api.GeneralFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.util.CustomHtmlSanitizer;
 import stirling.software.common.util.ProcessExecutor;
 import stirling.software.common.util.ProcessExecutor.ProcessExecutorResult;
 import stirling.software.common.util.WebResponseUtils;
@@ -38,6 +40,7 @@ public class ConvertOfficeController {
 
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final RuntimePathConfig runtimePathConfig;
+    private final CustomHtmlSanitizer customHtmlSanitizer;
 
     public File convertToPdf(MultipartFile inputFile) throws IOException, InterruptedException {
         // Check for valid file extension
@@ -50,7 +53,17 @@ public File convertToPdf(MultipartFile inputFile) throws IOException, Interrupte
         // Save the uploaded file to a temporary location
         Path tempInputFile =
                 Files.createTempFile("input_", "." + FilenameUtils.getExtension(originalFilename));
-        inputFile.transferTo(tempInputFile);
+
+        // Check if the file is HTML and apply sanitization if needed
+        String fileExtension = FilenameUtils.getExtension(originalFilename).toLowerCase();
+        if ("html".equals(fileExtension) || "htm".equals(fileExtension)) {
+            // Read and sanitize HTML content
+            String htmlContent = new String(inputFile.getBytes(), StandardCharsets.UTF_8);
+            String sanitizedHtml = customHtmlSanitizer.sanitize(htmlContent);
+            Files.write(tempInputFile, sanitizedHtml.getBytes(StandardCharsets.UTF_8));
+        } else {
+            inputFile.transferTo(tempInputFile);
+        }
 
         // Prepare the output file path
         Path tempOutputFile = Files.createTempFile("output_", ".pdf");
diff --git a/app/core/src/main/resources/settings.yml.template b/app/core/src/main/resources/settings.yml.template
index a26f256f704..38d79baeafd 100644
--- a/app/core/src/main/resources/settings.yml.template
+++ b/app/core/src/main/resources/settings.yml.template
@@ -108,6 +108,17 @@ system:
   enableAnalytics: null # set to 'true' to enable analytics, set to 'false' to disable analytics; for enterprise users, this is set to true
   enableUrlToPDF: false # Set to 'true' to enable URL to PDF, INTERNAL ONLY, known security issues, should not be used externally
   disableSanitize: false # set to true to disable Sanitize HTML; (can lead to injections in HTML)
+  html:
+    urlSecurity:
+      enabled: true # Enable URL security restrictions for HTML processing
+      level: MEDIUM # Security level: MAX (whitelist only), MEDIUM (block internal networks), OFF (no restrictions)
+      allowedDomains: [] # Whitelist of allowed domains (e.g. ['cdn.example.com', 'images.google.com'])
+      blockedDomains: [] # Additional domains to block (e.g. ['evil.com', 'malicious.org'])
+      internalTlds: ['.local', '.internal', '.corp', '.home'] # Block domains with these TLD patterns
+      blockPrivateNetworks: true # Block RFC 1918 private networks (10.x.x.x, 192.168.x.x, 172.16-31.x.x)
+      blockLocalhost: true # Block localhost and loopback addresses (127.x.x.x, ::1)
+      blockLinkLocal: true # Block link-local addresses (169.254.x.x, fe80::/10)
+      blockCloudMetadata: true # Block cloud provider metadata endpoints (169.254.169.254)
   datasource:
     enableCustomDatabase: false # Enterprise users ONLY, set this property to 'true' if you would like to use your own custom database configuration
     customDatabaseUrl: '' # eg jdbc:postgresql://localhost:5432/postgres, set the url for your own custom database connection. If provided, the type, hostName, port and name are not necessary and will not be used
diff --git a/testing/allEndpointsRemovedSettings.yml b/testing/allEndpointsRemovedSettings.yml
index 7240fe1284b..b8699736fa5 100644
--- a/testing/allEndpointsRemovedSettings.yml
+++ b/testing/allEndpointsRemovedSettings.yml
@@ -6,7 +6,6 @@
 #                      ___) || |  | ||  _ <| |___ | || |\  | |_| |_____|  __/| |_| |  _|                    #
 #                     |____/ |_| |___|_| \_\_____|___|_| \_|\____|     |_|   |____/|_|                      #
 #                                                                                                           #
-# Custom setting.yml file with all endpoints disabled to only be used for testing purposes                  #
 # Do not comment out any entry, it will be removed on next startup                                          #
 # If you want to override with environment parameter follow parameter naming SECURITY_INITIALLOGIN_USERNAME #
 #############################################################################################################
@@ -109,6 +108,17 @@ system:
   enableAnalytics: true # set to 'true' to enable analytics, set to 'false' to disable analytics; for enterprise users, this is set to true
   enableUrlToPDF: false # Set to 'true' to enable URL to PDF, INTERNAL ONLY, known security issues, should not be used externally
   disableSanitize: false # set to true to disable Sanitize HTML; (can lead to injections in HTML)
+  html:
+    urlSecurity:
+      enabled: true # Enable URL security restrictions for HTML processing
+      level: MEDIUM # Security level: MAX (whitelist only), MEDIUM (block internal networks), OFF (no restrictions)
+      allowedDomains: [] # Whitelist of allowed domains (e.g. ['cdn.example.com', 'images.google.com'])
+      blockedDomains: [] # Additional domains to block (e.g. ['evil.com', 'malicious.org'])
+      internalTlds: ['.local', '.internal', '.corp', '.home'] # Block domains with these TLD patterns
+      blockPrivateNetworks: true # Block RFC 1918 private networks (10.x.x.x, 192.168.x.x, 172.16-31.x.x)
+      blockLocalhost: true # Block localhost and loopback addresses (127.x.x.x, ::1)
+      blockLinkLocal: true # Block link-local addresses (169.254.x.x, fe80::/10)
+      blockCloudMetadata: true # Block cloud provider metadata endpoints (169.254.169.254)
   datasource:
     enableCustomDatabase: false # Enterprise users ONLY, set this property to 'true' if you would like to use your own custom database configuration
     customDatabaseUrl: '' # eg jdbc:postgresql://localhost:5432/postgres, set the url for your own custom database connection. If provided, the type, hostName, port and name are not necessary and will not be used
@@ -142,7 +152,7 @@ ui:
   appNameNavbar: '' # name displayed on the navigation bar
   languages: [] # If empty, all languages are enabled. To display only German and Polish ["de_DE", "pl_PL"]. British English is always enabled.
 
-endpoints: # All the possible endpoints are disabled
+endpoints:
   toRemove: [crop, merge-pdfs, multi-page-layout, overlay-pdfs, pdf-to-single-page, rearrange-pages, remove-image-pdf, remove-pages, rotate-pdf, scale-pages, split-by-size-or-count, split-pages, split-pdf-by-chapters, split-pdf-by-sections, add-password, add-watermark, auto-redact, cert-sign, get-info-on-pdf, redact, remove-cert-sign, remove-password, sanitize-pdf, validate-signature, file-to-pdf, html-to-pdf, img-to-pdf, markdown-to-pdf, pdf-to-csv, pdf-to-html, pdf-to-img, pdf-to-markdown, pdf-to-pdfa, pdf-to-presentation, pdf-to-text, pdf-to-word, pdf-to-xml, url-to-pdf, add-image, add-page-numbers, add-stamp, auto-rename, auto-split-pdf, compress-pdf, decompress-pdf, extract-image-scans, extract-images, flatten, ocr-pdf, remove-blanks, repair, replace-invert-pdf, show-javascript, update-metadata, filter-contains-image, filter-contains-text, filter-file-size, filter-page-count, filter-page-rotation, filter-page-size, add-attachments] # list endpoints to disable (e.g. ['img-to-pdf', 'remove-pages'])
   groupsToRemove: [] # list groups to disable (e.g. ['LibreOffice'])
 
@@ -153,7 +163,7 @@ metrics:
 AutomaticallyGenerated:
   key: cbb81c0f-50b1-450c-a2b5-89ae527776eb
   UUID: 10dd4fba-01fa-4717-9b78-3dc4f54e398a
-  appVersion: 0.44.3
+  appVersion: 1.1.0
 
 processExecutor:
   sessionLimit: # Process executor instances limits",
"url": "https://github.com/Stirling-Tools/Stirling-PDF/commit/7d6b70871bad2a3ff810825f7382c49f55293943.patch"
}
] |
CWE-918: Server-Side Request Forgery (SSRF)
|
GHSA-mc63-4cpc-gjqj
| null |
[
{
"commit_message": "[PATCH] fix for use-after-free (#240) src/request-handler.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/drachtio/drachtio-server/commit/860f025468feb31c43227153d8fb3f34210a522e.patch"
}
] | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.