id
stringlengths 12
19
| title
stringlengths 0
237
| description
stringlengths 35
3.87k
⌀ | patches
listlengths 1
22
| cwe
stringlengths 2
440
⌀ |
|---|---|---|---|---|
CVE-2021-23758
|
Deserialization of Untrusted Data
|
All versions of package ajaxpro.2 are vulnerable to Deserialization of Untrusted Data due to the possibility of deserialization of arbitrary .NET classes, which can be abused to gain remote code execution.
|
[
{
"commit_message": "[PATCH] added allowed customized types .gitignore | 1 + AjaxPro/AjaxPro.csproj | 13 +- AjaxPro/AjaxPro.sln | 4 +- .../AjaxSettingsSectionHandler.cs | 19 + AjaxPro/Handler/AjaxProcHelper.cs | 49 +- AjaxPro/JSON/JavaScriptDeserializer.cs | 26 +- AjaxPro/Services/AuthenticationService.cs | 89 - AjaxPro/Services/CartService.cs | 61 - AjaxPro/Services/ChatService.cs | 71 - AjaxPro/Services/ProfileService.cs | 91 - AjaxPro/Utilities/AjaxSettings.cs | 10 +- AjaxPro/Utilities/Constant.cs | 2 +- AjaxPro/core.js | 2 +- AjaxPro/jquery-1.3.1.js | 4241 ----------------- AjaxPro/web.config | 38 +- 15 files changed, 94 insertions(+), 4623 deletions(-) delete mode 100644 AjaxPro/Services/AuthenticationService.cs delete mode 100644 AjaxPro/Services/CartService.cs delete mode 100644 AjaxPro/Services/ChatService.cs delete mode 100644 AjaxPro/Services/ProfileService.cs delete mode 100644 AjaxPro/jquery-1.3.1.js",
"patch_text_b64": "From b0e63be5f0bb20dfce507cb8a1a9568f6e73de57 Mon Sep 17 00:00:00 2001
From: Michael Schwarz <michaelschwarz@users.noreply.github.com>
Date: Wed, 27 Oct 2021 21:17:11 +0200
Subject: [PATCH] added allowed customized types

---
 .gitignore                                    |    1 +
 AjaxPro/AjaxPro.csproj                        |   13 +-
 AjaxPro/AjaxPro.sln                           |    4 +-
 .../AjaxSettingsSectionHandler.cs             |   19 +
 AjaxPro/Handler/AjaxProcHelper.cs             |   49 +-
 AjaxPro/JSON/JavaScriptDeserializer.cs        |   26 +-
 AjaxPro/Services/AuthenticationService.cs     |   89 -
 AjaxPro/Services/CartService.cs               |   61 -
 AjaxPro/Services/ChatService.cs               |   71 -
 AjaxPro/Services/ProfileService.cs            |   91 -
 AjaxPro/Utilities/AjaxSettings.cs             |   10 +-
 AjaxPro/Utilities/Constant.cs                 |    2 +-
 AjaxPro/core.js                               |    2 +-
 AjaxPro/jquery-1.3.1.js                       | 4241 -----------------
 AjaxPro/web.config                            |   38 +-
 15 files changed, 94 insertions(+), 4623 deletions(-)
 delete mode 100644 AjaxPro/Services/AuthenticationService.cs
 delete mode 100644 AjaxPro/Services/CartService.cs
 delete mode 100644 AjaxPro/Services/ChatService.cs
 delete mode 100644 AjaxPro/Services/ProfileService.cs
 delete mode 100644 AjaxPro/jquery-1.3.1.js

diff --git a/.gitignore b/.gitignore
index 436b019..eb77396 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,4 @@
 /AjaxPro/.vs/AjaxPro
 /AjaxPro/bin
 /AjaxPro/obj
+/DemoWebSite
diff --git a/AjaxPro/AjaxPro.csproj b/AjaxPro/AjaxPro.csproj
index 5546101..7bff051 100644
--- a/AjaxPro/AjaxPro.csproj
+++ b/AjaxPro/AjaxPro.csproj
@@ -11,7 +11,7 @@
     </ApplicationIcon>
     <AssemblyKeyContainerName>
     </AssemblyKeyContainerName>
-    <AssemblyName>AjaxPro</AssemblyName>
+    <AssemblyName>AjaxPro.2</AssemblyName>
     <AssemblyOriginatorKeyFile>
     </AssemblyOriginatorKeyFile>
     <DefaultClientScript>JScript</DefaultClientScript>
@@ -249,10 +249,6 @@
     <Compile Include="Security\EncryptTransformer.cs" />
     <Compile Include="Security\WebDecrypter.cs" />
     <Compile Include="Security\WebEncrypter.cs" />
-    <Compile Include="Services\AuthenticationService.cs" />
-    <Compile Include="Services\CartService.cs" />
-    <Compile Include="Services\ChatService.cs" />
-    <Compile Include="Services\ProfileService.cs" />
     <Compile Include="Utilities\AjaxSettings.cs">
       <SubType>Code</SubType>
     </Compile>
@@ -277,18 +273,11 @@
     <EmbeddedResource Include="core.js" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="build_1.1.bat" />
-    <None Include="build_2.0.bat" />
     <None Include="web.config" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="build.bat" />
-    <None Include="build_json.bat" />
     <EmbeddedResource Include="ms.js" />
   </ItemGroup>
-  <ItemGroup>
-    <Content Include="jquery-1.3.1.js" />
-  </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
     <PreBuildEvent>
diff --git a/AjaxPro/AjaxPro.sln b/AjaxPro/AjaxPro.sln
index 7e07790..9e8430f 100644
--- a/AjaxPro/AjaxPro.sln
+++ b/AjaxPro/AjaxPro.sln
@@ -1,7 +1,7 @@
 ï»¿
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.28307.1705
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31729.503
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AjaxPro", "AjaxPro.csproj", "{9AD42568-07A4-4D8B-9C6D-1FD54683EF4B}"
 EndProject
diff --git a/AjaxPro/Configuration/AjaxSettingsSectionHandler.cs b/AjaxPro/Configuration/AjaxSettingsSectionHandler.cs
index 7e30f68..9c3f8ff 100644
--- a/AjaxPro/Configuration/AjaxSettingsSectionHandler.cs
+++ b/AjaxPro/Configuration/AjaxSettingsSectionHandler.cs
@@ -34,6 +34,7 @@
  * MS	07-04-24	added new settings (oldStyle == configuration)
  *					added provider settings
  *					added includeTypeProperty
+ * MS	21-10-27	added allowed customized types for JSON deserialization
  * 
  * 
  */
@@ -154,6 +155,24 @@ public object Create(object parent, object configContext, System.Xml.XmlNode sec
 					if (n.SelectSingleNode("@enabled") != null && n.SelectSingleNode("@enabled").InnerText == "true")
 						settings.DebugEnabled = true;
 				}
+				else if (n.Name == "jsonDeserializationCustomTypes")
+				{
+					settings.IsJsonDeserializationCustomTypesDenied = n.Attributes["default"] == null || n.Attributes["default"].InnerText.ToLower() != "allow";
+
+					foreach (XmlNode sn in n.ChildNodes)
+					{
+						switch (sn.Name)
+						{
+							case "allow":
+								settings.JsonDeserializationCustomTypesAllowed.Add(sn.InnerText);
+								break;
+
+							case "deny":
+								settings.JsonDeserializationCustomTypesDenied.Add(sn.InnerText);
+								break;
+						}
+					}
+				}
 				else if (n.Name == "oldStyle" || n.Name == "configuration")
 				{
 					foreach (XmlNode sn in n.ChildNodes)
diff --git a/AjaxPro/Handler/AjaxProcHelper.cs b/AjaxPro/Handler/AjaxProcHelper.cs
index 8c68fee..6e55773 100644
--- a/AjaxPro/Handler/AjaxProcHelper.cs
+++ b/AjaxPro/Handler/AjaxProcHelper.cs
@@ -36,6 +36,8 @@
  * MS	06-06-11	removed WebEvent because of SecurityPermissions not available in medium trust environments
  * MS	06-10-04	set UTF-8 encoding for XML documents
  * MS	07-04-24	fixed Ajax token
+ * MS	21-10-27	added allowed customized types for JSON deserialization
+ * 
  * 
  */
 using System;
@@ -43,7 +45,8 @@
 using System.Web;
 using System.Web.Caching;
 using System.IO;
-#if(NET20)
+using System.Collections.Generic;
+#if (NET20)
 using System.Web.Management;
 using System.Diagnostics;
 #endif
@@ -115,25 +118,6 @@ internal void Run()
 				object[] po = null;
 				object res = null;
 
-				#region Retreive Parameters from the HTTP Request
-
-				try
-				{
-					// The IAjaxProcessor will read the values either form the 
-					// request URL or the request input stream.
-
-					po = p.RetreiveParameters();
-				}
-				catch(Exception ex)
-				{
-					p.SerializeObject(ex);
-
-					if(p.Context.Trace.IsEnabled) p.Context.Trace.Write(Constant.AjaxID, "End ProcessRequest");
-					return;
-				}
-
-				#endregion 
-
 				// Check if we have the same request already in our cache. The 
 				// cacheKey will be the type and a hashcode from the parameter values.
 
@@ -151,6 +135,23 @@ internal void Run()
 					return;
 				}
 
+				#region Retreive Parameters from the HTTP Request
+
+				try
+				{
+					// The IAjaxProcessor will read the values either form the 
+					// request URL or the request input stream.
+
+					po = p.RetreiveParameters();
+				}
+				catch (Exception ex)
+				{
+					ReturnException(ex);
+					return;
+				}
+
+				#endregion
+
 				#region Reflection part of Ajax.NET
 
 				try
@@ -326,5 +327,13 @@ internal void Run()
 					winctx.Undo();
 			}
 		}
+
+		private void ReturnException(Exception ex)
+		{
+			p.SerializeObject(ex);
+
+			if (p.Context.Trace.IsEnabled) p.Context.Trace.Write(Constant.AjaxID, "End ProcessRequest");
+			return;
+		}
 	}
 }
diff --git a/AjaxPro/JSON/JavaScriptDeserializer.cs b/AjaxPro/JSON/JavaScriptDeserializer.cs
index 6933bf9..354731e 100644
--- a/AjaxPro/JSON/JavaScriptDeserializer.cs
+++ b/AjaxPro/JSON/JavaScriptDeserializer.cs
@@ -36,6 +36,7 @@
  * MS	06-05-30	changed to new converter usage
  * MS	06-07-11	added generic method for DeserializeFromJson
  * MS	06-09-26	improved performance removing three-times cast
+ * MS	21-10-27	added allowed customized types for JSON deserialization
  * 
  * 
  */
@@ -212,11 +213,28 @@ public static object Deserialize(IJavaScriptObject o, Type type)
         /// <returns></returns>
 		internal static object DeserializeCustomObject(JavaScriptObject o, Type type)
 		{
-			object c = Activator.CreateInstance(type);
+			if (AjaxPro.Utility.Settings.IsJsonDeserializationCustomTypesDenied)
+			{
+				bool isCustomTypeAllowed = false;
+
+				foreach (var s in AjaxPro.Utility.Settings.JsonDeserializationCustomTypesAllowed)
+					if (type.FullName.StartsWith(s, StringComparison.InvariantCultureIgnoreCase))
+					{
+						isCustomTypeAllowed = true;
+						break;
+					}
 
-			// TODO: is this a security problem?
-			// if(o.GetType().GetCustomAttributes(typeof(AjaxClassAttribute), true).Length == 0)
-			//	throw new System.Security.SecurityException("Could not create class '" + type.FullName + "' because of missing AjaxClass attribute.");
+				if (!isCustomTypeAllowed)
+					throw new System.Security.SecurityException("This cusomized type is not allowed as argument for this method.");
+			}
+			else
+			{
+				foreach (var s in AjaxPro.Utility.Settings.JsonDeserializationCustomTypesDenied)
+					if (type.FullName.StartsWith(s, StringComparison.InvariantCultureIgnoreCase))
+						throw new System.Security.SecurityException("This cusomized type is not allowed as argument for this method.");
+			}
+
+			object c = Activator.CreateInstance(type);
 
 			MemberInfo[] members = type.GetMembers(BindingFlags.GetField | BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance);
 			foreach (MemberInfo memberInfo in members)
diff --git a/AjaxPro/Services/AuthenticationService.cs b/AjaxPro/Services/AuthenticationService.cs
deleted file mode 100644
index edfa98e..0000000
--- a/AjaxPro/Services/AuthenticationService.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * AuthenticationService.cs
- * 
- * Copyright © 2007 Michael Schwarz (http://www.ajaxpro.info).
- * All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person 
- * obtaining a copy of this software and associated documentation 
- * files (the "Software"), to deal in the Software without 
- * restriction, including without limitation the rights to use, 
- * copy, modify, merge, publish, distribute, sublicense, and/or 
- * sell copies of the Software, and to permit persons to whom the 
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be 
- * included in all copies or substantial portions of the Software.
- *
- * 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.
- */
-/*
- * MS	05-12-20	initial version
- * MS	06-04-16	changed methods to static
- * 
- * 
- * 
- * 
- */
-using System;
-using System.Web.Security;
-
-namespace AjaxPro.Services
-{
-	[AjaxNamespace("AjaxPro.Services.Authentication")]
-	public class AuthenticationService
-	{
-        /// <summary>
-        /// Logins the specified username.
-        /// </summary>
-        /// <param name="username">The username.</param>
-        /// <param name="password">The password.</param>
-        /// <returns></returns>
-		[AjaxMethod]
-		public static bool Login(string username, string password)
-		{
-#if(NET20)
-			if(Membership.Provider.ValidateUser(username, password))
-#else
-			if(FormsAuthentication.Authenticate(username, password))
-#endif
-			{
-				FormsAuthentication.SetAuthCookie(username, false);
-				return true;
-			}
-
-			return false;
-		}
-
-        /// <summary>
-        /// Logouts this instance.
-        /// </summary>
-		[AjaxMethod]
-		public static void Logout()
-		{
-			FormsAuthentication.SignOut();
-		}
-
-        /// <summary>
-        /// Validates the user.
-        /// </summary>
-        /// <param name="username">The username.</param>
-        /// <param name="password">The password.</param>
-        /// <returns></returns>
-		[AjaxMethod]
-		public static bool ValidateUser(string username, string password)
-		{
-#if(NET20)
-			return Membership.Provider.ValidateUser(username, password);
-#else
-			throw new NotImplementedException("ValidateUser is not yet implemented.");
-#endif
-		}
-	}
-}
diff --git a/AjaxPro/Services/CartService.cs b/AjaxPro/Services/CartService.cs
deleted file mode 100644
index f51e7d9..0000000
--- a/AjaxPro/Services/CartService.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * CartService.cs
- * 
- * Copyright © 2007 Michael Schwarz (http://www.ajaxpro.info).
- * All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person 
- * obtaining a copy of this software and associated documentation 
- * files (the "Software"), to deal in the Software without 
- * restriction, including without limitation the rights to use, 
- * copy, modify, merge, publish, distribute, sublicense, and/or 
- * sell copies of the Software, and to permit persons to whom the 
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be 
- * included in all copies or substantial portions of the Software.
- *
- * 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.
- */
-#if(NET20)
-/*
- * MS	06-04-16	initial version
- * 
- * 
- * 
- * 
- * 
- */
-using System;
-using System.Text;
-
-namespace AjaxPro.Services
-{
-	[AjaxNamespace("AjaxPro.Services.Cart")]
-	public abstract class ICartService
-	{
-        /// <summary>
-        /// Adds the item.
-        /// </summary>
-        /// <param name="cartName">Name of the cart.</param>
-        /// <param name="item">The item.</param>
-        /// <returns></returns>
-		[AjaxMethod]
-		public abstract bool AddItem(string cartName, object item);
-
-        /// <summary>
-        /// Gets the items.
-        /// </summary>
-        /// <param name="cartName">Name of the cart.</param>
-        /// <returns></returns>
-		[AjaxMethod]
-		public abstract object[] GetItems(string cartName);
-	}
-}
-#endif
\ No newline at end of file
diff --git a/AjaxPro/Services/ChatService.cs b/AjaxPro/Services/ChatService.cs
deleted file mode 100644
index ebe668c..0000000
--- a/AjaxPro/Services/ChatService.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * ChatService.cs
- * 
- * Copyright © 2007 Michael Schwarz (http://www.ajaxpro.info).
- * All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person 
- * obtaining a copy of this software and associated documentation 
- * files (the "Software"), to deal in the Software without 
- * restriction, including without limitation the rights to use, 
- * copy, modify, merge, publish, distribute, sublicense, and/or 
- * sell copies of the Software, and to permit persons to whom the 
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be 
- * included in all copies or substantial portions of the Software.
- *
- * 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.
- */
-#if(NET20)
-/*
- * MS	06-04-16	initial version
- * 
- * 
- * 
- * 
- * 
- */
-using System;
-using System.Text;
-
-namespace AjaxPro.Services
-{
-	[AjaxNamespace("AjaxPro.Services.Chat")]
-	public abstract class IChatService
-	{
-        /// <summary>
-        /// Sends the message.
-        /// </summary>
-        /// <param name="room">The room.</param>
-        /// <param name="message">The message.</param>
-        /// <returns></returns>
-		[AjaxMethod]
-		public abstract bool SendMessage(string room, string message);
-
-        /// <summary>
-        /// Retrieves the new.
-        /// </summary>
-        /// <param name="room">The room.</param>
-        /// <param name="lastRetreived">The last retreived.</param>
-        /// <returns></returns>
-		[AjaxMethod]
-		public abstract object[] RetrieveNew(string room, DateTime lastRetreived);
-
-        /// <summary>
-        /// Retrieves the last.
-        /// </summary>
-        /// <param name="room">The room.</param>
-        /// <param name="count">The count.</param>
-        /// <returns></returns>
-		[AjaxMethod]
-		public abstract object[] RetrieveLast(string room, int count);
-	}
-}
-#endif
\ No newline at end of file
diff --git a/AjaxPro/Services/ProfileService.cs b/AjaxPro/Services/ProfileService.cs
deleted file mode 100644
index 47fac2b..0000000
--- a/AjaxPro/Services/ProfileService.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * ProfileService.cs
- * 
- * Copyright © 2007 Michael Schwarz (http://www.ajaxpro.info).
- * All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person 
- * obtaining a copy of this software and associated documentation 
- * files (the "Software"), to deal in the Software without 
- * restriction, including without limitation the rights to use, 
- * copy, modify, merge, publish, distribute, sublicense, and/or 
- * sell copies of the Software, and to permit persons to whom the 
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be 
- * included in all copies or substantial portions of the Software.
- *
- * 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.
- */
-#if(NET20)
-/*
- * MS	05-12-20	initial version
- * MS	06-04-16	changed methods to static
- * MS	06-04-25	changed GetProfile, added ProfileBaseConverter
- * 
- * 
- * 
- */
-using System;
-using System.Data;
-using System.Collections;
-using System.Configuration;
-using System.Web;
-using System.Web.Profile;
-
-namespace AjaxPro.Services
-{
-	[AjaxNamespace("AjaxPro.Services.Profile")]
-	public class ProfileService
-	{
-        /// <summary>
-        /// Gets the profile.
-        /// </summary>
-        /// <returns></returns>
-		[AjaxMethod]
-		public static ProfileBase GetProfile()
-		{
-			return HttpContext.Current.Profile;
-		}
-
-        /// <summary>
-        /// Gets the profile property.
-        /// </summary>
-        /// <param name="property">The property.</param>
-        /// <returns></returns>
-        [AjaxMethod]
-        public static object GetProfileProperty(string property)
-        {
-            ProfileBase profile = HttpContext.Current.Profile;
-            if (profile == null)
-            {
-                return null;
-            }
-            return profile[property];
-        }
-
-        /// <summary>
-        /// Sets the profile.
-        /// </summary>
-        /// <param name="o">The o.</param>
-        /// <returns></returns>
-        [AjaxMethod]
-        public static bool SetProfile(JavaScriptObject o)
-        {
-            ProfileBase profile = HttpContext.Current.Profile;
-            foreach (string key in o.Keys)
-            {
-				profile[key] = JavaScriptDeserializer.Deserialize((IJavaScriptObject)o[key], profile[key].GetType());
-            }
-
-			return true;
-        }
-	}
-}
-#endif
\ No newline at end of file
diff --git a/AjaxPro/Utilities/AjaxSettings.cs b/AjaxPro/Utilities/AjaxSettings.cs
index 209fc1f..dba67b8 100644
--- a/AjaxPro/Utilities/AjaxSettings.cs
+++ b/AjaxPro/Utilities/AjaxSettings.cs
@@ -34,7 +34,7 @@
  *					added UseSimpleObjectNaming
  *					using new AjaxSecurityProvider
  *					fixed Ajax token
- * 
+ * MS	21-10-27	added allowed customized types for JSON deserialization
  */
 using System;
 using System.Collections;
@@ -127,6 +127,9 @@ internal AjaxSettings()
 			SerializableConverters = new JavaScriptConverterList();
 			DeserializableConverters = new JavaScriptConverterList();
 #endif
+
+			JsonDeserializationCustomTypesAllowed = new List<string>();
+			JsonDeserializationCustomTypesDenied = new List<string>();
 		}
 
 		#region Public Properties
@@ -244,6 +247,11 @@ internal System.Collections.Specialized.StringDictionary ScriptReplacements
 			set{ m_ScriptReplacements = value; }
 		}
 
+		public bool IsJsonDeserializationCustomTypesDenied { get; set; }
+
+		public List<string> JsonDeserializationCustomTypesAllowed { get; set; }
+		public List<string> JsonDeserializationCustomTypesDenied { get; set; }
+
 		#endregion
 	}
 #endif
diff --git a/AjaxPro/Utilities/Constant.cs b/AjaxPro/Utilities/Constant.cs
index cefabd8..b281e34 100644
--- a/AjaxPro/Utilities/Constant.cs
+++ b/AjaxPro/Utilities/Constant.cs
@@ -52,6 +52,6 @@ public sealed class Constant
         /// <summary>
 		/// The assembly version.
 		/// </summary>
-        public const string AssemblyVersion = "21.10.26.1";
+        public const string AssemblyVersion = "21.10.27.1";
 	}
 }
diff --git a/AjaxPro/core.js b/AjaxPro/core.js
index 3b394d6..9bb8243 100644
--- a/AjaxPro/core.js
+++ b/AjaxPro/core.js
@@ -169,7 +169,7 @@ Object.extend(AjaxPro, {
 	cryptProvider: null,
 	queue: null,
 	token: "",
-	version: "9.2.17.1",
+	version: "21.10.27.1",
 	ID: "AjaxPro",
 	noActiveX: false,
 	timeoutPeriod: 15*1000,
diff --git a/AjaxPro/jquery-1.3.1.js b/AjaxPro/jquery-1.3.1.js
deleted file mode 100644
index 94e9c17..0000000
--- a/AjaxPro/jquery-1.3.1.js
+++ /dev/null
@@ -1,4241 +0,0 @@
-/*!
- * jQuery JavaScript Library v1.3.1
- * http://jquery.com/
- *
- * Copyright (c) 2009 John Resig
- * Dual licensed under the MIT and GPL licenses.
- * http://docs.jquery.com/License
- *
- * Date: 2009-01-21 20:42:16 -0500 (Wed, 21 Jan 2009)
- * Revision: 6158
- */
-(function(){
-
-var 
-	// Will speed up references to window, and allows munging its name.
-	window = this,
-	// Will speed up references to undefined, and allows munging its name.
-	undefined,
-	// Map over jQuery in case of overwrite
-	_jQuery = window.jQuery,
-	// Map over the $ in case of overwrite
-	_$ = window.$,
-
-	jQuery = window.jQuery = window.$ = function( selector, context ) {
-		// The jQuery object is actually just the init constructor 'enhanced'
-		return new jQuery.fn.init( selector, context );
-	},
-
-	// A simple way to check for HTML strings or ID strings
-	// (both of which we optimize for)
-	quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,
-	// Is it a simple selector
-	isSimple = /^.[^:#\[\.,]*$/;
-
-jQuery.fn = jQuery.prototype = {
-	init: function( selector, context ) {
-		// Make sure that a selection was provided
-		selector = selector || document;
-
-		// Handle $(DOMElement)
-		if ( selector.nodeType ) {
-			this[0] = selector;
-			this.length = 1;
-			this.context = selector;
-			return this;
-		}
-		// Handle HTML strings
-		if ( typeof selector === "string" ) {
-			// Are we dealing with HTML string or an ID?
-			var match = quickExpr.exec( selector );
-
-			// Verify a match, and that no context was specified for #id
-			if ( match && (match[1] || !context) ) {
-
-				// HANDLE: $(html) -> $(array)
-				if ( match[1] )
-					selector = jQuery.clean( [ match[1] ], context );
-
-				// HANDLE: $("#id")
-				else {
-					var elem = document.getElementById( match[3] );
-
-					// Handle the case where IE and Opera return items
-					// by name instead of ID
-					if ( elem && elem.id != match[3] )
-						return jQuery().find( selector );
-
-					// Otherwise, we inject the element directly into the jQuery object
-					var ret = jQuery( elem || [] );
-					ret.context = document;
-					ret.selector = selector;
-					return ret;
-				}
-
-			// HANDLE: $(expr, [context])
-			// (which is just equivalent to: $(content).find(expr)
-			} else
-				return jQuery( context ).find( selector );
-
-		// HANDLE: $(function)
-		// Shortcut for document ready
-		} else if ( jQuery.isFunction( selector ) )
-			return jQuery( document ).ready( selector );
-
-		// Make sure that old selector state is passed along
-		if ( selector.selector && selector.context ) {
-			this.selector = selector.selector;
-			this.context = selector.context;
-		}
-
-		return this.setArray(jQuery.makeArray(selector));
-	},
-
-	// Start with an empty selector
-	selector: "",
-
-	// The current version of jQuery being used
-	jquery: "1.3.1",
-
-	// The number of elements contained in the matched element set
-	size: function() {
-		return this.length;
-	},
-
-	// Get the Nth element in the matched element set OR
-	// Get the whole matched element set as a clean array
-	get: function( num ) {
-		return num === undefined ?
-
-			// Return a 'clean' array
-			jQuery.makeArray( this ) :
-
-			// Return just the object
-			this[ num ];
-	},
-
-	// Take an array of elements and push it onto the stack
-	// (returning the new matched element set)
-	pushStack: function( elems, name, selector ) {
-		// Build a new jQuery matched element set
-		var ret = jQuery( elems );
-
-		// Add the old object onto the stack (as a reference)
-		ret.prevObject = this;
-
-		ret.context = this.context;
-
-		if ( name === "find" )
-			ret.selector = this.selector + (this.selector ? " " : "") + selector;
-		else if ( name )
-			ret.selector = this.selector + "." + name + "(" + selector + ")";
-
-		// Return the newly-formed element set
-		return ret;
-	},
-
-	// Force the current matched set of elements to become
-	// the specified array of elements (destroying the stack in the process)
-	// You should use pushStack() in order to do this, but maintain the stack
-	setArray: function( elems ) {
-		// Resetting the length to 0, then using the native Array push
-		// is a super-fast way to populate an object with array-like properties
-		this.length = 0;
-		Array.prototype.push.apply( this, elems );
-
-		return this;
-	},
-
-	// Execute a callback for every element in the matched set.
-	// (You can seed the arguments with an array of args, but this is
-	// only used internally.)
-	each: function( callback, args ) {
-		return jQuery.each( this, callback, args );
-	},
-
-	// Determine the position of an element within
-	// the matched set of elements
-	index: function( elem ) {
-		// Locate the position of the desired element
-		return jQuery.inArray(
-			// If it receives a jQuery object, the first element is used
-			elem && elem.jquery ? elem[0] : elem
-		, this );
-	},
-
-	attr: function( name, value, type ) {
-		var options = name;
-
-		// Look for the case where we're accessing a style value
-		if ( typeof name === "string" )
-			if ( value === undefined )
-				return this[0] && jQuery[ type || "attr" ]( this[0], name );
-
-			else {
-				options = {};
-				options[ name ] = value;
-			}
-
-		// Check to see if we're setting style values
-		return this.each(function(i){
-			// Set all the styles
-			for ( name in options )
-				jQuery.attr(
-					type ?
-						this.style :
-						this,
-					name, jQuery.prop( this, options[ name ], type, i, name )
-				);
-		});
-	},
-
-	css: function( key, value ) {
-		// ignore negative width and height values
-		if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
-			value = undefined;
-		return this.attr( key, value, "curCSS" );
-	},
-
-	text: function( text ) {
-		if ( typeof text !== "object" && text != null )
-			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
-
-		var ret = "";
-
-		jQuery.each( text || this, function(){
-			jQuery.each( this.childNodes, function(){
-				if ( this.nodeType != 8 )
-					ret += this.nodeType != 1 ?
-						this.nodeValue :
-						jQuery.fn.text( [ this ] );
-			});
-		});
-
-		return ret;
-	},
-
-	wrapAll: function( html ) {
-		if ( this[0] ) {
-			// The elements to wrap the target around
-			var wrap = jQuery( html, this[0].ownerDocument ).clone();
-
-			if ( this[0].parentNode )
-				wrap.insertBefore( this[0] );
-
-			wrap.map(function(){
-				var elem = this;
-
-				while ( elem.firstChild )
-					elem = elem.firstChild;
-
-				return elem;
-			}).append(this);
-		}
-
-		return this;
-	},
-
-	wrapInner: function( html ) {
-		return this.each(function(){
-			jQuery( this ).contents().wrapAll( html );
-		});
-	},
-
-	wrap: function( html ) {
-		return this.each(function(){
-			jQuery( this ).wrapAll( html );
-		});
-	},
-
-	append: function() {
-		return this.domManip(arguments, true, function(elem){
-			if (this.nodeType == 1)
-				this.appendChild( elem );
-		});
-	},
-
-	prepend: function() {
-		return this.domManip(arguments, true, function(elem){
-			if (this.nodeType == 1)
-				this.insertBefore( elem, this.firstChild );
-		});
-	},
-
-	before: function() {
-		return this.domManip(arguments, false, function(elem){
-			this.parentNode.insertBefore( elem, this );
-		});
-	},
-
-	after: function() {
-		return this.domManip(arguments, false, function(elem){
-			this.parentNode.insertBefore( elem, this.nextSibling );
-		});
-	},
-
-	end: function() {
-		return this.prevObject || jQuery( [] );
-	},
-
-	// For internal use only.
-	// Behaves like an Array's .push method, not like a jQuery method.
-	push: [].push,
-
-	find: function( selector ) {
-		if ( this.length === 1 && !/,/.test(selector) ) {
-			var ret = this.pushStack( [], "find", selector );
-			ret.length = 0;
-			jQuery.find( selector, this[0], ret );
-			return ret;
-		} else {
-			var elems = jQuery.map(this, function(elem){
-				return jQuery.find( selector, elem );
-			});
-
-			return this.pushStack( /[^+>] [^+>]/.test( selector ) ?
-				jQuery.unique( elems ) :
-				elems, "find", selector );
-		}
-	},
-
-	clone: function( events ) {
-		// Do the clone
-		var ret = this.map(function(){
-			if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
-				// IE copies events bound via attachEvent when
-				// using cloneNode. Calling detachEvent on the
-				// clone will also remove the events from the orignal
-				// In order to get around this, we use innerHTML.
-				// Unfortunately, this means some modifications to
-				// attributes in IE that are actually only stored
-				// as properties will not be copied (such as the
-				// the name attribute on an input).
-				var clone = this.cloneNode(true),
-					container = document.createElement("div");
-				container.appendChild(clone);
-				return jQuery.clean([container.innerHTML])[0];
-			} else
-				return this.cloneNode(true);
-		});
-
-		// Need to set the expando to null on the cloned set if it exists
-		// removeData doesn't work here, IE removes it from the original as well
-		// this is primarily for IE but the data expando shouldn't be copied over in any browser
-		var clone = ret.find("*").andSelf().each(function(){
-			if ( this[ expando ] !== undefined )
-				this[ expando ] = null;
-		});
-
-		// Copy the events from the original to the clone
-		if ( events === true )
-			this.find("*").andSelf().each(function(i){
-				if (this.nodeType == 3)
-					return;
-				var events = jQuery.data( this, "events" );
-
-				for ( var type in events )
-					for ( var handler in events[ type ] )
-						jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
-			});
-
-		// Return the cloned set
-		return ret;
-	},
-
-	filter: function( selector ) {
-		return this.pushStack(
-			jQuery.isFunction( selector ) &&
-			jQuery.grep(this, function(elem, i){
-				return selector.call( elem, i );
-			}) ||
-
-			jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
-				return elem.nodeType === 1;
-			}) ), "filter", selector );
-	},
-
-	closest: function( selector ) {
-		var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null;
-
-		return this.map(function(){
-			var cur = this;
-			while ( cur && cur.ownerDocument ) {
-				if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) )
-					return cur;
-				cur = cur.parentNode;
-			}
-		});
-	},
-
-	not: function( selector ) {
-		if ( typeof selector === "string" )
-			// test special case where just one selector is passed in
-			if ( isSimple.test( selector ) )
-				return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
-			else
-				selector = jQuery.multiFilter( selector, this );
-
-		var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
-		return this.filter(function() {
-			return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
-		});
-	},
-
-	add: function( selector ) {
-		return this.pushStack( jQuery.unique( jQuery.merge(
-			this.get(),
-			typeof selector === "string" ?
-				jQuery( selector ) :
-				jQuery.makeArray( selector )
-		)));
-	},
-
-	is: function( selector ) {
-		return !!selector && jQuery.multiFilter( selector, this ).length > 0;
-	},
-
-	hasClass: function( selector ) {
-		return !!selector && this.is( "." + selector );
-	},
-
-	val: function( value ) {
-		if ( value === undefined ) {			
-			var elem = this[0];
-
-			if ( elem ) {
-				if( jQuery.nodeName( elem, 'option' ) )
-					return (elem.attributes.value || {}).specified ? elem.value : elem.text;
-				
-				// We need to handle select boxes special
-				if ( jQuery.nodeName( elem, "select" ) ) {
-					var index = elem.selectedIndex,
-						values = [],
-						options = elem.options,
-						one = elem.type == "select-one";
-
-					// Nothing was selected
-					if ( index < 0 )
-						return null;
-
-					// Loop through all the selected options
-					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
-						var option = options[ i ];
-
-						if ( option.selected ) {
-							// Get the specifc value for the option
-							value = jQuery(option).val();
-
-							// We don't need an array for one selects
-							if ( one )
-								return value;
-
-							// Multi-Selects return an array
-							values.push( value );
-						}
-					}
-
-					return values;				
-				}
-
-				// Everything else, we just grab the value
-				return (elem.value || "").replace(/\r/g, "");
-
-			}
-
-			return undefined;
-		}
-
-		if ( typeof value === "number" )
-			value += '';
-
-		return this.each(function(){
-			if ( this.nodeType != 1 )
-				return;
-
-			if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) )
-				this.checked = (jQuery.inArray(this.value, value) >= 0 ||
-					jQuery.inArray(this.name, value) >= 0);
-
-			else if ( jQuery.nodeName( this, "select" ) ) {
-				var values = jQuery.makeArray(value);
-
-				jQuery( "option", this ).each(function(){
-					this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
-						jQuery.inArray( this.text, values ) >= 0);
-				});
-
-				if ( !values.length )
-					this.selectedIndex = -1;
-
-			} else
-				this.value = value;
-		});
-	},
-
-	html: function( value ) {
-		return value === undefined ?
-			(this[0] ?
-				this[0].innerHTML :
-				null) :
-			this.empty().append( value );
-	},
-
-	replaceWith: function( value ) {
-		return this.after( value ).remove();
-	},
-
-	eq: function( i ) {
-		return this.slice( i, +i + 1 );
-	},
-
-	slice: function() {
-		return this.pushStack( Array.prototype.slice.apply( this, arguments ),
-			"slice", Array.prototype.slice.call(arguments).join(",") );
-	},
-
-	map: function( callback ) {
-		return this.pushStack( jQuery.map(this, function(elem, i){
-			return callback.call( elem, i, elem );
-		}));
-	},
-
-	andSelf: function() {
-		return this.add( this.prevObject );
-	},
-
-	domManip: function( args, table, callback ) {
-		if ( this[0] ) {
-			var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),
-				scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ),
-				first = fragment.firstChild,
-				extra = this.length > 1 ? fragment.cloneNode(true) : fragment;
-
-			if ( first )
-				for ( var i = 0, l = this.length; i < l; i++ )
-					callback.call( root(this[i], first), i > 0 ? extra.cloneNode(true) : fragment );
-			
-			if ( scripts )
-				jQuery.each( scripts, evalScript );
-		}
-
-		return this;
-		
-		function root( elem, cur ) {
-			return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
-				(elem.getElementsByTagName("tbody")[0] ||
-				elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
-				elem;
-		}
-	}
-};
-
-// Give the init function the jQuery prototype for later instantiation
-jQuery.fn.init.prototype = jQuery.fn;
-
-function evalScript( i, elem ) {
-	if ( elem.src )
-		jQuery.ajax({
-			url: elem.src,
-			async: false,
-			dataType: "script"
-		});
-
-	else
-		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
-
-	if ( elem.parentNode )
-		elem.parentNode.removeChild( elem );
-}
-
-function now(){
-	return +new Date;
-}
-
-jQuery.extend = jQuery.fn.extend = function() {
-	// copy reference to target object
-	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
-
-	// Handle a deep copy situation
-	if ( typeof target === "boolean" ) {
-		deep = target;
-		target = arguments[1] || {};
-		// skip the boolean and the target
-		i = 2;
-	}
-
-	// Handle case when target is a string or something (possible in deep copy)
-	if ( typeof target !== "object" && !jQuery.isFunction(target) )
-		target = {};
-
-	// extend jQuery itself if only one argument is passed
-	if ( length == i ) {
-		target = this;
-		--i;
-	}
-
-	for ( ; i < length; i++ )
-		// Only deal with non-null/undefined values
-		if ( (options = arguments[ i ]) != null )
-			// Extend the base object
-			for ( var name in options ) {
-				var src = target[ name ], copy = options[ name ];
-
-				// Prevent never-ending loop
-				if ( target === copy )
-					continue;
-
-				// Recurse if we're merging object values
-				if ( deep && copy && typeof copy === "object" && !copy.nodeType )
-					target[ name ] = jQuery.extend( deep, 
-						// Never move original objects, clone them
-						src || ( copy.length != null ? [ ] : { } )
-					, copy );
-
-				// Don't bring in undefined values
-				else if ( copy !== undefined )
-					target[ name ] = copy;
-
-			}
-
-	// Return the modified object
-	return target;
-};
-
-// exclude the following css properties to add px
-var	exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
-	// cache defaultView
-	defaultView = document.defaultView || {},
-	toString = Object.prototype.toString;
-
-jQuery.extend({
-	noConflict: function( deep ) {
-		window.$ = _$;
-
-		if ( deep )
-			window.jQuery = _jQuery;
-
-		return jQuery;
-	},
-
-	// See test/unit/core.js for details concerning isFunction.
-	// Since version 1.3, DOM methods and functions like alert
-	// aren't supported. They return false on IE (#2968).
-	isFunction: function( obj ) {
-		return toString.call(obj) === "[object Function]";
-	},
-
-	isArray: function( obj ) {
-		return toString.call(obj) === "[object Array]";
-	},
-
-	// check if an element is in a (or is an) XML document
-	isXMLDoc: function( elem ) {
-		return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
-			!!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument );
-	},
-
-	// Evalulates a script in a global context
-	globalEval: function( data ) {
-		data = jQuery.trim( data );
-
-		if ( data ) {
-			// Inspired by code by Andrea Giammarchi
-			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
-			var head = document.getElementsByTagName("head")[0] || document.documentElement,
-				script = document.createElement("script");
-
-			script.type = "text/javascript";
-			if ( jQuery.support.scriptEval )
-				script.appendChild( document.createTextNode( data ) );
-			else
-				script.text = data;
-
-			// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
-			// This arises when a base node is used (#2709).
-			head.insertBefore( script, head.firstChild );
-			head.removeChild( script );
-		}
-	},
-
-	nodeName: function( elem, name ) {
-		return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
-	},
-
-	// args is for internal usage only
-	each: function( object, callback, args ) {
-		var name, i = 0, length = object.length;
-
-		if ( args ) {
-			if ( length === undefined ) {
-				for ( name in object )
-					if ( callback.apply( object[ name ], args ) === false )
-						break;
-			} else
-				for ( ; i < length; )
-					if ( callback.apply( object[ i++ ], args ) === false )
-						break;
-
-		// A special, fast, case for the most common use of each
-		} else {
-			if ( length === undefined ) {
-				for ( name in object )
-					if ( callback.call( object[ name ], name, object[ name ] ) === false )
-						break;
-			} else
-				for ( var value = object[0];
-					i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
-		}
-
-		return object;
-	},
-
-	prop: function( elem, value, type, i, name ) {
-		// Handle executable functions
-		if ( jQuery.isFunction( value ) )
-			value = value.call( elem, i );
-
-		// Handle passing in a number to a CSS property
-		return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?
-			value + "px" :
-			value;
-	},
-
-	className: {
-		// internal only, use addClass("class")
-		add: function( elem, classNames ) {
-			jQuery.each((classNames || "").split(/\s+/), function(i, className){
-				if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
-					elem.className += (elem.className ? " " : "") + className;
-			});
-		},
-
-		// internal only, use removeClass("class")
-		remove: function( elem, classNames ) {
-			if (elem.nodeType == 1)
-				elem.className = classNames !== undefined ?
-					jQuery.grep(elem.className.split(/\s+/), function(className){
-						return !jQuery.className.has( classNames, className );
-					}).join(" ") :
-					"";
-		},
-
-		// internal only, use hasClass("class")
-		has: function( elem, className ) {
-			return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
-		}
-	},
-
-	// A method for quickly swapping in/out CSS properties to get correct calculations
-	swap: function( elem, options, callback ) {
-		var old = {};
-		// Remember the old values, and insert the new ones
-		for ( var name in options ) {
-			old[ name ] = elem.style[ name ];
-			elem.style[ name ] = options[ name ];
-		}
-
-		callback.call( elem );
-
-		// Revert the old values
-		for ( var name in options )
-			elem.style[ name ] = old[ name ];
-	},
-
-	css: function( elem, name, force ) {
-		if ( name == "width" || name == "height" ) {
-			var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
-
-			function getWH() {
-				val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
-				var padding = 0, border = 0;
-				jQuery.each( which, function() {
-					padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
-					border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
-				});
-				val -= Math.round(padding + border);
-			}
-
-			if ( jQuery(elem).is(":visible") )
-				getWH();
-			else
-				jQuery.swap( elem, props, getWH );
-
-			return Math.max(0, val);
-		}
-
-		return jQuery.curCSS( elem, name, force );
-	},
-
-	curCSS: function( elem, name, force ) {
-		var ret, style = elem.style;
-
-		// We need to handle opacity special in IE
-		if ( name == "opacity" && !jQuery.support.opacity ) {
-			ret = jQuery.attr( style, "opacity" );
-
-			return ret == "" ?
-				"1" :
-				ret;
-		}
-
-		// Make sure we're using the right name for getting the float value
-		if ( name.match( /float/i ) )
-			name = styleFloat;
-
-		if ( !force && style && style[ name ] )
-			ret = style[ name ];
-
-		else if ( defaultView.getComputedStyle ) {
-
-			// Only "float" is needed here
-			if ( name.match( /float/i ) )
-				name = "float";
-
-			name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
-
-			var computedStyle = defaultView.getComputedStyle( elem, null );
-
-			if ( computedStyle )
-				ret = computedStyle.getPropertyValue( name );
-
-			// We should always get a number back from opacity
-			if ( name == "opacity" && ret == "" )
-				ret = "1";
-
-		} else if ( elem.currentStyle ) {
-			var camelCase = name.replace(/\-(\w)/g, function(all, letter){
-				return letter.toUpperCase();
-			});
-
-			ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
-
-			// From the awesome hack by Dean Edwards
-			// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
-
-			// If we're not dealing with a regular pixel number
-			// but a number that has a weird ending, we need to convert it to pixels
-			if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
-				// Remember the original values
-				var left = style.left, rsLeft = elem.runtimeStyle.left;
-
-				// Put in the new values to get a computed value out
-				elem.runtimeStyle.left = elem.currentStyle.left;
-				style.left = ret || 0;
-				ret = style.pixelLeft + "px";
-
-				// Revert the changed values
-				style.left = left;
-				elem.runtimeStyle.left = rsLeft;
-			}
-		}
-
-		return ret;
-	},
-
-	clean: function( elems, context, fragment ) {
-		context = context || document;
-
-		// !context.createElement fails in IE with an error but returns typeof 'object'
-		if ( typeof context.createElement === "undefined" )
-			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
-
-		// If a single string is passed in and it's a single tag
-		// just do a createElement and skip the rest
-		if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {
-			var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);
-			if ( match )
-				return [ context.createElement( match[1] ) ];
-		}
-
-		var ret = [], scripts = [], div = context.createElement("div");
-
-		jQuery.each(elems, function(i, elem){
-			if ( typeof elem === "number" )
-				elem += '';
-
-			if ( !elem )
-				return;
-
-			// Convert html string into DOM nodes
-			if ( typeof elem === "string" ) {
-				// Fix "XHTML"-style tags in all browsers
-				elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
-					return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
-						all :
-						front + "></" + tag + ">";
-				});
-
-				// Trim whitespace, otherwise indexOf won't work as expected
-				var tags = jQuery.trim( elem ).toLowerCase();
-
-				var wrap =
-					// option or optgroup
-					!tags.indexOf("<opt") &&
-					[ 1, "<select multiple='multiple'>", "</select>" ] ||
-
-					!tags.indexOf("<leg") &&
-					[ 1, "<fieldset>", "</fieldset>" ] ||
-
-					tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
-					[ 1, "<table>", "</table>" ] ||
-
-					!tags.indexOf("<tr") &&
-					[ 2, "<table><tbody>", "</tbody></table>" ] ||
-
-				 	// <thead> matched above
-					(!tags.indexOf("<td") || !tags.indexOf("<th")) &&
-					[ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
-
-					!tags.indexOf("<col") &&
-					[ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
-
-					// IE can't serialize <link> and <script> tags normally
-					!jQuery.support.htmlSerialize &&
-					[ 1, "div<div>", "</div>" ] ||
-
-					[ 0, "", "" ];
-
-				// Go to html and back, then peel off extra wrappers
-				div.innerHTML = wrap[1] + elem + wrap[2];
-
-				// Move to the right depth
-				while ( wrap[0]-- )
-					div = div.lastChild;
-
-				// Remove IE's autoinserted <tbody> from table fragments
-				if ( !jQuery.support.tbody ) {
-
-					// String was a <table>, *may* have spurious <tbody>
-					var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
-						div.firstChild && div.firstChild.childNodes :
-
-						// String was a bare <thead> or <tfoot>
-						wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
-							div.childNodes :
-							[];
-
-					for ( var j = tbody.length - 1; j >= 0 ; --j )
-						if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
-							tbody[ j ].parentNode.removeChild( tbody[ j ] );
-
-					}
-
-				// IE completely kills leading whitespace when innerHTML is used
-				if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) )
-					div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
-				
-				elem = jQuery.makeArray( div.childNodes );
-			}
-
-			if ( elem.nodeType )
-				ret.push( elem );
-			else
-				ret = jQuery.merge( ret, elem );
-
-		});
-
-		if ( fragment ) {
-			for ( var i = 0; ret[i]; i++ ) {
-				if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
-					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
-				} else {
-					if ( ret[i].nodeType === 1 )
-						ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
-					fragment.appendChild( ret[i] );
-				}
-			}
-			
-			return scripts;
-		}
-
-		return ret;
-	},
-
-	attr: function( elem, name, value ) {
-		// don't set attributes on text and comment nodes
-		if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
-			return undefined;
-
-		var notxml = !jQuery.isXMLDoc( elem ),
-			// Whether we are setting (or getting)
-			set = value !== undefined;
-
-		// Try to normalize/fix the name
-		name = notxml && jQuery.props[ name ] || name;
-
-		// Only do all the following if this is a node (faster for style)
-		// IE elem.getAttribute passes even for style
-		if ( elem.tagName ) {
-
-			// These attributes require special treatment
-			var special = /href|src|style/.test( name );
-
-			// Safari mis-reports the default selected property of a hidden option
-			// Accessing the parent's selectedIndex property fixes it
-			if ( name == "selected" && elem.parentNode )
-				elem.parentNode.selectedIndex;
-
-			// If applicable, access the attribute via the DOM 0 way
-			if ( name in elem && notxml && !special ) {
-				if ( set ){
-					// We can't allow the type property to be changed (since it causes problems in IE)
-					if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
-						throw "type property can't be changed";
-
-					elem[ name ] = value;
-				}
-
-				// browsers index elements by id/name on forms, give priority to attributes.
-				if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
-					return elem.getAttributeNode( name ).nodeValue;
-
-				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
-				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
-				if ( name == "tabIndex" ) {
-					var attributeNode = elem.getAttributeNode( "tabIndex" );
-					return attributeNode && attributeNode.specified
-						? attributeNode.value
-						: elem.nodeName.match(/(button|input|object|select|textarea)/i)
-							? 0
-							: elem.nodeName.match(/^(a|area)$/i) && elem.href
-								? 0
-								: undefined;
-				}
-
-				return elem[ name ];
-			}
-
-			if ( !jQuery.support.style && notxml &&  name == "style" )
-				return jQuery.attr( elem.style, "cssText", value );
-
-			if ( set )
-				// convert the value to a string (all browsers do this but IE) see #1070
-				elem.setAttribute( name, "" + value );
-
-			var attr = !jQuery.support.hrefNormalized && notxml && special
-					// Some attributes require a special call on IE
-					? elem.getAttribute( name, 2 )
-					: elem.getAttribute( name );
-
-			// Non-existent attributes return null, we normalize to undefined
-			return attr === null ? undefined : attr;
-		}
-
-		// elem is actually elem.style ... set the style
-
-		// IE uses filters for opacity
-		if ( !jQuery.support.opacity && name == "opacity" ) {
-			if ( set ) {
-				// IE has trouble with opacity if it does not have layout
-				// Force it by setting the zoom level
-				elem.zoom = 1;
-
-				// Set the alpha filter to set the opacity
-				elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
-					(parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
-			}
-
-			return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
-				(parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
-				"";
-		}
-
-		name = name.replace(/-([a-z])/ig, function(all, letter){
-			return letter.toUpperCase();
-		});
-
-		if ( set )
-			elem[ name ] = value;
-
-		return elem[ name ];
-	},
-
-	trim: function( text ) {
-		return (text || "").replace( /^\s+|\s+$/g, "" );
-	},
-
-	makeArray: function( array ) {
-		var ret = [];
-
-		if( array != null ){
-			var i = array.length;
-			// The window, strings (and functions) also have 'length'
-			if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval )
-				ret[0] = array;
-			else
-				while( i )
-					ret[--i] = array[i];
-		}
-
-		return ret;
-	},
-
-	inArray: function( elem, array ) {
-		for ( var i = 0, length = array.length; i < length; i++ )
-		// Use === because on IE, window == document
-			if ( array[ i ] === elem )
-				return i;
-
-		return -1;
-	},
-
-	merge: function( first, second ) {
-		// We have to loop this way because IE & Opera overwrite the length
-		// expando of getElementsByTagName
-		var i = 0, elem, pos = first.length;
-		// Also, we need to make sure that the correct elements are being returned
-		// (IE returns comment nodes in a '*' query)
-		if ( !jQuery.support.getAll ) {
-			while ( (elem = second[ i++ ]) != null )
-				if ( elem.nodeType != 8 )
-					first[ pos++ ] = elem;
-
-		} else
-			while ( (elem = second[ i++ ]) != null )
-				first[ pos++ ] = elem;
-
-		return first;
-	},
-
-	unique: function( array ) {
-		var ret = [], done = {};
-
-		try {
-
-			for ( var i = 0, length = array.length; i < length; i++ ) {
-				var id = jQuery.data( array[ i ] );
-
-				if ( !done[ id ] ) {
-					done[ id ] = true;
-					ret.push( array[ i ] );
-				}
-			}
-
-		} catch( e ) {
-			ret = array;
-		}
-
-		return ret;
-	},
-
-	grep: function( elems, callback, inv ) {
-		var ret = [];
-
-		// Go through the array, only saving the items
-		// that pass the validator function
-		for ( var i = 0, length = elems.length; i < length; i++ )
-			if ( !inv != !callback( elems[ i ], i ) )
-				ret.push( elems[ i ] );
-
-		return ret;
-	},
-
-	map: function( elems, callback ) {
-		var ret = [];
-
-		// Go through the array, translating each of the items to their
-		// new value (or values).
-		for ( var i = 0, length = elems.length; i < length; i++ ) {
-			var value = callback( elems[ i ], i );
-
-			if ( value != null )
-				ret[ ret.length ] = value;
-		}
-
-		return ret.concat.apply( [], ret );
-	}
-});
-
-// Use of jQuery.browser is deprecated.
-// It's included for backwards compatibility and plugins,
-// although they should work to migrate away.
-
-var userAgent = navigator.userAgent.toLowerCase();
-
-// Figure out what browser is being used
-jQuery.browser = {
-	version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],
-	safari: /webkit/.test( userAgent ),
-	opera: /opera/.test( userAgent ),
-	msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
-	mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
-};
-
-jQuery.each({
-	parent: function(elem){return elem.parentNode;},
-	parents: function(elem){return jQuery.dir(elem,"parentNode");},
-	next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
-	prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
-	nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
-	prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
-	siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
-	children: function(elem){return jQuery.sibling(elem.firstChild);},
-	contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
-}, function(name, fn){
-	jQuery.fn[ name ] = function( selector ) {
-		var ret = jQuery.map( this, fn );
-
-		if ( selector && typeof selector == "string" )
-			ret = jQuery.multiFilter( selector, ret );
-
-		return this.pushStack( jQuery.unique( ret ), name, selector );
-	};
-});
-
-jQuery.each({
-	appendTo: "append",
-	prependTo: "prepend",
-	insertBefore: "before",
-	insertAfter: "after",
-	replaceAll: "replaceWith"
-}, function(name, original){
-	jQuery.fn[ name ] = function() {
-		var args = arguments;
-
-		return this.each(function(){
-			for ( var i = 0, length = args.length; i < length; i++ )
-				jQuery( args[ i ] )[ original ]( this );
-		});
-	};
-});
-
-jQuery.each({
-	removeAttr: function( name ) {
-		jQuery.attr( this, name, "" );
-		if (this.nodeType == 1)
-			this.removeAttribute( name );
-	},
-
-	addClass: function( classNames ) {
-		jQuery.className.add( this, classNames );
-	},
-
-	removeClass: function( classNames ) {
-		jQuery.className.remove( this, classNames );
-	},
-
-	toggleClass: function( classNames, state ) {
-		if( typeof state !== "boolean" )
-			state = !jQuery.className.has( this, classNames );
-		jQuery.className[ state ? "add" : "remove" ]( this, classNames );
-	},
-
-	remove: function( selector ) {
-		if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
-			// Prevent memory leaks
-			jQuery( "*", this ).add([this]).each(function(){
-				jQuery.event.remove(this);
-				jQuery.removeData(this);
-			});
-			if (this.parentNode)
-				this.parentNode.removeChild( this );
-		}
-	},
-
-	empty: function() {
-		// Remove element nodes and prevent memory leaks
-		jQuery( ">*", this ).remove();
-
-		// Remove any remaining nodes
-		while ( this.firstChild )
-			this.removeChild( this.firstChild );
-	}
-}, function(name, fn){
-	jQuery.fn[ name ] = function(){
-		return this.each( fn, arguments );
-	};
-});
-
-// Helper function used by the dimensions and offset modules
-function num(elem, prop) {
-	return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
-}
-var expando = "jQuery" + now(), uuid = 0, windowData = {};
-
-jQuery.extend({
-	cache: {},
-
-	data: function( elem, name, data ) {
-		elem = elem == window ?
-			windowData :
-			elem;
-
-		var id = elem[ expando ];
-
-		// Compute a unique ID for the element
-		if ( !id )
-			id = elem[ expando ] = ++uuid;
-
-		// Only generate the data cache if we're
-		// trying to access or manipulate it
-		if ( name && !jQuery.cache[ id ] )
-			jQuery.cache[ id ] = {};
-
-		// Prevent overriding the named cache with undefined values
-		if ( data !== undefined )
-			jQuery.cache[ id ][ name ] = data;
-
-		// Return the named cache data, or the ID for the element
-		return name ?
-			jQuery.cache[ id ][ name ] :
-			id;
-	},
-
-	removeData: function( elem, name ) {
-		elem = elem == window ?
-			windowData :
-			elem;
-
-		var id = elem[ expando ];
-
-		// If we want to remove a specific section of the element's data
-		if ( name ) {
-			if ( jQuery.cache[ id ] ) {
-				// Remove the section of cache data
-				delete jQuery.cache[ id ][ name ];
-
-				// If we've removed all the data, remove the element's cache
-				name = "";
-
-				for ( name in jQuery.cache[ id ] )
-					break;
-
-				if ( !name )
-					jQuery.removeData( elem );
-			}
-
-		// Otherwise, we want to remove all of the element's data
-		} else {
-			// Clean up the element expando
-			try {
-				delete elem[ expando ];
-			} catch(e){
-				// IE has trouble directly removing the expando
-				// but it's ok with using removeAttribute
-				if ( elem.removeAttribute )
-					elem.removeAttribute( expando );
-			}
-
-			// Completely remove the data cache
-			delete jQuery.cache[ id ];
-		}
-	},
-	queue: function( elem, type, data ) {
-		if ( elem ){
-	
-			type = (type || "fx") + "queue";
-	
-			var q = jQuery.data( elem, type );
-	
-			if ( !q || jQuery.isArray(data) )
-				q = jQuery.data( elem, type, jQuery.makeArray(data) );
-			else if( data )
-				q.push( data );
-	
-		}
-		return q;
-	},
-
-	dequeue: function( elem, type ){
-		var queue = jQuery.queue( elem, type ),
-			fn = queue.shift();
-		
-		if( !type || type === "fx" )
-			fn = queue[0];
-			
-		if( fn !== undefined )
-			fn.call(elem);
-	}
-});
-
-jQuery.fn.extend({
-	data: function( key, value ){
-		var parts = key.split(".");
-		parts[1] = parts[1] ? "." + parts[1] : "";
-
-		if ( value === undefined ) {
-			var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
-
-			if ( data === undefined && this.length )
-				data = jQuery.data( this[0], key );
-
-			return data === undefined && parts[1] ?
-				this.data( parts[0] ) :
-				data;
-		} else
-			return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
-				jQuery.data( this, key, value );
-			});
-	},
-
-	removeData: function( key ){
-		return this.each(function(){
-			jQuery.removeData( this, key );
-		});
-	},
-	queue: function(type, data){
-		if ( typeof type !== "string" ) {
-			data = type;
-			type = "fx";
-		}
-
-		if ( data === undefined )
-			return jQuery.queue( this[0], type );
-
-		return this.each(function(){
-			var queue = jQuery.queue( this, type, data );
-			
-			 if( type == "fx" && queue.length == 1 )
-				queue[0].call(this);
-		});
-	},
-	dequeue: function(type){
-		return this.each(function(){
-			jQuery.dequeue( this, type );
-		});
-	}
-});/*!
- * Sizzle CSS Selector Engine - v0.9.3
- *  Copyright 2009, The Dojo Foundation
- *  Released under the MIT, BSD, and GPL Licenses.
- *  More information: http://sizzlejs.com/
- */
-(function(){
-
-var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]+['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[]+)+|[>+~])(\s*,\s*)?/g,
-	done = 0,
-	toString = Object.prototype.toString;
-
-var Sizzle = function(selector, context, results, seed) {
-	results = results || [];
-	context = context || document;
-
-	if ( context.nodeType !== 1 && context.nodeType !== 9 )
-		return [];
-	
-	if ( !selector || typeof selector !== "string" ) {
-		return results;
-	}
-
-	var parts = [], m, set, checkSet, check, mode, extra, prune = true;
-	
-	// Reset the position of the chunker regexp (start from head)
-	chunker.lastIndex = 0;
-	
-	while ( (m = chunker.exec(selector)) !== null ) {
-		parts.push( m[1] );
-		
-		if ( m[2] ) {
-			extra = RegExp.rightContext;
-			break;
-		}
-	}
-
-	if ( parts.length > 1 && origPOS.exec( selector ) ) {
-		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
-			set = posProcess( parts[0] + parts[1], context );
-		} else {
-			set = Expr.relative[ parts[0] ] ?
-				[ context ] :
-				Sizzle( parts.shift(), context );
-
-			while ( parts.length ) {
-				selector = parts.shift();
-
-				if ( Expr.relative[ selector ] )
-					selector += parts.shift();
-
-				set = posProcess( selector, set );
-			}
-		}
-	} else {
-		var ret = seed ?
-			{ expr: parts.pop(), set: makeArray(seed) } :
-			Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) );
-		set = Sizzle.filter( ret.expr, ret.set );
-
-		if ( parts.length > 0 ) {
-			checkSet = makeArray(set);
-		} else {
-			prune = false;
-		}
-
-		while ( parts.length ) {
-			var cur = parts.pop(), pop = cur;
-
-			if ( !Expr.relative[ cur ] ) {
-				cur = "";
-			} else {
-				pop = parts.pop();
-			}
-
-			if ( pop == null ) {
-				pop = context;
-			}
-
-			Expr.relative[ cur ]( checkSet, pop, isXML(context) );
-		}
-	}
-
-	if ( !checkSet ) {
-		checkSet = set;
-	}
-
-	if ( !checkSet ) {
-		throw "Syntax error, unrecognized expression: " + (cur || selector);
-	}
-
-	if ( toString.call(checkSet) === "[object Array]" ) {
-		if ( !prune ) {
-			results.push.apply( results, checkSet );
-		} else if ( context.nodeType === 1 ) {
-			for ( var i = 0; checkSet[i] != null; i++ ) {
-				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
-					results.push( set[i] );
-				}
-			}
-		} else {
-			for ( var i = 0; checkSet[i] != null; i++ ) {
-				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
-					results.push( set[i] );
-				}
-			}
-		}
-	} else {
-		makeArray( checkSet, results );
-	}
-
-	if ( extra ) {
-		Sizzle( extra, context, results, seed );
-	}
-
-	return results;
-};
-
-Sizzle.matches = function(expr, set){
-	return Sizzle(expr, null, null, set);
-};
-
-Sizzle.find = function(expr, context, isXML){
-	var set, match;
-
-	if ( !expr ) {
-		return [];
-	}
-
-	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
-		var type = Expr.order[i], match;
-		
-		if ( (match = Expr.match[ type ].exec( expr )) ) {
-			var left = RegExp.leftContext;
-
-			if ( left.substr( left.length - 1 ) !== "\\" ) {
-				match[1] = (match[1] || "").replace(/\\/g, "");
-				set = Expr.find[ type ]( match, context, isXML );
-				if ( set != null ) {
-					expr = expr.replace( Expr.match[ type ], "" );
-					break;
-				}
-			}
-		}
-	}
-
-	if ( !set ) {
-		set = context.getElementsByTagName("*");
-	}
-
-	return {set: set, expr: expr};
-};
-
-Sizzle.filter = function(expr, set, inplace, not){
-	var old = expr, result = [], curLoop = set, match, anyFound;
-
-	while ( expr && set.length ) {
-		for ( var type in Expr.filter ) {
-			if ( (match = Expr.match[ type ].exec( expr )) != null ) {
-				var filter = Expr.filter[ type ], found, item;
-				anyFound = false;
-
-				if ( curLoop == result ) {
-					result = [];
-				}
-
-				if ( Expr.preFilter[ type ] ) {
-					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not );
-
-					if ( !match ) {
-						anyFound = found = true;
-					} else if ( match === true ) {
-						continue;
-					}
-				}
-
-				if ( match ) {
-					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
-						if ( item ) {
-							found = filter( item, match, i, curLoop );
-							var pass = not ^ !!found;
-
-							if ( inplace && found != null ) {
-								if ( pass ) {
-									anyFound = true;
-								} else {
-									curLoop[i] = false;
-								}
-							} else if ( pass ) {
-								result.push( item );
-								anyFound = true;
-							}
-						}
-					}
-				}
-
-				if ( found !== undefined ) {
-					if ( !inplace ) {
-						curLoop = result;
-					}
-
-					expr = expr.replace( Expr.match[ type ], "" );
-
-					if ( !anyFound ) {
-						return [];
-					}
-
-					break;
-				}
-			}
-		}
-
-		expr = expr.replace(/\s*,\s*/, "");
-
-		// Improper expression
-		if ( expr == old ) {
-			if ( anyFound == null ) {
-				throw "Syntax error, unrecognized expression: " + expr;
-			} else {
-				break;
-			}
-		}
-
-		old = expr;
-	}
-
-	return curLoop;
-};
-
-var Expr = Sizzle.selectors = {
-	order: [ "ID", "NAME", "TAG" ],
-	match: {
-		ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
-		CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
-		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/,
-		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
-		TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/,
-		CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
-		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
-		PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
-	},
-	attrMap: {
-		"class": "className",
-		"for": "htmlFor"
-	},
-	attrHandle: {
-		href: function(elem){
-			return elem.getAttribute("href");
-		}
-	},
-	relative: {
-		"+": function(checkSet, part){
-			for ( var i = 0, l = checkSet.length; i < l; i++ ) {
-				var elem = checkSet[i];
-				if ( elem ) {
-					var cur = elem.previousSibling;
-					while ( cur && cur.nodeType !== 1 ) {
-						cur = cur.previousSibling;
-					}
-					checkSet[i] = typeof part === "string" ?
-						cur || false :
-						cur === part;
-				}
-			}
-
-			if ( typeof part === "string" ) {
-				Sizzle.filter( part, checkSet, true );
-			}
-		},
-		">": function(checkSet, part, isXML){
-			if ( typeof part === "string" && !/\W/.test(part) ) {
-				part = isXML ? part : part.toUpperCase();
-
-				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
-					var elem = checkSet[i];
-					if ( elem ) {
-						var parent = elem.parentNode;
-						checkSet[i] = parent.nodeName === part ? parent : false;
-					}
-				}
-			} else {
-				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
-					var elem = checkSet[i];
-					if ( elem ) {
-						checkSet[i] = typeof part === "string" ?
-							elem.parentNode :
-							elem.parentNode === part;
-					}
-				}
-
-				if ( typeof part === "string" ) {
-					Sizzle.filter( part, checkSet, true );
-				}
-			}
-		},
-		"": function(checkSet, part, isXML){
-			var doneName = "done" + (done++), checkFn = dirCheck;
-
-			if ( !part.match(/\W/) ) {
-				var nodeCheck = part = isXML ? part : part.toUpperCase();
-				checkFn = dirNodeCheck;
-			}
-
-			checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
-		},
-		"~": function(checkSet, part, isXML){
-			var doneName = "done" + (done++), checkFn = dirCheck;
-
-			if ( typeof part === "string" && !part.match(/\W/) ) {
-				var nodeCheck = part = isXML ? part : part.toUpperCase();
-				checkFn = dirNodeCheck;
-			}
-
-			checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
-		}
-	},
-	find: {
-		ID: function(match, context, isXML){
-			if ( typeof context.getElementById !== "undefined" && !isXML ) {
-				var m = context.getElementById(match[1]);
-				return m ? [m] : [];
-			}
-		},
-		NAME: function(match, context, isXML){
-			if ( typeof context.getElementsByName !== "undefined" && !isXML ) {
-				return context.getElementsByName(match[1]);
-			}
-		},
-		TAG: function(match, context){
-			return context.getElementsByTagName(match[1]);
-		}
-	},
-	preFilter: {
-		CLASS: function(match, curLoop, inplace, result, not){
-			match = " " + match[1].replace(/\\/g, "") + " ";
-
-			var elem;
-			for ( var i = 0; (elem = curLoop[i]) != null; i++ ) {
-				if ( elem ) {
-					if ( not ^ (" " + elem.className + " ").indexOf(match) >= 0 ) {
-						if ( !inplace )
-							result.push( elem );
-					} else if ( inplace ) {
-						curLoop[i] = false;
-					}
-				}
-			}
-
-			return false;
-		},
-		ID: function(match){
-			return match[1].replace(/\\/g, "");
-		},
-		TAG: function(match, curLoop){
-			for ( var i = 0; curLoop[i] === false; i++ ){}
-			return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
-		},
-		CHILD: function(match){
-			if ( match[1] == "nth" ) {
-				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
-				var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
-					match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
-					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
-
-				// calculate the numbers (first)n+(last) including if they are negative
-				match[2] = (test[1] + (test[2] || 1)) - 0;
-				match[3] = test[3] - 0;
-			}
-
-			// TODO: Move to normal caching system
-			match[0] = "done" + (done++);
-
-			return match;
-		},
-		ATTR: function(match){
-			var name = match[1].replace(/\\/g, "");
-			
-			if ( Expr.attrMap[name] ) {
-				match[1] = Expr.attrMap[name];
-			}
-
-			if ( match[2] === "~=" ) {
-				match[4] = " " + match[4] + " ";
-			}
-
-			return match;
-		},
-		PSEUDO: function(match, curLoop, inplace, result, not){
-			if ( match[1] === "not" ) {
-				// If we're dealing with a complex expression, or a simple one
-				if ( match[3].match(chunker).length > 1 ) {
-					match[3] = Sizzle(match[3], null, null, curLoop);
-				} else {
-					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
-					if ( !inplace ) {
-						result.push.apply( result, ret );
-					}
-					return false;
-				}
-			} else if ( Expr.match.POS.test( match[0] ) ) {
-				return true;
-			}
-			
-			return match;
-		},
-		POS: function(match){
-			match.unshift( true );
-			return match;
-		}
-	},
-	filters: {
-		enabled: function(elem){
-			return elem.disabled === false && elem.type !== "hidden";
-		},
-		disabled: function(elem){
-			return elem.disabled === true;
-		},
-		checked: function(elem){
-			return elem.checked === true;
-		},
-		selected: function(elem){
-			// Accessing this property makes selected-by-default
-			// options in Safari work properly
-			elem.parentNode.selectedIndex;
-			return elem.selected === true;
-		},
-		parent: function(elem){
-			return !!elem.firstChild;
-		},
-		empty: function(elem){
-			return !elem.firstChild;
-		},
-		has: function(elem, i, match){
-			return !!Sizzle( match[3], elem ).length;
-		},
-		header: function(elem){
-			return /h\d/i.test( elem.nodeName );
-		},
-		text: function(elem){
-			return "text" === elem.type;
-		},
-		radio: function(elem){
-			return "radio" === elem.type;
-		},
-		checkbox: function(elem){
-			return "checkbox" === elem.type;
-		},
-		file: function(elem){
-			return "file" === elem.type;
-		},
-		password: function(elem){
-			return "password" === elem.type;
-		},
-		submit: function(elem){
-			return "submit" === elem.type;
-		},
-		image: function(elem){
-			return "image" === elem.type;
-		},
-		reset: function(elem){
-			return "reset" === elem.type;
-		},
-		button: function(elem){
-			return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
-		},
-		input: function(elem){
-			return /input|select|textarea|button/i.test(elem.nodeName);
-		}
-	},
-	setFilters: {
-		first: function(elem, i){
-			return i === 0;
-		},
-		last: function(elem, i, match, array){
-			return i === array.length - 1;
-		},
-		even: function(elem, i){
-			return i % 2 === 0;
-		},
-		odd: function(elem, i){
-			return i % 2 === 1;
-		},
-		lt: function(elem, i, match){
-			return i < match[3] - 0;
-		},
-		gt: function(elem, i, match){
-			return i > match[3] - 0;
-		},
-		nth: function(elem, i, match){
-			return match[3] - 0 == i;
-		},
-		eq: function(elem, i, match){
-			return match[3] - 0 == i;
-		}
-	},
-	filter: {
-		CHILD: function(elem, match){
-			var type = match[1], parent = elem.parentNode;
-
-			var doneName = match[0];
-			
-			if ( parent && (!parent[ doneName ] || !elem.nodeIndex) ) {
-				var count = 1;
-
-				for ( var node = parent.firstChild; node; node = node.nextSibling ) {
-					if ( node.nodeType == 1 ) {
-						node.nodeIndex = count++;
-					}
-				}
-
-				parent[ doneName ] = count - 1;
-			}
-
-			if ( type == "first" ) {
-				return elem.nodeIndex == 1;
-			} else if ( type == "last" ) {
-				return elem.nodeIndex == parent[ doneName ];
-			} else if ( type == "only" ) {
-				return parent[ doneName ] == 1;
-			} else if ( type == "nth" ) {
-				var add = false, first = match[2], last = match[3];
-
-				if ( first == 1 && last == 0 ) {
-					return true;
-				}
-
-				if ( first == 0 ) {
-					if ( elem.nodeIndex == last ) {
-						add = true;
-					}
-				} else if ( (elem.nodeIndex - last) % first == 0 && (elem.nodeIndex - last) / first >= 0 ) {
-					add = true;
-				}
-
-				return add;
-			}
-		},
-		PSEUDO: function(elem, match, i, array){
-			var name = match[1], filter = Expr.filters[ name ];
-
-			if ( filter ) {
-				return filter( elem, i, match, array );
-			} else if ( name === "contains" ) {
-				return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
-			} else if ( name === "not" ) {
-				var not = match[3];
-
-				for ( var i = 0, l = not.length; i < l; i++ ) {
-					if ( not[i] === elem ) {
-						return false;
-					}
-				}
-
-				return true;
-			}
-		},
-		ID: function(elem, match){
-			return elem.nodeType === 1 && elem.getAttribute("id") === match;
-		},
-		TAG: function(elem, match){
-			return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
-		},
-		CLASS: function(elem, match){
-			return match.test( elem.className );
-		},
-		ATTR: function(elem, match){
-			var result = Expr.attrHandle[ match[1] ] ? Expr.attrHandle[ match[1] ]( elem ) : elem[ match[1] ] || elem.getAttribute( match[1] ), value = result + "", type = match[2], check = match[4];
-			return result == null ?
-				type === "!=" :
-				type === "=" ?
-				value === check :
-				type === "*=" ?
-				value.indexOf(check) >= 0 :
-				type === "~=" ?
-				(" " + value + " ").indexOf(check) >= 0 :
-				!match[4] ?
-				result :
-				type === "!=" ?
-				value != check :
-				type === "^=" ?
-				value.indexOf(check) === 0 :
-				type === "$=" ?
-				value.substr(value.length - check.length) === check :
-				type === "|=" ?
-				value === check || value.substr(0, check.length + 1) === check + "-" :
-				false;
-		},
-		POS: function(elem, match, i, array){
-			var name = match[2], filter = Expr.setFilters[ name ];
-
-			if ( filter ) {
-				return filter( elem, i, match, array );
-			}
-		}
-	}
-};
-
-var origPOS = Expr.match.POS;
-
-for ( var type in Expr.match ) {
-	Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
-}
-
-var makeArray = function(array, results) {
-	array = Array.prototype.slice.call( array );
-
-	if ( results ) {
-		results.push.apply( results, array );
-		return results;
-	}
-	
-	return array;
-};
-
-// Perform a simple check to determine if the browser is capable of
-// converting a NodeList to an array using builtin methods.
-try {
-	Array.prototype.slice.call( document.documentElement.childNodes );
-
-// Provide a fallback method if it does not work
-} catch(e){
-	makeArray = function(array, results) {
-		var ret = results || [];
-
-		if ( toString.call(array) === "[object Array]" ) {
-			Array.prototype.push.apply( ret, array );
-		} else {
-			if ( typeof array.length === "number" ) {
-				for ( var i = 0, l = array.length; i < l; i++ ) {
-					ret.push( array[i] );
-				}
-			} else {
-				for ( var i = 0; array[i]; i++ ) {
-					ret.push( array[i] );
-				}
-			}
-		}
-
-		return ret;
-	};
-}
-
-// Check to see if the browser returns elements by name when
-// querying by getElementById (and provide a workaround)
-(function(){
-	// We're going to inject a fake input element with a specified name
-	var form = document.createElement("form"),
-		id = "script" + (new Date).getTime();
-	form.innerHTML = "<input name='" + id + "'/>";
-
-	// Inject it into the root element, check its status, and remove it quickly
-	var root = document.documentElement;
-	root.insertBefore( form, root.firstChild );
-
-	// The workaround has to do additional checks after a getElementById
-	// Which slows things down for other browsers (hence the branching)
-	if ( !!document.getElementById( id ) ) {
-		Expr.find.ID = function(match, context, isXML){
-			if ( typeof context.getElementById !== "undefined" && !isXML ) {
-				var m = context.getElementById(match[1]);
-				return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
-			}
-		};
-
-		Expr.filter.ID = function(elem, match){
-			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
-			return elem.nodeType === 1 && node && node.nodeValue === match;
-		};
-	}
-
-	root.removeChild( form );
-})();
-
-(function(){
-	// Check to see if the browser returns only elements
-	// when doing getElementsByTagName("*")
-
-	// Create a fake element
-	var div = document.createElement("div");
-	div.appendChild( document.createComment("") );
-
-	// Make sure no comments are found
-	if ( div.getElementsByTagName("*").length > 0 ) {
-		Expr.find.TAG = function(match, context){
-			var results = context.getElementsByTagName(match[1]);
-
-			// Filter out possible comments
-			if ( match[1] === "*" ) {
-				var tmp = [];
-
-				for ( var i = 0; results[i]; i++ ) {
-					if ( results[i].nodeType === 1 ) {
-						tmp.push( results[i] );
-					}
-				}
-
-				results = tmp;
-			}
-
-			return results;
-		};
-	}
-
-	// Check to see if an attribute returns normalized href attributes
-	div.innerHTML = "<a href='#'></a>";
-	if ( div.firstChild && div.firstChild.getAttribute("href") !== "#" ) {
-		Expr.attrHandle.href = function(elem){
-			return elem.getAttribute("href", 2);
-		};
-	}
-})();
-
-if ( document.querySelectorAll ) (function(){
-	var oldSizzle = Sizzle, div = document.createElement("div");
-	div.innerHTML = "<p class='TEST'></p>";
-
-	// Safari can't handle uppercase or unicode characters when
-	// in quirks mode.
-	if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
-		return;
-	}
-	
-	Sizzle = function(query, context, extra, seed){
-		context = context || document;
-
-		// Only use querySelectorAll on non-XML documents
-		// (ID selectors don't work in non-HTML documents)
-		if ( !seed && context.nodeType === 9 && !isXML(context) ) {
-			try {
-				return makeArray( context.querySelectorAll(query), extra );
-			} catch(e){}
-		}
-		
-		return oldSizzle(query, context, extra, seed);
-	};
-
-	Sizzle.find = oldSizzle.find;
-	Sizzle.filter = oldSizzle.filter;
-	Sizzle.selectors = oldSizzle.selectors;
-	Sizzle.matches = oldSizzle.matches;
-})();
-
-if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) {
-	Expr.order.splice(1, 0, "CLASS");
-	Expr.find.CLASS = function(match, context) {
-		return context.getElementsByClassName(match[1]);
-	};
-}
-
-function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
-	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
-		var elem = checkSet[i];
-		if ( elem ) {
-			elem = elem[dir];
-			var match = false;
-
-			while ( elem && elem.nodeType ) {
-				var done = elem[doneName];
-				if ( done ) {
-					match = checkSet[ done ];
-					break;
-				}
-
-				if ( elem.nodeType === 1 && !isXML )
-					elem[doneName] = i;
-
-				if ( elem.nodeName === cur ) {
-					match = elem;
-					break;
-				}
-
-				elem = elem[dir];
-			}
-
-			checkSet[i] = match;
-		}
-	}
-}
-
-function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
-	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
-		var elem = checkSet[i];
-		if ( elem ) {
-			elem = elem[dir];
-			var match = false;
-
-			while ( elem && elem.nodeType ) {
-				if ( elem[doneName] ) {
-					match = checkSet[ elem[doneName] ];
-					break;
-				}
-
-				if ( elem.nodeType === 1 ) {
-					if ( !isXML )
-						elem[doneName] = i;
-
-					if ( typeof cur !== "string" ) {
-						if ( elem === cur ) {
-							match = true;
-							break;
-						}
-
-					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
-						match = elem;
-						break;
-					}
-				}
-
-				elem = elem[dir];
-			}
-
-			checkSet[i] = match;
-		}
-	}
-}
-
-var contains = document.compareDocumentPosition ?  function(a, b){
-	return a.compareDocumentPosition(b) & 16;
-} : function(a, b){
-	return a !== b && (a.contains ? a.contains(b) : true);
-};
-
-var isXML = function(elem){
-	return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
-		!!elem.ownerDocument && isXML( elem.ownerDocument );
-};
-
-var posProcess = function(selector, context){
-	var tmpSet = [], later = "", match,
-		root = context.nodeType ? [context] : context;
-
-	// Position selectors must be done after the filter
-	// And so must :not(positional) so we move all PSEUDOs to the end
-	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
-		later += match[0];
-		selector = selector.replace( Expr.match.PSEUDO, "" );
-	}
-
-	selector = Expr.relative[selector] ? selector + "*" : selector;
-
-	for ( var i = 0, l = root.length; i < l; i++ ) {
-		Sizzle( selector, root[i], tmpSet );
-	}
-
-	return Sizzle.filter( later, tmpSet );
-};
-
-// EXPOSE
-jQuery.find = Sizzle;
-jQuery.filter = Sizzle.filter;
-jQuery.expr = Sizzle.selectors;
-jQuery.expr[":"] = jQuery.expr.filters;
-
-Sizzle.selectors.filters.hidden = function(elem){
-	return "hidden" === elem.type ||
-		jQuery.css(elem, "display") === "none" ||
-		jQuery.css(elem, "visibility") === "hidden";
-};
-
-Sizzle.selectors.filters.visible = function(elem){
-	return "hidden" !== elem.type &&
-		jQuery.css(elem, "display") !== "none" &&
-		jQuery.css(elem, "visibility") !== "hidden";
-};
-
-Sizzle.selectors.filters.animated = function(elem){
-	return jQuery.grep(jQuery.timers, function(fn){
-		return elem === fn.elem;
-	}).length;
-};
-
-jQuery.multiFilter = function( expr, elems, not ) {
-	if ( not ) {
-		expr = ":not(" + expr + ")";
-	}
-
-	return Sizzle.matches(expr, elems);
-};
-
-jQuery.dir = function( elem, dir ){
-	var matched = [], cur = elem[dir];
-	while ( cur && cur != document ) {
-		if ( cur.nodeType == 1 )
-			matched.push( cur );
-		cur = cur[dir];
-	}
-	return matched;
-};
-
-jQuery.nth = function(cur, result, dir, elem){
-	result = result || 1;
-	var num = 0;
-
-	for ( ; cur; cur = cur[dir] )
-		if ( cur.nodeType == 1 && ++num == result )
-			break;
-
-	return cur;
-};
-
-jQuery.sibling = function(n, elem){
-	var r = [];
-
-	for ( ; n; n = n.nextSibling ) {
-		if ( n.nodeType == 1 && n != elem )
-			r.push( n );
-	}
-
-	return r;
-};
-
-return;
-
-window.Sizzle = Sizzle;
-
-})();
-/*
- * A number of helper functions used for managing events.
- * Many of the ideas behind this code originated from
- * Dean Edwards' addEvent library.
- */
-jQuery.event = {
-
-	// Bind an event to an element
-	// Original by Dean Edwards
-	add: function(elem, types, handler, data) {
-		if ( elem.nodeType == 3 || elem.nodeType == 8 )
-			return;
-
-		// For whatever reason, IE has trouble passing the window object
-		// around, causing it to be cloned in the process
-		if ( elem.setInterval && elem != window )
-			elem = window;
-
-		// Make sure that the function being executed has a unique ID
-		if ( !handler.guid )
-			handler.guid = this.guid++;
-
-		// if data is passed, bind to handler
-		if ( data !== undefined ) {
-			// Create temporary function pointer to original handler
-			var fn = handler;
-
-			// Create unique handler function, wrapped around original handler
-			handler = this.proxy( fn );
-
-			// Store data in unique handler
-			handler.data = data;
-		}
-
-		// Init the element's event structure
-		var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
-			handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
-				// Handle the second event of a trigger and when
-				// an event is called after a page has unloaded
-				return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
-					jQuery.event.handle.apply(arguments.callee.elem, arguments) :
-					undefined;
-			});
-		// Add elem as a property of the handle function
-		// This is to prevent a memory leak with non-native
-		// event in IE.
-		handle.elem = elem;
-
-		// Handle multiple events separated by a space
-		// jQuery(...).bind("mouseover mouseout", fn);
-		jQuery.each(types.split(/\s+/), function(index, type) {
-			// Namespaced event handlers
-			var namespaces = type.split(".");
-			type = namespaces.shift();
-			handler.type = namespaces.slice().sort().join(".");
-
-			// Get the current list of functions bound to this event
-			var handlers = events[type];
-			
-			if ( jQuery.event.specialAll[type] )
-				jQuery.event.specialAll[type].setup.call(elem, data, namespaces);
-
-			// Init the event handler queue
-			if (!handlers) {
-				handlers = events[type] = {};
-
-				// Check for a special event handler
-				// Only use addEventListener/attachEvent if the special
-				// events handler returns false
-				if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem, data, namespaces) === false ) {
-					// Bind the global event handler to the element
-					if (elem.addEventListener)
-						elem.addEventListener(type, handle, false);
-					else if (elem.attachEvent)
-						elem.attachEvent("on" + type, handle);
-				}
-			}
-
-			// Add the function to the element's handler list
-			handlers[handler.guid] = handler;
-
-			// Keep track of which events have been used, for global triggering
-			jQuery.event.global[type] = true;
-		});
-
-		// Nullify elem to prevent memory leaks in IE
-		elem = null;
-	},
-
-	guid: 1,
-	global: {},
-
-	// Detach an event or set of events from an element
-	remove: function(elem, types, handler) {
-		// don't do events on text and comment nodes
-		if ( elem.nodeType == 3 || elem.nodeType == 8 )
-			return;
-
-		var events = jQuery.data(elem, "events"), ret, index;
-
-		if ( events ) {
-			// Unbind all events for the element
-			if ( types === undefined || (typeof types === "string" && types.charAt(0) == ".") )
-				for ( var type in events )
-					this.remove( elem, type + (types || "") );
-			else {
-				// types is actually an event object here
-				if ( types.type ) {
-					handler = types.handler;
-					types = types.type;
-				}
-
-				// Handle multiple events seperated by a space
-				// jQuery(...).unbind("mouseover mouseout", fn);
-				jQuery.each(types.split(/\s+/), function(index, type){
-					// Namespaced event handlers
-					var namespaces = type.split(".");
-					type = namespaces.shift();
-					var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
-
-					if ( events[type] ) {
-						// remove the given handler for the given type
-						if ( handler )
-							delete events[type][handler.guid];
-
-						// remove all handlers for the given type
-						else
-							for ( var handle in events[type] )
-								// Handle the removal of namespaced events
-								if ( namespace.test(events[type][handle].type) )
-									delete events[type][handle];
-									
-						if ( jQuery.event.specialAll[type] )
-							jQuery.event.specialAll[type].teardown.call(elem, namespaces);
-
-						// remove generic event handler if no more handlers exist
-						for ( ret in events[type] ) break;
-						if ( !ret ) {
-							if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem, namespaces) === false ) {
-								if (elem.removeEventListener)
-									elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
-								else if (elem.detachEvent)
-									elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
-							}
-							ret = null;
-							delete events[type];
-						}
-					}
-				});
-			}
-
-			// Remove the expando if it's no longer used
-			for ( ret in events ) break;
-			if ( !ret ) {
-				var handle = jQuery.data( elem, "handle" );
-				if ( handle ) handle.elem = null;
-				jQuery.removeData( elem, "events" );
-				jQuery.removeData( elem, "handle" );
-			}
-		}
-	},
-
-	// bubbling is internal
-	trigger: function( event, data, elem, bubbling ) {
-		// Event object or event type
-		var type = event.type || event;
-
-		if( !bubbling ){
-			event = typeof event === "object" ?
-				// jQuery.Event object
-				event[expando] ? event :
-				// Object literal
-				jQuery.extend( jQuery.Event(type), event ) :
-				// Just the event type (string)
-				jQuery.Event(type);
-
-			if ( type.indexOf("!") >= 0 ) {
-				event.type = type = type.slice(0, -1);
-				event.exclusive = true;
-			}
-
-			// Handle a global trigger
-			if ( !elem ) {
-				// Don't bubble custom events when global (to avoid too much overhead)
-				event.stopPropagation();
-				// Only trigger if we've ever bound an event for it
-				if ( this.global[type] )
-					jQuery.each( jQuery.cache, function(){
-						if ( this.events && this.events[type] )
-							jQuery.event.trigger( event, data, this.handle.elem );
-					});
-			}
-
-			// Handle triggering a single element
-
-			// don't do events on text and comment nodes
-			if ( !elem || elem.nodeType == 3 || elem.nodeType == 8 )
-				return undefined;
-			
-			// Clean up in case it is reused
-			event.result = undefined;
-			event.target = elem;
-			
-			// Clone the incoming data, if any
-			data = jQuery.makeArray(data);
-			data.unshift( event );
-		}
-
-		event.currentTarget = elem;
-
-		// Trigger the event, it is assumed that "handle" is a function
-		var handle = jQuery.data(elem, "handle");
-		if ( handle )
-			handle.apply( elem, data );
-
-		// Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
-		if ( (!elem[type] || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
-			event.result = false;
-
-		// Trigger the native events (except for clicks on links)
-		if ( !bubbling && elem[type] && !event.isDefaultPrevented() && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
-			this.triggered = true;
-			try {
-				elem[ type ]();
-			// prevent IE from throwing an error for some hidden elements
-			} catch (e) {}
-		}
-
-		this.triggered = false;
-
-		if ( !event.isPropagationStopped() ) {
-			var parent = elem.parentNode || elem.ownerDocument;
-			if ( parent )
-				jQuery.event.trigger(event, data, parent, true);
-		}
-	},
-
-	handle: function(event) {
-		// returned undefined or false
-		var all, handlers;
-
-		event = arguments[0] = jQuery.event.fix( event || window.event );
-
-		// Namespaced event handlers
-		var namespaces = event.type.split(".");
-		event.type = namespaces.shift();
-
-		// Cache this now, all = true means, any handler
-		all = !namespaces.length && !event.exclusive;
-		
-		var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
-
-		handlers = ( jQuery.data(this, "events") || {} )[event.type];
-
-		for ( var j in handlers ) {
-			var handler = handlers[j];
-
-			// Filter the functions by class
-			if ( all || namespace.test(handler.type) ) {
-				// Pass in a reference to the handler function itself
-				// So that we can later remove it
-				event.handler = handler;
-				event.data = handler.data;
-
-				var ret = handler.apply(this, arguments);
-
-				if( ret !== undefined ){
-					event.result = ret;
-					if ( ret === false ) {
-						event.preventDefault();
-						event.stopPropagation();
-					}
-				}
-
-				if( event.isImmediatePropagationStopped() )
-					break;
-
-			}
-		}
-	},
-
-	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
-
-	fix: function(event) {
-		if ( event[expando] )
-			return event;
-
-		// store a copy of the original event object
-		// and "clone" to set read-only properties
-		var originalEvent = event;
-		event = jQuery.Event( originalEvent );
-
-		for ( var i = this.props.length, prop; i; ){
-			prop = this.props[ --i ];
-			event[ prop ] = originalEvent[ prop ];
-		}
-
-		// Fix target property, if necessary
-		if ( !event.target )
-			event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
-
-		// check if target is a textnode (safari)
-		if ( event.target.nodeType == 3 )
-			event.target = event.target.parentNode;
-
-		// Add relatedTarget, if necessary
-		if ( !event.relatedTarget && event.fromElement )
-			event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
-
-		// Calculate pageX/Y if missing and clientX/Y available
-		if ( event.pageX == null && event.clientX != null ) {
-			var doc = document.documentElement, body = document.body;
-			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
-			event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
-		}
-
-		// Add which for key events
-		if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
-			event.which = event.charCode || event.keyCode;
-
-		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
-		if ( !event.metaKey && event.ctrlKey )
-			event.metaKey = event.ctrlKey;
-
-		// Add which for click: 1 == left; 2 == middle; 3 == right
-		// Note: button is not normalized, so don't use it
-		if ( !event.which && event.button )
-			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
-
-		return event;
-	},
-
-	proxy: function( fn, proxy ){
-		proxy = proxy || function(){ return fn.apply(this, arguments); };
-		// Set the guid of unique handler to the same of original handler, so it can be removed
-		proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
-		// So proxy can be declared as an argument
-		return proxy;
-	},
-
-	special: {
-		ready: {
-			// Make sure the ready event is setup
-			setup: bindReady,
-			teardown: function() {}
-		}
-	},
-	
-	specialAll: {
-		live: {
-			setup: function( selector, namespaces ){
-				jQuery.event.add( this, namespaces[0], liveHandler );
-			},
-			teardown:  function( namespaces ){
-				if ( namespaces.length ) {
-					var remove = 0, name = RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
-					
-					jQuery.each( (jQuery.data(this, "events").live || {}), function(){
-						if ( name.test(this.type) )
-							remove++;
-					});
-					
-					if ( remove < 1 )
-						jQuery.event.remove( this, namespaces[0], liveHandler );
-				}
-			}
-		}
-	}
-};
-
-jQuery.Event = function( src ){
-	// Allow instantiation without the 'new' keyword
-	if( !this.preventDefault )
-		return new jQuery.Event(src);
-	
-	// Event object
-	if( src && src.type ){
-		this.originalEvent = src;
-		this.type = src.type;
-	// Event type
-	}else
-		this.type = src;
-
-	// timeStamp is buggy for some events on Firefox(#3843)
-	// So we won't rely on the native value
-	this.timeStamp = now();
-	
-	// Mark it as fixed
-	this[expando] = true;
-};
-
-function returnFalse(){
-	return false;
-}
-function returnTrue(){
-	return true;
-}
-
-// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
-// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
-jQuery.Event.prototype = {
-	preventDefault: function() {
-		this.isDefaultPrevented = returnTrue;
-
-		var e = this.originalEvent;
-		if( !e )
-			return;
-		// if preventDefault exists run it on the original event
-		if (e.preventDefault)
-			e.preventDefault();
-		// otherwise set the returnValue property of the original event to false (IE)
-		e.returnValue = false;
-	},
-	stopPropagation: function() {
-		this.isPropagationStopped = returnTrue;
-
-		var e = this.originalEvent;
-		if( !e )
-			return;
-		// if stopPropagation exists run it on the original event
-		if (e.stopPropagation)
-			e.stopPropagation();
-		// otherwise set the cancelBubble property of the original event to true (IE)
-		e.cancelBubble = true;
-	},
-	stopImmediatePropagation:function(){
-		this.isImmediatePropagationStopped = returnTrue;
-		this.stopPropagation();
-	},
-	isDefaultPrevented: returnFalse,
-	isPropagationStopped: returnFalse,
-	isImmediatePropagationStopped: returnFalse
-};
-// Checks if an event happened on an element within another element
-// Used in jQuery.event.special.mouseenter and mouseleave handlers
-var withinElement = function(event) {
-	// Check if mouse(over|out) are still within the same parent element
-	var parent = event.relatedTarget;
-	// Traverse up the tree
-	while ( parent && parent != this )
-		try { parent = parent.parentNode; }
-		catch(e) { parent = this; }
-	
-	if( parent != this ){
-		// set the correct event type
-		event.type = event.data;
-		// handle event if we actually just moused on to a non sub-element
-		jQuery.event.handle.apply( this, arguments );
-	}
-};
-	
-jQuery.each({ 
-	mouseover: 'mouseenter', 
-	mouseout: 'mouseleave'
-}, function( orig, fix ){
-	jQuery.event.special[ fix ] = {
-		setup: function(){
-			jQuery.event.add( this, orig, withinElement, fix );
-		},
-		teardown: function(){
-			jQuery.event.remove( this, orig, withinElement );
-		}
-	};			   
-});
-
-jQuery.fn.extend({
-	bind: function( type, data, fn ) {
-		return type == "unload" ? this.one(type, data, fn) : this.each(function(){
-			jQuery.event.add( this, type, fn || data, fn && data );
-		});
-	},
-
-	one: function( type, data, fn ) {
-		var one = jQuery.event.proxy( fn || data, function(event) {
-			jQuery(this).unbind(event, one);
-			return (fn || data).apply( this, arguments );
-		});
-		return this.each(function(){
-			jQuery.event.add( this, type, one, fn && data);
-		});
-	},
-
-	unbind: function( type, fn ) {
-		return this.each(function(){
-			jQuery.event.remove( this, type, fn );
-		});
-	},
-
-	trigger: function( type, data ) {
-		return this.each(function(){
-			jQuery.event.trigger( type, data, this );
-		});
-	},
-
-	triggerHandler: function( type, data ) {
-		if( this[0] ){
-			var event = jQuery.Event(type);
-			event.preventDefault();
-			event.stopPropagation();
-			jQuery.event.trigger( event, data, this[0] );
-			return event.result;
-		}		
-	},
-
-	toggle: function( fn ) {
-		// Save reference to arguments for access in closure
-		var args = arguments, i = 1;
-
-		// link all the functions, so any of them can unbind this click handler
-		while( i < args.length )
-			jQuery.event.proxy( fn, args[i++] );
-
-		return this.click( jQuery.event.proxy( fn, function(event) {
-			// Figure out which function to execute
-			this.lastToggle = ( this.lastToggle || 0 ) % i;
-
-			// Make sure that clicks stop
-			event.preventDefault();
-
-			// and execute the function
-			return args[ this.lastToggle++ ].apply( this, arguments ) || false;
-		}));
-	},
-
-	hover: function(fnOver, fnOut) {
-		return this.mouseenter(fnOver).mouseleave(fnOut);
-	},
-
-	ready: function(fn) {
-		// Attach the listeners
-		bindReady();
-
-		// If the DOM is already ready
-		if ( jQuery.isReady )
-			// Execute the function immediately
-			fn.call( document, jQuery );
-
-		// Otherwise, remember the function for later
-		else
-			// Add the function to the wait list
-			jQuery.readyList.push( fn );
-
-		return this;
-	},
-	
-	live: function( type, fn ){
-		var proxy = jQuery.event.proxy( fn );
-		proxy.guid += this.selector + type;
-
-		jQuery(document).bind( liveConvert(type, this.selector), this.selector, proxy );
-
-		return this;
-	},
-	
-	die: function( type, fn ){
-		jQuery(document).unbind( liveConvert(type, this.selector), fn ? { guid: fn.guid + this.selector + type } : null );
-		return this;
-	}
-});
-
-function liveHandler( event ){
-	var check = RegExp("(^|\\.)" + event.type + "(\\.|$)"),
-		stop = true,
-		elems = [];
-
-	jQuery.each(jQuery.data(this, "events").live || [], function(i, fn){
-		if ( check.test(fn.type) ) {
-			var elem = jQuery(event.target).closest(fn.data)[0];
-			if ( elem )
-				elems.push({ elem: elem, fn: fn });
-		}
-	});
-
-	jQuery.each(elems, function(){
-		if ( this.fn.call(this.elem, event, this.fn.data) === false )
-			stop = false;
-	});
-
-	return stop;
-}
-
-function liveConvert(type, selector){
-	return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "|")].join(".");
-}
-
-jQuery.extend({
-	isReady: false,
-	readyList: [],
-	// Handle when the DOM is ready
-	ready: function() {
-		// Make sure that the DOM is not already loaded
-		if ( !jQuery.isReady ) {
-			// Remember that the DOM is ready
-			jQuery.isReady = true;
-
-			// If there are functions bound, to execute
-			if ( jQuery.readyList ) {
-				// Execute all of them
-				jQuery.each( jQuery.readyList, function(){
-					this.call( document, jQuery );
-				});
-
-				// Reset the list of functions
-				jQuery.readyList = null;
-			}
-
-			// Trigger any bound ready events
-			jQuery(document).triggerHandler("ready");
-		}
-	}
-});
-
-var readyBound = false;
-
-function bindReady(){
-	if ( readyBound ) return;
-	readyBound = true;
-
-	// Mozilla, Opera and webkit nightlies currently support this event
-	if ( document.addEventListener ) {
-		// Use the handy event callback
-		document.addEventListener( "DOMContentLoaded", function(){
-			document.removeEventListener( "DOMContentLoaded", arguments.callee, false );
-			jQuery.ready();
-		}, false );
-
-	// If IE event model is used
-	} else if ( document.attachEvent ) {
-		// ensure firing before onload,
-		// maybe late but safe also for iframes
-		document.attachEvent("onreadystatechange", function(){
-			if ( document.readyState === "complete" ) {
-				document.detachEvent( "onreadystatechange", arguments.callee );
-				jQuery.ready();
-			}
-		});
-
-		// If IE and not an iframe
-		// continually check to see if the document is ready
-		if ( document.documentElement.doScroll && typeof window.frameElement === "undefined" ) (function(){
-			if ( jQuery.isReady ) return;
-
-			try {
-				// If IE is used, use the trick by Diego Perini
-				// http://javascript.nwbox.com/IEContentLoaded/
-				document.documentElement.doScroll("left");
-			} catch( error ) {
-				setTimeout( arguments.callee, 0 );
-				return;
-			}
-
-			// and execute any waiting functions
-			jQuery.ready();
-		})();
-	}
-
-	// A fallback to window.onload, that will always work
-	jQuery.event.add( window, "load", jQuery.ready );
-}
-
-jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
-	"mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave," +
-	"change,select,submit,keydown,keypress,keyup,error").split(","), function(i, name){
-
-	// Handle event binding
-	jQuery.fn[name] = function(fn){
-		return fn ? this.bind(name, fn) : this.trigger(name);
-	};
-});
-
-// Prevent memory leaks in IE
-// And prevent errors on refresh with events like mouseover in other browsers
-// Window isn't included so as not to unbind existing unload events
-jQuery( window ).bind( 'unload', function(){ 
-	for ( var id in jQuery.cache )
-		// Skip the window
-		if ( id != 1 && jQuery.cache[ id ].handle )
-			jQuery.event.remove( jQuery.cache[ id ].handle.elem );
-}); 
-(function(){
-
-	jQuery.support = {};
-
-	var root = document.documentElement,
-		script = document.createElement("script"),
-		div = document.createElement("div"),
-		id = "script" + (new Date).getTime();
-
-	div.style.display = "none";
-	div.innerHTML = '   <link/><table></table><a href="/a" style="color:red;float:left;opacity:.5;">a</a><select><option>text</option></select><object><param/></object>';
-
-	var all = div.getElementsByTagName("*"),
-		a = div.getElementsByTagName("a")[0];
-
-	// Can't get basic test support
-	if ( !all || !all.length || !a ) {
-		return;
-	}
-
-	jQuery.support = {
-		// IE strips leading whitespace when .innerHTML is used
-		leadingWhitespace: div.firstChild.nodeType == 3,
-		
-		// Make sure that tbody elements aren't automatically inserted
-		// IE will insert them into empty tables
-		tbody: !div.getElementsByTagName("tbody").length,
-		
-		// Make sure that you can get all elements in an <object> element
-		// IE 7 always returns no results
-		objectAll: !!div.getElementsByTagName("object")[0]
-			.getElementsByTagName("*").length,
-		
-		// Make sure that link elements get serialized correctly by innerHTML
-		// This requires a wrapper element in IE
-		htmlSerialize: !!div.getElementsByTagName("link").length,
-		
-		// Get the style information from getAttribute
-		// (IE uses .cssText insted)
-		style: /red/.test( a.getAttribute("style") ),
-		
-		// Make sure that URLs aren't manipulated
-		// (IE normalizes it by default)
-		hrefNormalized: a.getAttribute("href") === "/a",
-		
-		// Make sure that element opacity exists
-		// (IE uses filter instead)
-		opacity: a.style.opacity === "0.5",
-		
-		// Verify style float existence
-		// (IE uses styleFloat instead of cssFloat)
-		cssFloat: !!a.style.cssFloat,
-
-		// Will be defined later
-		scriptEval: false,
-		noCloneEvent: true,
-		boxModel: null
-	};
-	
-	script.type = "text/javascript";
-	try {
-		script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
-	} catch(e){}
-
-	root.insertBefore( script, root.firstChild );
-	
-	// Make sure that the execution of code works by injecting a script
-	// tag with appendChild/createTextNode
-	// (IE doesn't support this, fails, and uses .text instead)
-	if ( window[ id ] ) {
-		jQuery.support.scriptEval = true;
-		delete window[ id ];
-	}
-
-	root.removeChild( script );
-
-	if ( div.attachEvent && div.fireEvent ) {
-		div.attachEvent("onclick", function(){
-			// Cloning a node shouldn't copy over any
-			// bound event handlers (IE does this)
-			jQuery.support.noCloneEvent = false;
-			div.detachEvent("onclick", arguments.callee);
-		});
-		div.cloneNode(true).fireEvent("onclick");
-	}
-
-	// Figure out if the W3C box model works as expected
-	// document.body must exist before we can do this
-	jQuery(function(){
-		var div = document.createElement("div");
-		div.style.width = "1px";
-		div.style.paddingLeft = "1px";
-
-		document.body.appendChild( div );
-		jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
-		document.body.removeChild( div );
-	});
-})();
-
-var styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat";
-
-jQuery.props = {
-	"for": "htmlFor",
-	"class": "className",
-	"float": styleFloat,
-	cssFloat: styleFloat,
-	styleFloat: styleFloat,
-	readonly: "readOnly",
-	maxlength: "maxLength",
-	cellspacing: "cellSpacing",
-	rowspan: "rowSpan",
-	tabindex: "tabIndex"
-};
-jQuery.fn.extend({
-	// Keep a copy of the old load
-	_load: jQuery.fn.load,
-
-	load: function( url, params, callback ) {
-		if ( typeof url !== "string" )
-			return this._load( url );
-
-		var off = url.indexOf(" ");
-		if ( off >= 0 ) {
-			var selector = url.slice(off, url.length);
-			url = url.slice(0, off);
-		}
-
-		// Default to a GET request
-		var type = "GET";
-
-		// If the second parameter was provided
-		if ( params )
-			// If it's a function
-			if ( jQuery.isFunction( params ) ) {
-				// We assume that it's the callback
-				callback = params;
-				params = null;
-
-			// Otherwise, build a param string
-			} else if( typeof params === "object" ) {
-				params = jQuery.param( params );
-				type = "POST";
-			}
-
-		var self = this;
-
-		// Request the remote document
-		jQuery.ajax({
-			url: url,
-			type: type,
-			dataType: "html",
-			data: params,
-			complete: function(res, status){
-				// If successful, inject the HTML into all the matched elements
-				if ( status == "success" || status == "notmodified" )
-					// See if a selector was specified
-					self.html( selector ?
-						// Create a dummy div to hold the results
-						jQuery("<div/>")
-							// inject the contents of the document in, removing the scripts
-							// to avoid any 'Permission Denied' errors in IE
-							.append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))
-
-							// Locate the specified elements
-							.find(selector) :
-
-						// If not, just inject the full result
-						res.responseText );
-
-				if( callback )
-					self.each( callback, [res.responseText, status, res] );
-			}
-		});
-		return this;
-	},
-
-	serialize: function() {
-		return jQuery.param(this.serializeArray());
-	},
-	serializeArray: function() {
-		return this.map(function(){
-			return this.elements ? jQuery.makeArray(this.elements) : this;
-		})
-		.filter(function(){
-			return this.name && !this.disabled &&
-				(this.checked || /select|textarea/i.test(this.nodeName) ||
-					/text|hidden|password/i.test(this.type));
-		})
-		.map(function(i, elem){
-			var val = jQuery(this).val();
-			return val == null ? null :
-				jQuery.isArray(val) ?
-					jQuery.map( val, function(val, i){
-						return {name: elem.name, value: val};
-					}) :
-					{name: elem.name, value: val};
-		}).get();
-	}
-});
-
-// Attach a bunch of functions for handling common AJAX events
-jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
-	jQuery.fn[o] = function(f){
-		return this.bind(o, f);
-	};
-});
-
-var jsc = now();
-
-jQuery.extend({
-  
-	get: function( url, data, callback, type ) {
-		// shift arguments if data argument was ommited
-		if ( jQuery.isFunction( data ) ) {
-			callback = data;
-			data = null;
-		}
-
-		return jQuery.ajax({
-			type: "GET",
-			url: url,
-			data: data,
-			success: callback,
-			dataType: type
-		});
-	},
-
-	getScript: function( url, callback ) {
-		return jQuery.get(url, null, callback, "script");
-	},
-
-	getJSON: function( url, data, callback ) {
-		return jQuery.get(url, data, callback, "json");
-	},
-
-	post: function( url, data, callback, type ) {
-		if ( jQuery.isFunction( data ) ) {
-			callback = data;
-			data = {};
-		}
-
-		return jQuery.ajax({
-			type: "POST",
-			url: url,
-			data: data,
-			success: callback,
-			dataType: type
-		});
-	},
-
-	ajaxSetup: function( settings ) {
-		jQuery.extend( jQuery.ajaxSettings, settings );
-	},
-
-	ajaxSettings: {
-		url: location.href,
-		global: true,
-		type: "GET",
-		contentType: "application/x-www-form-urlencoded",
-		processData: true,
-		async: true,
-		/*
-		timeout: 0,
-		data: null,
-		username: null,
-		password: null,
-		*/
-		// Create the request object; Microsoft failed to properly
-		// implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
-		// This function can be overriden by calling jQuery.ajaxSetup
-		xhr:function(){
-			return window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
-		},
-		accepts: {
-			xml: "application/xml, text/xml",
-			html: "text/html",
-			script: "text/javascript, application/javascript",
-			json: "application/json, text/javascript",
-			text: "text/plain",
-			_default: "*/*"
-		}
-	},
-
-	// Last-Modified header cache for next request
-	lastModified: {},
-
-	ajax: function( s ) {
-		// Extend the settings, but re-extend 's' so that it can be
-		// checked again later (in the test suite, specifically)
-		s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));
-
-		var jsonp, jsre = /=\?(&|$)/g, status, data,
-			type = s.type.toUpperCase();
-
-		// convert data if not already a string
-		if ( s.data && s.processData && typeof s.data !== "string" )
-			s.data = jQuery.param(s.data);
-
-		// Handle JSONP Parameter Callbacks
-		if ( s.dataType == "jsonp" ) {
-			if ( type == "GET" ) {
-				if ( !s.url.match(jsre) )
-					s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
-			} else if ( !s.data || !s.data.match(jsre) )
-				s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
-			s.dataType = "json";
-		}
-
-		// Build temporary JSONP function
-		if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
-			jsonp = "jsonp" + jsc++;
-
-			// Replace the =? sequence both in the query string and the data
-			if ( s.data )
-				s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
-			s.url = s.url.replace(jsre, "=" + jsonp + "$1");
-
-			// We need to make sure
-			// that a JSONP style response is executed properly
-			s.dataType = "script";
-
-			// Handle JSONP-style loading
-			window[ jsonp ] = function(tmp){
-				data = tmp;
-				success();
-				complete();
-				// Garbage collect
-				window[ jsonp ] = undefined;
-				try{ delete window[ jsonp ]; } catch(e){}
-				if ( head )
-					head.removeChild( script );
-			};
-		}
-
-		if ( s.dataType == "script" && s.cache == null )
-			s.cache = false;
-
-		if ( s.cache === false && type == "GET" ) {
-			var ts = now();
-			// try replacing _= if it is there
-			var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
-			// if nothing was replaced, add timestamp to the end
-			s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
-		}
-
-		// If data is available, append data to url for get requests
-		if ( s.data && type == "GET" ) {
-			s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
-
-			// IE likes to send both get and post data, prevent this
-			s.data = null;
-		}
-
-		// Watch for a new set of requests
-		if ( s.global && ! jQuery.active++ )
-			jQuery.event.trigger( "ajaxStart" );
-
-		// Matches an absolute URL, and saves the domain
-		var parts = /^(\w+:)?\/\/([^\/?#]+)/.exec( s.url );
-
-		// If we're requesting a remote document
-		// and trying to load JSON or Script with a GET
-		if ( s.dataType == "script" && type == "GET" && parts
-			&& ( parts[1] && parts[1] != location.protocol || parts[2] != location.host )){
-
-			var head = document.getElementsByTagName("head")[0];
-			var script = document.createElement("script");
-			script.src = s.url;
-			if (s.scriptCharset)
-				script.charset = s.scriptCharset;
-
-			// Handle Script loading
-			if ( !jsonp ) {
-				var done = false;
-
-				// Attach handlers for all browsers
-				script.onload = script.onreadystatechange = function(){
-					if ( !done && (!this.readyState ||
-							this.readyState == "loaded" || this.readyState == "complete") ) {
-						done = true;
-						success();
-						complete();
-						head.removeChild( script );
-					}
-				};
-			}
-
-			head.appendChild(script);
-
-			// We handle everything using the script element injection
-			return undefined;
-		}
-
-		var requestDone = false;
-
-		// Create the request object
-		var xhr = s.xhr();
-
-		// Open the socket
-		// Passing null username, generates a login popup on Opera (#2865)
-		if( s.username )
-			xhr.open(type, s.url, s.async, s.username, s.password);
-		else
-			xhr.open(type, s.url, s.async);
-
-		// Need an extra try/catch for cross domain requests in Firefox 3
-		try {
-			// Set the correct header, if data is being sent
-			if ( s.data )
-				xhr.setRequestHeader("Content-Type", s.contentType);
-
-			// Set the If-Modified-Since header, if ifModified mode.
-			if ( s.ifModified )
-				xhr.setRequestHeader("If-Modified-Since",
-					jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
-
-			// Set header so the called script knows that it's an XMLHttpRequest
-			xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
-
-			// Set the Accepts header for the server, depending on the dataType
-			xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
-				s.accepts[ s.dataType ] + ", */*" :
-				s.accepts._default );
-		} catch(e){}
-
-		// Allow custom headers/mimetypes and early abort
-		if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
-			// Handle the global AJAX counter
-			if ( s.global && ! --jQuery.active )
-				jQuery.event.trigger( "ajaxStop" );
-			// close opended socket
-			xhr.abort();
-			return false;
-		}
-
-		if ( s.global )
-			jQuery.event.trigger("ajaxSend", [xhr, s]);
-
-		// Wait for a response to come back
-		var onreadystatechange = function(isTimeout){
-			// The request was aborted, clear the interval and decrement jQuery.active
-			if (xhr.readyState == 0) {
-				if (ival) {
-					// clear poll interval
-					clearInterval(ival);
-					ival = null;
-					// Handle the global AJAX counter
-					if ( s.global && ! --jQuery.active )
-						jQuery.event.trigger( "ajaxStop" );
-				}
-			// The transfer is complete and the data is available, or the request timed out
-			} else if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
-				requestDone = true;
-
-				// clear poll interval
-				if (ival) {
-					clearInterval(ival);
-					ival = null;
-				}
-
-				status = isTimeout == "timeout" ? "timeout" :
-					!jQuery.httpSuccess( xhr ) ? "error" :
-					s.ifModified && jQuery.httpNotModified( xhr, s.url ) ? "notmodified" :
-					"success";
-
-				if ( status == "success" ) {
-					// Watch for, and catch, XML document parse errors
-					try {
-						// process the data (runs the xml through httpData regardless of callback)
-						data = jQuery.httpData( xhr, s.dataType, s );
-					} catch(e) {
-						status = "parsererror";
-					}
-				}
-
-				// Make sure that the request was successful or notmodified
-				if ( status == "success" ) {
-					// Cache Last-Modified header, if ifModified mode.
-					var modRes;
-					try {
-						modRes = xhr.getResponseHeader("Last-Modified");
-					} catch(e) {} // swallow exception thrown by FF if header is not available
-
-					if ( s.ifModified && modRes )
-						jQuery.lastModified[s.url] = modRes;
-
-					// JSONP handles its own success callback
-					if ( !jsonp )
-						success();
-				} else
-					jQuery.handleError(s, xhr, status);
-
-				// Fire the complete handlers
-				complete();
-
-				if ( isTimeout )
-					xhr.abort();
-
-				// Stop memory leaks
-				if ( s.async )
-					xhr = null;
-			}
-		};
-
-		if ( s.async ) {
-			// don't attach the handler to the request, just poll it instead
-			var ival = setInterval(onreadystatechange, 13);
-
-			// Timeout checker
-			if ( s.timeout > 0 )
-				setTimeout(function(){
-					// Check to see if the request is still happening
-					if ( xhr && !requestDone )
-						onreadystatechange( "timeout" );
-				}, s.timeout);
-		}
-
-		// Send the data
-		try {
-			xhr.send(s.data);
-		} catch(e) {
-			jQuery.handleError(s, xhr, null, e);
-		}
-
-		// firefox 1.5 doesn't fire statechange for sync requests
-		if ( !s.async )
-			onreadystatechange();
-
-		function success(){
-			// If a local callback was specified, fire it and pass it the data
-			if ( s.success )
-				s.success( data, status );
-
-			// Fire the global callback
-			if ( s.global )
-				jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
-		}
-
-		function complete(){
-			// Process result
-			if ( s.complete )
-				s.complete(xhr, status);
-
-			// The request was completed
-			if ( s.global )
-				jQuery.event.trigger( "ajaxComplete", [xhr, s] );
-
-			// Handle the global AJAX counter
-			if ( s.global && ! --jQuery.active )
-				jQuery.event.trigger( "ajaxStop" );
-		}
-
-		// return XMLHttpRequest to allow aborting the request etc.
-		return xhr;
-	},
-
-	handleError: function( s, xhr, status, e ) {
-		// If a local callback was specified, fire it
-		if ( s.error ) s.error( xhr, status, e );
-
-		// Fire the global callback
-		if ( s.global )
-			jQuery.event.trigger( "ajaxError", [xhr, s, e] );
-	},
-
-	// Counter for holding the number of active queries
-	active: 0,
-
-	// Determines if an XMLHttpRequest was successful or not
-	httpSuccess: function( xhr ) {
-		try {
-			// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
-			return !xhr.status && location.protocol == "file:" ||
-				( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223;
-		} catch(e){}
-		return false;
-	},
-
-	// Determines if an XMLHttpRequest returns NotModified
-	httpNotModified: function( xhr, url ) {
-		try {
-			var xhrRes = xhr.getResponseHeader("Last-Modified");
-
-			// Firefox always returns 200. check Last-Modified date
-			return xhr.status == 304 || xhrRes == jQuery.lastModified[url];
-		} catch(e){}
-		return false;
-	},
-
-	httpData: function( xhr, type, s ) {
-		var ct = xhr.getResponseHeader("content-type"),
-			xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
-			data = xml ? xhr.responseXML : xhr.responseText;
-
-		if ( xml && data.documentElement.tagName == "parsererror" )
-			throw "parsererror";
-			
-		// Allow a pre-filtering function to sanitize the response
-		// s != null is checked to keep backwards compatibility
-		if( s && s.dataFilter )
-			data = s.dataFilter( data, type );
-
-		// The filter can actually parse the response
-		if( typeof data === "string" ){
-
-			// If the type is "script", eval it in global context
-			if ( type == "script" )
-				jQuery.globalEval( data );
-
-			// Get the JavaScript object, if JSON is used.
-			if ( type == "json" )
-				data = window["eval"]("(" + data + ")");
-		}
-		
-		return data;
-	},
-
-	// Serialize an array of form elements or a set of
-	// key/values into a query string
-	param: function( a ) {
-		var s = [ ];
-
-		function add( key, value ){
-			s[ s.length ] = encodeURIComponent(key) + '=' + encodeURIComponent(value);
-		};
-
-		// If an array was passed in, assume that it is an array
-		// of form elements
-		if ( jQuery.isArray(a) || a.jquery )
-			// Serialize the form elements
-			jQuery.each( a, function(){
-				add( this.name, this.value );
-			});
-
-		// Otherwise, assume that it's an object of key/value pairs
-		else
-			// Serialize the key/values
-			for ( var j in a )
-				// If the value is an array then the key names need to be repeated
-				if ( jQuery.isArray(a[j]) )
-					jQuery.each( a[j], function(){
-						add( j, this );
-					});
-				else
-					add( j, jQuery.isFunction(a[j]) ? a[j]() : a[j] );
-
-		// Return the resulting serialization
-		return s.join("&").replace(/%20/g, "+");
-	}
-
-});
-var elemdisplay = {},
-	timerId,
-	fxAttrs = [
-		// height animations
-		[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
-		// width animations
-		[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
-		// opacity animations
-		[ "opacity" ]
-	];
-
-function genFx( type, num ){
-	var obj = {};
-	jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function(){
-		obj[ this ] = type;
-	});
-	return obj;
-}
-
-jQuery.fn.extend({
-	show: function(speed,callback){
-		if ( speed ) {
-			return this.animate( genFx("show", 3), speed, callback);
-		} else {
-			for ( var i = 0, l = this.length; i < l; i++ ){
-				var old = jQuery.data(this[i], "olddisplay");
-				
-				this[i].style.display = old || "";
-				
-				if ( jQuery.css(this[i], "display") === "none" ) {
-					var tagName = this[i].tagName, display;
-					
-					if ( elemdisplay[ tagName ] ) {
-						display = elemdisplay[ tagName ];
-					} else {
-						var elem = jQuery("<" + tagName + " />").appendTo("body");
-						
-						display = elem.css("display");
-						if ( display === "none" )
-							display = "block";
-						
-						elem.remove();
-						
-						elemdisplay[ tagName ] = display;
-					}
-					
-					this[i].style.display = jQuery.data(this[i], "olddisplay", display);
-				}
-			}
-			
-			return this;
-		}
-	},
-
-	hide: function(speed,callback){
-		if ( speed ) {
-			return this.animate( genFx("hide", 3), speed, callback);
-		} else {
-			for ( var i = 0, l = this.length; i < l; i++ ){
-				var old = jQuery.data(this[i], "olddisplay");
-				if ( !old && old !== "none" )
-					jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
-				this[i].style.display = "none";
-			}
-			return this;
-		}
-	},
-
-	// Save the old toggle function
-	_toggle: jQuery.fn.toggle,
-
-	toggle: function( fn, fn2 ){
-		var bool = typeof fn === "boolean";
-
-		return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
-			this._toggle.apply( this, arguments ) :
-			fn == null || bool ?
-				this.each(function(){
-					var state = bool ? fn : jQuery(this).is(":hidden");
-					jQuery(this)[ state ? "show" : "hide" ]();
-				}) :
-				this.animate(genFx("toggle", 3), fn, fn2);
-	},
-
-	fadeTo: function(speed,to,callback){
-		return this.animate({opacity: to}, speed, callback);
-	},
-
-	animate: function( prop, speed, easing, callback ) {
-		var optall = jQuery.speed(speed, easing, callback);
-
-		return this[ optall.queue === false ? "each" : "queue" ](function(){
-		
-			var opt = jQuery.extend({}, optall), p,
-				hidden = this.nodeType == 1 && jQuery(this).is(":hidden"),
-				self = this;
-	
-			for ( p in prop ) {
-				if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
-					return opt.complete.call(this);
-
-				if ( ( p == "height" || p == "width" ) && this.style ) {
-					// Store display property
-					opt.display = jQuery.css(this, "display");
-
-					// Make sure that nothing sneaks out
-					opt.overflow = this.style.overflow;
-				}
-			}
-
-			if ( opt.overflow != null )
-				this.style.overflow = "hidden";
-
-			opt.curAnim = jQuery.extend({}, prop);
-
-			jQuery.each( prop, function(name, val){
-				var e = new jQuery.fx( self, opt, name );
-
-				if ( /toggle|show|hide/.test(val) )
-					e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
-				else {
-					var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
-						start = e.cur(true) || 0;
-
-					if ( parts ) {
-						var end = parseFloat(parts[2]),
-							unit = parts[3] || "px";
-
-						// We need to compute starting value
-						if ( unit != "px" ) {
-							self.style[ name ] = (end || 1) + unit;
-							start = ((end || 1) / e.cur(true)) * start;
-							self.style[ name ] = start + unit;
-						}
-
-						// If a +=/-= token was provided, we're doing a relative animation
-						if ( parts[1] )
-							end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
-
-						e.custom( start, end, unit );
-					} else
-						e.custom( start, val, "" );
-				}
-			});
-
-			// For JS strict compliance
-			return true;
-		});
-	},
-
-	stop: function(clearQueue, gotoEnd){
-		var timers = jQuery.timers;
-
-		if (clearQueue)
-			this.queue([]);
-
-		this.each(function(){
-			// go in reverse order so anything added to the queue during the loop is ignored
-			for ( var i = timers.length - 1; i >= 0; i-- )
-				if ( timers[i].elem == this ) {
-					if (gotoEnd)
-						// force the next step to be the last
-						timers[i](true);
-					timers.splice(i, 1);
-				}
-		});
-
-		// start the next in the queue if the last step wasn't forced
-		if (!gotoEnd)
-			this.dequeue();
-
-		return this;
-	}
-
-});
-
-// Generate shortcuts for custom animations
-jQuery.each({
-	slideDown: genFx("show", 1),
-	slideUp: genFx("hide", 1),
-	slideToggle: genFx("toggle", 1),
-	fadeIn: { opacity: "show" },
-	fadeOut: { opacity: "hide" }
-}, function( name, props ){
-	jQuery.fn[ name ] = function( speed, callback ){
-		return this.animate( props, speed, callback );
-	};
-});
-
-jQuery.extend({
-
-	speed: function(speed, easing, fn) {
-		var opt = typeof speed === "object" ? speed : {
-			complete: fn || !fn && easing ||
-				jQuery.isFunction( speed ) && speed,
-			duration: speed,
-			easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
-		};
-
-		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
-			jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._default;
-
-		// Queueing
-		opt.old = opt.complete;
-		opt.complete = function(){
-			if ( opt.queue !== false )
-				jQuery(this).dequeue();
-			if ( jQuery.isFunction( opt.old ) )
-				opt.old.call( this );
-		};
-
-		return opt;
-	},
-
-	easing: {
-		linear: function( p, n, firstNum, diff ) {
-			return firstNum + diff * p;
-		},
-		swing: function( p, n, firstNum, diff ) {
-			return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
-		}
-	},
-
-	timers: [],
-
-	fx: function( elem, options, prop ){
-		this.options = options;
-		this.elem = elem;
-		this.prop = prop;
-
-		if ( !options.orig )
-			options.orig = {};
-	}
-
-});
-
-jQuery.fx.prototype = {
-
-	// Simple function for setting a style value
-	update: function(){
-		if ( this.options.step )
-			this.options.step.call( this.elem, this.now, this );
-
-		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
-
-		// Set display property to block for height/width animations
-		if ( ( this.prop == "height" || this.prop == "width" ) && this.elem.style )
-			this.elem.style.display = "block";
-	},
-
-	// Get the current size
-	cur: function(force){
-		if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) )
-			return this.elem[ this.prop ];
-
-		var r = parseFloat(jQuery.css(this.elem, this.prop, force));
-		return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
-	},
-
-	// Start an animation from one number to another
-	custom: function(from, to, unit){
-		this.startTime = now();
-		this.start = from;
-		this.end = to;
-		this.unit = unit || this.unit || "px";
-		this.now = this.start;
-		this.pos = this.state = 0;
-
-		var self = this;
-		function t(gotoEnd){
-			return self.step(gotoEnd);
-		}
-
-		t.elem = this.elem;
-
-		if ( t() && jQuery.timers.push(t) == 1 ) {
-			timerId = setInterval(function(){
-				var timers = jQuery.timers;
-
-				for ( var i = 0; i < timers.length; i++ )
-					if ( !timers[i]() )
-						timers.splice(i--, 1);
-
-				if ( !timers.length ) {
-					clearInterval( timerId );
-				}
-			}, 13);
-		}
-	},
-
-	// Simple 'show' function
-	show: function(){
-		// Remember where we started, so that we can go back to it later
-		this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
-		this.options.show = true;
-
-		// Begin the animation
-		// Make sure that we start at a small width/height to avoid any
-		// flash of content
-		this.custom(this.prop == "width" || this.prop == "height" ? 1 : 0, this.cur());
-
-		// Start by showing the element
-		jQuery(this.elem).show();
-	},
-
-	// Simple 'hide' function
-	hide: function(){
-		// Remember where we started, so that we can go back to it later
-		this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
-		this.options.hide = true;
-
-		// Begin the animation
-		this.custom(this.cur(), 0);
-	},
-
-	// Each step of an animation
-	step: function(gotoEnd){
-		var t = now();
-
-		if ( gotoEnd || t >= this.options.duration + this.startTime ) {
-			this.now = this.end;
-			this.pos = this.state = 1;
-			this.update();
-
-			this.options.curAnim[ this.prop ] = true;
-
-			var done = true;
-			for ( var i in this.options.curAnim )
-				if ( this.options.curAnim[i] !== true )
-					done = false;
-
-			if ( done ) {
-				if ( this.options.display != null ) {
-					// Reset the overflow
-					this.elem.style.overflow = this.options.overflow;
-
-					// Reset the display
-					this.elem.style.display = this.options.display;
-					if ( jQuery.css(this.elem, "display") == "none" )
-						this.elem.style.display = "block";
-				}
-
-				// Hide the element if the "hide" operation was done
-				if ( this.options.hide )
-					jQuery(this.elem).hide();
-
-				// Reset the properties, if the item has been hidden or shown
-				if ( this.options.hide || this.options.show )
-					for ( var p in this.options.curAnim )
-						jQuery.attr(this.elem.style, p, this.options.orig[p]);
-					
-				// Execute the complete function
-				this.options.complete.call( this.elem );
-			}
-
-			return false;
-		} else {
-			var n = t - this.startTime;
-			this.state = n / this.options.duration;
-
-			// Perform the easing function, defaults to swing
-			this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
-			this.now = this.start + ((this.end - this.start) * this.pos);
-
-			// Perform the next step of the animation
-			this.update();
-		}
-
-		return true;
-	}
-
-};
-
-jQuery.extend( jQuery.fx, {
-	speeds:{
-		slow: 600,
- 		fast: 200,
- 		// Default speed
- 		_default: 400
-	},
-	step: {
-
-		opacity: function(fx){
-			jQuery.attr(fx.elem.style, "opacity", fx.now);
-		},
-
-		_default: function(fx){
-			if ( fx.elem.style && fx.elem.style[ fx.prop ] != null )
-				fx.elem.style[ fx.prop ] = fx.now + fx.unit;
-			else
-				fx.elem[ fx.prop ] = fx.now;
-		}
-	}
-});
-if ( document.documentElement["getBoundingClientRect"] )
-	jQuery.fn.offset = function() {
-		if ( !this[0] ) return { top: 0, left: 0 };
-		if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
-		var box  = this[0].getBoundingClientRect(), doc = this[0].ownerDocument, body = doc.body, docElem = doc.documentElement,
-			clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
-			top  = box.top  + (self.pageYOffset || jQuery.boxModel && docElem.scrollTop  || body.scrollTop ) - clientTop,
-			left = box.left + (self.pageXOffset || jQuery.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
-		return { top: top, left: left };
-	};
-else 
-	jQuery.fn.offset = function() {
-		if ( !this[0] ) return { top: 0, left: 0 };
-		if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
-		jQuery.offset.initialized || jQuery.offset.initialize();
-
-		var elem = this[0], offsetParent = elem.offsetParent, prevOffsetParent = elem,
-			doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
-			body = doc.body, defaultView = doc.defaultView,
-			prevComputedStyle = defaultView.getComputedStyle(elem, null),
-			top = elem.offsetTop, left = elem.offsetLeft;
-
-		while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
-			computedStyle = defaultView.getComputedStyle(elem, null);
-			top -= elem.scrollTop, left -= elem.scrollLeft;
-			if ( elem === offsetParent ) {
-				top += elem.offsetTop, left += elem.offsetLeft;
-				if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.tagName)) )
-					top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
-					left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
-				prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
-			}
-			if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" )
-				top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
-				left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
-			prevComputedStyle = computedStyle;
-		}
-
-		if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" )
-			top  += body.offsetTop,
-			left += body.offsetLeft;
-
-		if ( prevComputedStyle.position === "fixed" )
-			top  += Math.max(docElem.scrollTop, body.scrollTop),
-			left += Math.max(docElem.scrollLeft, body.scrollLeft);
-
-		return { top: top, left: left };
-	};
-
-jQuery.offset = {
-	initialize: function() {
-		if ( this.initialized ) return;
-		var body = document.body, container = document.createElement('div'), innerDiv, checkDiv, table, td, rules, prop, bodyMarginTop = body.style.marginTop,
-			html = '<div style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;"><div></div></div><table style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;" cellpadding="0" cellspacing="0"><tr><td></td></tr></table>';
-
-		rules = { position: 'absolute', top: 0, left: 0, margin: 0, border: 0, width: '1px', height: '1px', visibility: 'hidden' };
-		for ( prop in rules ) container.style[prop] = rules[prop];
-
-		container.innerHTML = html;
-		body.insertBefore(container, body.firstChild);
-		innerDiv = container.firstChild, checkDiv = innerDiv.firstChild, td = innerDiv.nextSibling.firstChild.firstChild;
-
-		this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
-		this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
-
-		innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'relative';
-		this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
-
-		body.style.marginTop = '1px';
-		this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0);
-		body.style.marginTop = bodyMarginTop;
-
-		body.removeChild(container);
-		this.initialized = true;
-	},
-
-	bodyOffset: function(body) {
-		jQuery.offset.initialized || jQuery.offset.initialize();
-		var top = body.offsetTop, left = body.offsetLeft;
-		if ( jQuery.offset.doesNotIncludeMarginInBodyOffset )
-			top  += parseInt( jQuery.curCSS(body, 'marginTop',  true), 10 ) || 0,
-			left += parseInt( jQuery.curCSS(body, 'marginLeft', true), 10 ) || 0;
-		return { top: top, left: left };
-	}
-};
-
-
-jQuery.fn.extend({
-	position: function() {
-		var left = 0, top = 0, results;
-
-		if ( this[0] ) {
-			// Get *real* offsetParent
-			var offsetParent = this.offsetParent(),
-
-			// Get correct offsets
-			offset       = this.offset(),
-			parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
-
-			// Subtract element margins
-			// note: when an element has margin: auto the offsetLeft and marginLeft 
-			// are the same in Safari causing offset.left to incorrectly be 0
-			offset.top  -= num( this, 'marginTop'  );
-			offset.left -= num( this, 'marginLeft' );
-
-			// Add offsetParent borders
-			parentOffset.top  += num( offsetParent, 'borderTopWidth'  );
-			parentOffset.left += num( offsetParent, 'borderLeftWidth' );
-
-			// Subtract the two offsets
-			results = {
-				top:  offset.top  - parentOffset.top,
-				left: offset.left - parentOffset.left
-			};
-		}
-
-		return results;
-	},
-
-	offsetParent: function() {
-		var offsetParent = this[0].offsetParent || document.body;
-		while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
-			offsetParent = offsetParent.offsetParent;
-		return jQuery(offsetParent);
-	}
-});
-
-
-// Create scrollLeft and scrollTop methods
-jQuery.each( ['Left', 'Top'], function(i, name) {
-	var method = 'scroll' + name;
-	
-	jQuery.fn[ method ] = function(val) {
-		if (!this[0]) return null;
-
-		return val !== undefined ?
-
-			// Set the scroll offset
-			this.each(function() {
-				this == window || this == document ?
-					window.scrollTo(
-						!i ? val : jQuery(window).scrollLeft(),
-						 i ? val : jQuery(window).scrollTop()
-					) :
-					this[ method ] = val;
-			}) :
-
-			// Return the scroll offset
-			this[0] == window || this[0] == document ?
-				self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
-					jQuery.boxModel && document.documentElement[ method ] ||
-					document.body[ method ] :
-				this[0][ method ];
-	};
-});
-// Create innerHeight, innerWidth, outerHeight and outerWidth methods
-jQuery.each([ "Height", "Width" ], function(i, name){
-
-	var tl = i ? "Left"  : "Top",  // top or left
-		br = i ? "Right" : "Bottom"; // bottom or right
-
-	// innerHeight and innerWidth
-	jQuery.fn["inner" + name] = function(){
-		return this[ name.toLowerCase() ]() +
-			num(this, "padding" + tl) +
-			num(this, "padding" + br);
-	};
-
-	// outerHeight and outerWidth
-	jQuery.fn["outer" + name] = function(margin) {
-		return this["inner" + name]() +
-			num(this, "border" + tl + "Width") +
-			num(this, "border" + br + "Width") +
-			(margin ?
-				num(this, "margin" + tl) + num(this, "margin" + br) : 0);
-	};
-	
-	var type = name.toLowerCase();
-
-	jQuery.fn[ type ] = function( size ) {
-		// Get window width or height
-		return this[0] == window ?
-			// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
-			document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] ||
-			document.body[ "client" + name ] :
-
-			// Get document width or height
-			this[0] == document ?
-				// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
-				Math.max(
-					document.documentElement["client" + name],
-					document.body["scroll" + name], document.documentElement["scroll" + name],
-					document.body["offset" + name], document.documentElement["offset" + name]
-				) :
-
-				// Get or set width or height on the element
-				size === undefined ?
-					// Get width or height on the element
-					(this.length ? jQuery.css( this[0], type ) : null) :
-
-					// Set the width or height on the element (default to pixels if value is unitless)
-					this.css( type, typeof size === "string" ? size : size + "px" );
-	};
-
-});})();
diff --git a/AjaxPro/web.config b/AjaxPro/web.config
index 0bdbb9c..d51fb39 100644
--- a/AjaxPro/web.config
+++ b/AjaxPro/web.config
@@ -1,9 +1,7 @@
 <?xml version="1.0"?>
 <configuration>
-	
 	<configSections>
 		<sectionGroup name="ajaxNet">
-
 			<!--
 				If you are using Microsoft .NET 1.1 please remove the two attributes
 				requirePermission and restartOnExternalChanges, they are only supported
@@ -14,13 +12,10 @@
 				requirePermission="false"
 				restartOnExternalChanges="true"
 			/>
-			
 		</sectionGroup>
 	</configSections>
-
 	<ajaxNet>
 		<ajaxSettings>
-
 			<urlNamespaceMappings useAssemblyQualifiedName="false" allowListOnly="false">
 				<!--
 					Set the attribute useAssemblyQualifiedName to true to enable
@@ -33,8 +28,7 @@
 					<add type="Namespace.Class1,Assembly" path="mypath" />
 				-->
 			</urlNamespaceMappings>
-
-			<jsonConverters includeTypeProperty="true">
+			<jsonConverters includeTypeProperty="false">
 				<!--
 					This section can be used to add new IJavaScriptConverters to the
 					Ajax.NET Professional engine. If you want to disable built-in
@@ -46,13 +40,14 @@
 					<add type="AjaxPro.BitmapConverter,AjaxPro.2" mimeType="image/jpeg" quality="100"/>
 				-->
 			</jsonConverters>
-
+			<jsonDeserializationCustomTypes default="deny">
+				<allow>MyOwnNamespace.</allow>
+			</jsonDeserializationCustomTypes>
 			<!--
 				Set the enabled attribute to true to get Stack, TargetSize and Source 
 				information if an exception has been thrown.
 			-->
 			<debug enabled="false" />
-
 			<!--
 				This is the default configuration used with Ajax.NET Professional. You
 				can put there your static JavaScript files, or remove the path attribute
@@ -64,16 +59,13 @@
 					<file name="converter" path="~/ajaxpro/converter.ashx" />
 				</scriptReplacements>
 			-->
-			
 			<!-- <encryption cryptType="" keyType="" /> -->
-			
 			<!--
 				Set the enabled attribute to true to enable the use of an Ajax.NET Professional
 				token. This will send a token to the client that will be used to identify if the
 				requests comes from the same PC.
 			-->
 			<token enabled="false" sitePassword="password" />
-
 			<!--
 				The oldStyle (or now configuration) section can be used to enable old styled JavaScript code or
 				functions that are not used any more. Some of them cannot be used together.
@@ -91,12 +83,9 @@
 					<useSimpleObjectNaming/>
 				</configuration>
 			-->
-			
 		</ajaxSettings>
 	</ajaxNet>
-
 	<!-- Common ASP.NET configuration -->
-
 	<appSettings/>
 	<connectionStrings/>
 	<system.web>
@@ -110,27 +99,19 @@
 			-->
 		</httpModules>
 	</system.web>
-
 	<!-- Handler configuration for Ajax.NET Professional -->
-	
 	<location path="ajaxpro">
 		<system.web>
 			<httpHandlers>
 				<add verb="*" path="*.ashx" type="AjaxPro.AjaxHandlerFactory,AjaxPro.2"/>
 			</httpHandlers>
-			<!--
-				If you need to have Ajax.NET Professional methods running on the
-				login page you may have to enable your own authorization configuration
-				here.
-			-->
-			<!--
-			<authorization>
-				<deny users="?"/>
-			</authorization>
-			-->
 		</system.web>
+		<system.webServer>
+			<handlers>
+				<add name="@ajaxpro" verb="*" path="*.ashx" type="AjaxPro.AjaxHandlerFactory,AjaxPro.2" />
+			</handlers>
+		</system.webServer>
 	</location>
-
 	<!--
 	If you are using the AjaxPro.BitmapConverter you have to use following location
 	configuration to get a JPEG of the Bitmap.
@@ -144,5 +125,4 @@
 		</system.web>
 	</location>
 	-->
-	
 </configuration>
\ No newline at end of file",
"url": "https://github.com/michaelschwarz/Ajax.NET-Professional/commit/b0e63be5f0bb20dfce507cb8a1a9568f6e73de57.patch"
}
] |
Deserialization of Untrusted Data
|
CVE-2022-4455
|
sproctor php-calendar index.php cross site scripting
|
A vulnerability was identified in sproctor php-calendar up to 2.0.13. This impacts an unknown function of the file index.php. Such manipulation of the argument $_SERVER['PHP_SELF'] leads to cross site scripting. The attack may be launched remotely. The name of the patch is a2941109b42201c19733127ced763e270a357809. It is advisable to implement a patch to correct this issue.
|
[
{
"commit_message": "[PATCH] Attempt to mitigate reflective XSS attack index.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSBhMjk0MTEwOWI0MjIwMWMxOTczMzEyN2NlZDc2M2UyNzBhMzU3ODA5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBTZWFuIFByb2N0b3IgPHNwcm9jdG9yQGdtYWlsLmNvbT4KRGF0ZTogVGh1LCAyOCBBcHIgMjAyMiAwODozNzo1MSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIEF0dGVtcHQgdG8gbWl0aWdhdGUgcmVmbGVjdGl2ZSBYU1MgYXR0YWNrCgotLS0KIGluZGV4LnBocCB8IDQgKystLQogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9pbmRleC5waHAgYi9pbmRleC5waHAKaW5kZXggZWI1OWIxMS4uMzA0MjRkOCAxMDA2NDQKLS0tIGEvaW5kZXgucGhwCisrKyBiL2luZGV4LnBocApAQCAtMzAsMTMgKzMwLDEzIEBACiAvKgogICogJHBocGNfcm9vdF9wYXRoIGdpdmVzIHRoZSBsb2NhdGlvbiBvZiB0aGUgYmFzZSBjYWxlbmRhciBpbnN0YWxsLgogICogaWYgeW91IG1vdmUgdGhpcyBmaWxlIHRvIGEgbmV3IGxvY2F0aW9uLCBtb2RpZnkgJHBocGNfcm9vdF9wYXRoIHRvIHBvaW50Ci0gKiB0byB0aGUgbG9jYXRpb24gd2hlcmUgdGhlIHN1cHBvcnQgZmlsZXMgZm9yIHRoZSBjYWxsZW5kYXIgYXJlIGxvY2F0ZWQuCisgKiB0byB0aGUgbG9jYXRpb24gd2hlcmUgdGhlIHN1cHBvcnQgZmlsZXMgZm9yIHRoZSBjYWxlbmRhciBhcmUgbG9jYXRlZC4KICAqLwogJHBocGNfcm9vdF9wYXRoID0gZGlybmFtZShfX0ZJTEVfXyk7CiAkcGhwY19pbmNsdWRlc19wYXRoID0gIiRwaHBjX3Jvb3RfcGF0aC9zcmMiOwogJHBocGNfY29uZmlnX2ZpbGUgPSAiJHBocGNfcm9vdF9wYXRoL2NvbmZpZy5waHAiOwogJHBocGNfbG9jYWxlX3BhdGggPSAiJHBocGNfcm9vdF9wYXRoL2xvY2FsZSI7Ci0kcGhwY19zY3JpcHQgPSBodG1sZW50aXRpZXMoJF9TRVJWRVJbJ1BIUF9TRUxGJ10pOworJHBocGNfc2NyaXB0ID0gaHRtbHNwZWNpYWxjaGFycygkX1NFUlZFUlsnUEhQX1NFTEYnXSwgRU5UX1FVT1RFUywgJ1VURi04Jyk7CiAKICRwaHBjX3NlcnZlciA9ICRfU0VSVkVSWydTRVJWRVJfTkFNRSddOwogaWYoIWVtcHR5KCRfU0VSVkVSWyJTRVJWRVJfUE9SVCJdKSAmJiAkX1NFUlZFUlsiU0VSVkVSX1BPUlQiXSAhPSA4MCk=",
"url": "https://github.com/sproctor/php-calendar/commit/a2941109b42201c19733127ced763e270a357809.patch"
}
] |
Cross Site Scripting
|
GHSA-v5x8-2g8c-7279
| null |
[
{
"commit_message": "[PATCH] Bugfix: Possible SQL injection in nat/item-add-submit.php. Fixes #2344 app/admin/nat/item-add-submit.php | 6 ++++++ misc/CHANGELOG | 1 + 2 files changed, 7 insertions(+)",
"patch_text_b64": "RnJvbSA4NTZiMTBjYTg1YTI0YzA0ZWQ4NjUxZjRlMTNmODY3ZWM3OGEzNTNkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBHYXJ5IEFsbGFuIDxnaXRodWJAZ2FsbGFuLmNvLnVrPgpEYXRlOiBUdWUsIDQgRGVjIDIwMTggMTk6NDg6MzcgKzAwMDAKU3ViamVjdDogW1BBVENIXSBCdWdmaXg6IFBvc3NpYmxlIFNRTCBpbmplY3Rpb24gaW4gbmF0L2l0ZW0tYWRkLXN1Ym1pdC5waHAuCiBGaXhlcyAjMjM0NAoKLS0tCiBhcHAvYWRtaW4vbmF0L2l0ZW0tYWRkLXN1Ym1pdC5waHAgfCA2ICsrKysrKwogbWlzYy9DSEFOR0VMT0cgICAgICAgICAgICAgICAgICAgIHwgMSArCiAyIGZpbGVzIGNoYW5nZWQsIDcgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2FwcC9hZG1pbi9uYXQvaXRlbS1hZGQtc3VibWl0LnBocCBiL2FwcC9hZG1pbi9uYXQvaXRlbS1hZGQtc3VibWl0LnBocAppbmRleCBkOTU0MTRhYzIuLjdlNzAzMzAyMyAxMDA2NDQKLS0tIGEvYXBwL2FkbWluL25hdC9pdGVtLWFkZC1zdWJtaXQucGhwCisrKyBiL2FwcC9hZG1pbi9uYXQvaXRlbS1hZGQtc3VibWl0LnBocApAQCAtOTEsNiArOTEsMTIgQEAKICAgICAkbmF0X2lkICAgPSAkX1BPU1RbJ2lkJ107ICAgICAgICAgICAgICAgLy8gbmF0IGlkCiAgICAgJG5hdF90eXBlID0gJF9QT1NUWyd0eXBlJ107ICAgICAgICAgICAgIC8vIHNyYywgZHN0CiAKKyAgICAvLyB2YWxpZGF0ZSBvYmplY3QgdHlwZQorICAgIGlmICghaW5fYXJyYXkoJG9ial90eXBlLCBbJ3N1Ym5ldHMnLCAnaXBhZGRyZXNzZXMnXSkpIHsgJFJlc3VsdC0+c2hvdygiZGFuZ2VyIiwgXygiSW52YWxpZCBvYmplY3QgdHlwZSIpLCB0cnVlKTsgfQorCisgICAgLy8gdmFsaWRhdGUgb2JqZWN0IGlkCisgICAgaWYgKCFpc19udW1lcmljKCRvYmpfaWQpKSB7ICRSZXN1bHQtPnNob3coImRhbmdlciIsIF8oIkludmFsaWQgb2JqZWN0IGlkIiksIHRydWUpOyB9CisKICAgICAvLyB2YWxpZGF0ZSBvYmplY3QKICAgICAkaXRlbSA9ICRUb29scy0+ZmV0Y2hfb2JqZWN0ICgkb2JqX3R5cGUsICJpZCIsICRvYmpfaWQpOwogICAgIGlmKCRpdGVtIT09ZmFsc2UpIHsKZGlmZiAtLWdpdCBhL21pc2MvQ0hBTkdFTE9HIGIvbWlzYy9DSEFOR0VMT0cKaW5kZXggZmEwZjg1NmM2Li4xYmE2MWI5MjYgMTAwNzU1Ci0tLSBhL21pc2MvQ0hBTkdFTE9HCisrKyBiL21pc2MvQ0hBTkdFTE9HCkBAIC01MSw2ICs1MSw3IEBACiAgICAgKyBIaWRlIExEQVAvQUQvUmFkaXVzIHVzZXJuYW1lIC8gcGFzc3dvcmQgYW5kIHNlY3JldCBmcm9tIGxvZ3MgYW5kIHN5c2xvZyAoIzIwMDYpOwogICAgICsgWFNTIGluIHBocGlwYW1yZWRpcmVjdCBjb29raWUgKCMyMzM4KTsKICAgICArIFhTUyBpbiBwcmludC11c2VyLnBocCwgQ1NSRiBpbiB1c2VyLWVkaXQucGhwICgjMjMyNik7CisgICAgKyBQb3NzaWJsZSBTUUwgaW5qZWN0aW9uIGluIG5hdC9pdGVtLWFkZC1zdWJtaXQucGhwICgjMjM0NCk7CiAKID09IDEuMy4y",
"url": "https://github.com/phpipam/phpipam/commit/856b10ca85a24c04ed8651f4e13f867ec78a353d.patch"
}
] | null |
|
GHSA-vxwr-wpjv-qjq7
|
XWiki Platform: Privilege escalation (PR) from user registration through PDFClass
| null |
[
{
"commit_message": "[PATCH] XWIKI-21337: Apply PDF templates with the rights of their authors (cherry picked from commit d28e21a670c69880b951e415dd2ddd69d273eae9) .../com/xpn/xwiki/pdf/impl/PdfExportImpl.java | 80 +++++--- .../xpn/xwiki/pdf/impl/PdfExportImplTest.java | 181 +++++++++++++++--- 2 files changed, 206 insertions(+), 55 deletions(-)",
"patch_text_b64": "From 480186f9d2fca880513da8bc5a609674d106cbd3 Mon Sep 17 00:00:00 2001
From: pjeanjean <pierre.jeanjean@xwiki.com>
Date: Thu, 19 Oct 2023 17:35:07 +0200
Subject: [PATCH] XWIKI-21337: Apply PDF templates with the rights of their
 authors

(cherry picked from commit d28e21a670c69880b951e415dd2ddd69d273eae9)
---
 .../com/xpn/xwiki/pdf/impl/PdfExportImpl.java |  80 +++++---
 .../xpn/xwiki/pdf/impl/PdfExportImplTest.java | 181 +++++++++++++++---
 2 files changed, 206 insertions(+), 55 deletions(-)

diff --git a/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java b/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java
index 9f471406bc61..b4d86b793d54 100644
--- a/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java
+++ b/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java
@@ -29,6 +29,7 @@
 import java.io.StringWriter;
 import java.lang.reflect.Type;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -37,9 +38,9 @@
 
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang.exception.ExceptionUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.velocity.VelocityContext;
 import org.dom4j.Element;
 import org.dom4j.io.OutputFormat;
@@ -54,8 +55,11 @@
 import org.xwiki.model.reference.DocumentReference;
 import org.xwiki.model.reference.DocumentReferenceResolver;
 import org.xwiki.model.reference.EntityReferenceSerializer;
+import org.xwiki.security.authorization.AuthorExecutor;
+import org.xwiki.security.authorization.AuthorizationManager;
+import org.xwiki.security.authorization.Right;
+import org.xwiki.user.UserReferenceSerializer;
 import org.xwiki.velocity.VelocityManager;
-import org.xwiki.velocity.XWikiVelocityException;
 import org.xwiki.xml.EntityResolver;
 import org.xwiki.xml.XMLReaderFactory;
 import org.xwiki.xml.XMLUtils;
@@ -95,30 +99,37 @@ public class PdfExportImpl implements PdfExport
     private static final Logger LOGGER = LoggerFactory.getLogger(PdfExportImpl.class);
 
     /** Document name resolver. */
-    private static DocumentReferenceResolver<String> referenceResolver =
+    private final DocumentReferenceResolver<String> referenceResolver =
         Utils.getComponent(DocumentReferenceResolver.TYPE_STRING, "currentmixed");
 
     /** Document name serializer. */
-    private static EntityReferenceSerializer<String> referenceSerializer =
+    private final EntityReferenceSerializer<String> referenceSerializer =
         Utils.getComponent(EntityReferenceSerializer.TYPE_STRING);
 
     /** Provides access to document properties. */
-    private static DocumentAccessBridge dab = Utils.getComponent(DocumentAccessBridge.class);
+    private final DocumentAccessBridge dab = Utils.getComponent(DocumentAccessBridge.class);
 
     /** Velocity engine manager, used for interpreting velocity. */
-    private static VelocityManager velocityManager = Utils.getComponent(VelocityManager.class);
+    private final VelocityManager velocityManager = Utils.getComponent(VelocityManager.class);
 
-    private static XMLReaderFactory xmlReaderFactory = Utils.getComponent(XMLReaderFactory.class);
+    private final XMLReaderFactory xmlReaderFactory = Utils.getComponent(XMLReaderFactory.class);
+
+    private final AuthorizationManager authorizationManager = Utils.getComponent(AuthorizationManager.class);
+
+    private final AuthorExecutor authorExecutor = Utils.getComponent(AuthorExecutor.class);
+
+    private final UserReferenceSerializer<DocumentReference> userReferenceSerializer =
+        Utils.getComponent(UserReferenceSerializer.TYPE_DOCUMENT_REFERENCE, "document");
 
     /**
      * Used to get the temporary directory.
      */
-    private Environment environment = Utils.getComponent((Type) Environment.class);
+    private final Environment environment = Utils.getComponent((Type) Environment.class);
 
     /**
      * Used to render XSL-FO to PDF.
      */
-    private XSLFORenderer xslFORenderer = Utils.getComponent(XSLFORenderer.class, "fop");
+    private final XSLFORenderer xslFORenderer = Utils.getComponent(XSLFORenderer.class, "fop");
 
     @Override
     public void exportToPDF(XWikiDocument doc, OutputStream out, XWikiContext context) throws XWikiException
@@ -184,7 +195,7 @@ private String convertToStrictXHtml(String input)
 
         HTMLCleaner cleaner = Utils.getComponent(HTMLCleaner.class);
         HTMLCleanerConfiguration config = cleaner.getDefaultConfiguration();
-        List<HTMLFilter> filters = new ArrayList<HTMLFilter>(config.getFilters());
+        List<HTMLFilter> filters = new ArrayList<>(config.getFilters());
         filters.add(Utils.getComponent(HTMLFilter.class, "uniqueId"));
         config.setFilters(filters);
         String result = HTMLUtils.toString(cleaner.clean(new StringReader(input), config));
@@ -261,7 +272,7 @@ private void renderXSLFO(String xmlfo, OutputStream out, ExportType type, final
         throws XWikiException
     {
         try {
-            this.xslFORenderer.render(new ByteArrayInputStream(xmlfo.getBytes("UTF-8")), out, type.getMimeType());
+            this.xslFORenderer.render(new ByteArrayInputStream(xmlfo.getBytes(StandardCharsets.UTF_8)), out, type.getMimeType());
         } catch (IllegalStateException e) {
             throw createException(e, type, XWikiException.ERROR_XWIKI_APP_SEND_RESPONSE_EXCEPTION);
         } catch (Exception e) {
@@ -338,7 +349,7 @@ String applyCSS(String html, String css, XWikiContext context)
 
             // Dom4J 2.1.1 disables external DTDs by default, so we set our own XMLReader.
             // See https://github.com/dom4j/dom4j/issues/51
-            XMLReader xmlReader = xmlReaderFactory.createXMLReader();
+            XMLReader xmlReader = this.xmlReaderFactory.createXMLReader();
             reader.setXMLReader(xmlReader);
 
             reader.setEntityResolver(new DefaultEntityResolver());
@@ -465,28 +476,47 @@ private String getPDFTemplateProperty(String propertyName, XWikiContext context)
         DocumentReference templateReference;
         DocumentReference classReference;
         if (StringUtils.isNotEmpty(pdftemplate)) {
-            templateReference = referenceResolver.resolve(pdftemplate);
+            templateReference = this.referenceResolver.resolve(pdftemplate);
             classReference = new DocumentReference(templateReference.getWikiReference().getName(), "XWiki", "PDFClass");
         } else {
-            templateReference = dab.getCurrentDocumentReference();
-            String currentWiki = dab.getCurrentDocumentReference().getRoot().getName();
+            templateReference = this.dab.getCurrentDocumentReference();
+            String currentWiki = this.dab.getCurrentDocumentReference().getRoot().getName();
             classReference = new DocumentReference(currentWiki, "XWiki", "PDFClass");
         }
 
-        String result = (String) dab.getProperty(templateReference, classReference, propertyName);
-        if (StringUtils.isBlank(result)) {
+        String templateContent = (String) this.dab.getProperty(templateReference, classReference, propertyName);
+        if (StringUtils.isBlank(templateContent)) {
             return "";
         }
-        String templateName = referenceSerializer.serialize(templateReference);
+
+        String templateName = this.referenceSerializer.serialize(templateReference);
+        DocumentReference templateAuthorReference;
+        String result = templateContent;
         try {
-            StringWriter writer = new StringWriter();
-            VelocityContext vcontext = velocityManager.getVelocityContext();
-            velocityManager.getVelocityEngine().evaluate(vcontext, writer, templateName, result);
-            result = writer.toString();
-        } catch (XWikiVelocityException e) {
-            LOGGER.warn("Error applying Velocity to the [{}] property of the [{}] document. Using the property's value "
-                + "without applying Velocity.", propertyName, templateName, ExceptionUtils.getRootCauseMessage(e));
+             templateAuthorReference = this.userReferenceSerializer.serialize(
+                 this.dab.getDocumentInstance(templateReference).getAuthors().getEffectiveMetadataAuthor());
+        } catch (Exception e) {
+            LOGGER.warn("Error fetching the author of template [{}] during PDF conversion. Using the [{}] property of "
+                + "the document's value without applying Velocity.", templateName, propertyName);
+            return result;
         }
+
+        if (this.authorizationManager.hasAccess(Right.SCRIPT, templateAuthorReference, templateReference)) {
+            try {
+                result = this.authorExecutor.call(() -> {
+                    StringWriter writer = new StringWriter();
+                    VelocityContext vcontext = this.velocityManager.getVelocityContext();
+                    this.velocityManager.getVelocityEngine().evaluate(vcontext, writer, templateName,
+                        templateContent);
+                    return writer.toString();
+                }, templateAuthorReference, templateReference);
+            } catch (Exception e) {
+                LOGGER.warn("Failed to run Velocity engine in author executor. Using the [{}] property of the [{}] "
+                    + "document's value without applying Velocity. Reason: [{}]",
+                    propertyName, templateName, ExceptionUtils.getRootCauseMessage(e));
+            }
+        }
+
         return result;
     }
 
diff --git a/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java b/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java
index 7532ee3167a9..b273f8544617 100644
--- a/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java
+++ b/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java
@@ -19,23 +19,55 @@
  */
 package com.xpn.xwiki.pdf.impl;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.StringReader;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.w3c.dom.Document;
 import org.xwiki.bridge.DocumentAccessBridge;
 import org.xwiki.environment.Environment;
-import org.xwiki.model.reference.DocumentReferenceResolver;
-import org.xwiki.model.reference.EntityReferenceSerializer;
+import org.xwiki.job.event.status.JobProgressManager;
+import org.xwiki.model.reference.DocumentReference;
+import org.xwiki.observation.ObservationManager;
+import org.xwiki.security.authorization.AuthorExecutor;
+import org.xwiki.security.authorization.AuthorizationManager;
+import org.xwiki.security.authorization.Right;
+import org.xwiki.template.TemplateManager;
 import org.xwiki.test.annotation.ComponentList;
+import org.xwiki.test.junit5.mockito.MockComponent;
+import org.xwiki.user.UserReference;
+import org.xwiki.user.UserReferenceResolver;
+import org.xwiki.velocity.VelocityEngine;
 import org.xwiki.velocity.VelocityManager;
+import org.xwiki.xml.EntityResolver;
+import org.xwiki.xml.html.HTMLCleaner;
+import org.xwiki.xml.html.HTMLCleanerConfiguration;
+import org.xwiki.xml.html.filter.HTMLFilter;
+import org.xwiki.xml.internal.XMLReaderFactoryComponent;
+import org.xwiki.xml.internal.html.DefaultHTMLCleanerConfiguration;
 
 import com.xpn.xwiki.XWikiContext;
 import com.xpn.xwiki.doc.XWikiDocument;
 import com.xpn.xwiki.internal.pdf.XSLFORenderer;
+import com.xpn.xwiki.pdf.api.PdfExport;
 import com.xpn.xwiki.test.MockitoOldcore;
 import com.xpn.xwiki.test.junit5.mockito.InjectMockitoOldcore;
 import com.xpn.xwiki.test.junit5.mockito.OldcoreTest;
+import com.xpn.xwiki.test.reference.ReferenceComponentList;
+import com.xpn.xwiki.web.XWikiServletRequestStub;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
 /**
@@ -44,40 +76,59 @@
  * @version $Id$
  */
 @ComponentList({
-    org.xwiki.xml.internal.XMLReaderFactoryComponent.class,
+    XMLReaderFactoryComponent.class,
 })
+@ReferenceComponentList
 @OldcoreTest
-public class PdfExportImplTest
+class PdfExportImplTest
 {
+    private static final DocumentReference AUTHOR_REFERENCE = new DocumentReference("xwiki", "XWiki", "XWikiAdmin");
+
+    private static final DocumentReference DOCUMENT_REFERENCE = new DocumentReference("xwiki", "XWiki", "PDFClass");
+
     @InjectMockitoOldcore
     private MockitoOldcore oldcore;
 
-    /**
-     * Verify that PDF Export can apply some CSS on the XHTML when that XHTML already has some style defined and in
-     * shorthand notation.
-     */
-    @Test
-    public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exception
+    @Mock
+    private VelocityEngine velocityEngine;
+
+    @MockComponent
+    private AuthorizationManager authorizationManager;
+
+    @MockComponent
+    private HTMLCleaner htmlCleaner;
+
+    @MockComponent
+    private AuthorExecutor authorExecutor;
+
+    private String htmlContent;
+
+    private String cssProperties;
+
+    private XWikiContext context;
+
+    private PdfExportImpl pdfExport;
+
+    @BeforeEach
+    void setUp() throws Exception
     {
-        this.oldcore.getMocker().registerMockComponent(DocumentReferenceResolver.TYPE_STRING, "currentmixed");
-        this.oldcore.getMocker().registerMockComponent(EntityReferenceSerializer.TYPE_STRING);
-        this.oldcore.getMocker().registerMockComponent(DocumentAccessBridge.class);
-        this.oldcore.getMocker().registerMockComponent(DocumentAccessBridge.class);
         this.oldcore.getMocker().registerMockComponent(PDFResourceResolver.class);
         this.oldcore.getMocker().registerMockComponent(Environment.class);
-        this.oldcore.getMocker().registerMockComponent(VelocityManager.class);
+        this.oldcore.getMocker().registerMockComponent(TemplateManager.class);
+        this.oldcore.getMocker().registerMockComponent(ObservationManager.class);
+        this.oldcore.getMocker().registerMockComponent(JobProgressManager.class);
+        this.oldcore.getMocker().registerMockComponent(EntityResolver.class);
         this.oldcore.getMocker().registerMockComponent(XSLFORenderer.class, "fop");
-
-        PdfExportImpl pdfExport = new PdfExportImpl();
+        this.oldcore.getMocker().registerMockComponent(HTMLFilter.class, "uniqueId");
 
         // The content below allows us to test several points:
         // 1) The SPAN below already has some style defined in shorthand notation( "background" is shorthand,
         //    see https://www.w3schools.com/css/css_background.asp). That's important for the test since that's what was
         //    failing in the past and why this test was written.
         // 2) We also test that HTML entities are correctly kept since we had issues with this at one point.
-        String html = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+        this.htmlContent = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
             + "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" "
-                + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
+            + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
             + "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head>\n"
             + "<title>\n"
             + "  Main.ttt - ttt\n"
@@ -98,13 +149,51 @@ public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exce
             + "\n"
             + "</body></html>";
 
-        String css = "span { color:red; }";
+        this.cssProperties = "span { color:red; }";
 
-        XWikiContext xcontext = this.oldcore.getXWikiContext();
+        // Set up HTML cleaner.
+        Document htmlDocument = DocumentBuilderFactory.newInstance().newDocumentBuilder()
+            .parse(new ByteArrayInputStream(this.htmlContent.getBytes()));
+        HTMLCleanerConfiguration cleanerConfiguration = new DefaultHTMLCleanerConfiguration();
+        when(this.htmlCleaner.getDefaultConfiguration()).thenReturn(cleanerConfiguration);
+        when(this.htmlCleaner.clean(any(StringReader.class), eq(cleanerConfiguration))).thenReturn(htmlDocument);
+
+        // Get a mocked Velocity Engine.
+        VelocityManager velocityManager = this.oldcore.getMocker().registerMockComponent(VelocityManager.class);
+        when(velocityManager.getVelocityEngine()).thenReturn(this.velocityEngine);
+
+        // Prepare a document reference and author reference for the template.
+        XWikiDocument template = new XWikiDocument(DOCUMENT_REFERENCE);
+        UserReferenceResolver<DocumentReference> userReferenceResolver =
+            this.oldcore.getMocker().getInstance(UserReferenceResolver.TYPE_DOCUMENT_REFERENCE, "document");
+        UserReference userReference = userReferenceResolver.resolve(AUTHOR_REFERENCE);
+        template.getAuthors().setEffectiveMetadataAuthor(userReference);
+
+        // Return a non-empty template property.
+        DocumentAccessBridge dab = this.oldcore.getDocumentAccessBridge();
+        when(dab.getProperty(template.getDocumentReference(), template.getDocumentReference(), "style"))
+            .thenReturn(this.cssProperties);
+        when(dab.getDocumentInstance(DOCUMENT_REFERENCE)).thenReturn(template);
+
+        // Set necessary parameters in the request.
+        this.context = this.oldcore.getXWikiContext();
+        XWikiServletRequestStub request = new XWikiServletRequestStub();
+        request.put("pdftemplate", "XWiki.PDFClass");
+        this.context.setRequest(request);
         XWikiDocument doc = mock(XWikiDocument.class);
-        when(doc.getExternalURL("view", xcontext)).thenReturn("http://localhost:8080/export");
-        xcontext.setDoc(doc);
+        when(doc.getExternalURL("view", this.context)).thenReturn("http://localhost:8080/export");
+        this.context.setDoc(doc);
 
+        this.pdfExport = new PdfExportImpl();
+    }
+
+    /**
+     * Verify that PDF Export can apply some CSS on the XHTML when that XHTML already has some style defined and in
+     * shorthand notation.
+     */
+    @Test
+    void applyCSSWhenExistingStyleDefinedUsingShorthandNotation()
+    {
         // - Verify that element's style attributes are normalized and that the SPAN's color is set to red.
         // - Verify that the accent in the content is still there.
         //   TODO: right now we output the DOM with DOM4J and use the default of converting entities when using the
@@ -113,8 +202,8 @@ public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exce
 
         String expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
             + "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" "
-                + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"
-                + "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head>\n"
+            + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"
+            + "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head>\n"
             + "<title>\n"
             + "  Main.ttt - ttt\n"
             + "</title>\n"
@@ -124,15 +213,47 @@ public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exce
             + "<div id=\"xwikimaincontainer\">\n"
             + "<div id=\"xwikimaincontainerinner\">\n\n"
             + "<div id=\"xwikicontent\">\n"
-                + "      <p><span style=\"color: #f00; background-color: #fff; background-image: none; "
-                + "background-position: 0% 0%; background-size: auto auto; background-origin: padding-box; "
-                + "background-clip: border-box; background-repeat: repeat repeat; "
-                + "background-attachment: scroll; \">Hello Clément</span></p>\n"
+            + "      <p><span style=\"color: #f00; background-color: #fff; background-image: none; "
+            + "background-position: 0% 0%; background-size: auto auto; background-origin: padding-box; "
+            + "background-clip: border-box; background-repeat: repeat repeat; "
+            + "background-attachment: scroll; \">Hello Clément</span></p>\n"
             + "          </div>\n"
             + "</div>\n"
             + "</div>\n\n"
             + "</body></html>";
 
-        assertEquals(expected, pdfExport.applyCSS(html, css, xcontext));
+        assertEquals(expected, this.pdfExport.applyCSS(this.htmlContent, this.cssProperties, this.context));
+    }
+
+    /**
+     * Verify that the Velocity Engine is never accessed if the user does not have script rights.
+     */
+    @Test
+    void applyPDFTemplateWithoutScriptRights() throws Exception
+    {
+        when(this.authorizationManager.hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE)).thenReturn(false);
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        this.pdfExport.exportHtml(this.htmlContent, baos, PdfExport.ExportType.PDF, this.context);
+        verify(this.authorizationManager).hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE);
+        verifyNoInteractions(this.authorExecutor);
+        verifyNoInteractions(this.velocityEngine);
+    }
+
+    /**
+     * Verify that the Velocity Engine is not accessed outside an Author Executor.
+     */
+    @Test
+    void applyPDFTemplateWithAuthorExecutor() throws Exception
+    {
+        when(this.authorizationManager.hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE)).thenReturn(true);
+
+        // Do not call the callable to check that the call to the Velocity engine is inside the author executor.
+        doReturn("").when(this.authorExecutor).call(any(), any(), any());
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        this.pdfExport.exportHtml(this.htmlContent, baos, PdfExport.ExportType.PDF, this.context);
+        verify(this.authorizationManager).hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE);
+        verify(this.authorExecutor).call(any(), eq(AUTHOR_REFERENCE), eq(DOCUMENT_REFERENCE));
+        verifyNoInteractions(this.velocityEngine);
     }
 }",
"url": "https://github.com/xwiki/xwiki-platform/commit/480186f9d2fca880513da8bc5a609674d106cbd3.patch"
},
{
"commit_message": "[PATCH] XWIKI-21337: Apply PDF templates with the rights of their authors (cherry picked from commit d28e21a670c69880b951e415dd2ddd69d273eae9) .../com/xpn/xwiki/pdf/impl/PdfExportImpl.java | 80 +++++--- .../xpn/xwiki/pdf/impl/PdfExportImplTest.java | 181 +++++++++++++++--- 2 files changed, 206 insertions(+), 55 deletions(-)",
"patch_text_b64": "From a4ad14d9c1605a5ab957237e505ebbb29f5b9d73 Mon Sep 17 00:00:00 2001
From: pjeanjean <pierre.jeanjean@xwiki.com>
Date: Thu, 19 Oct 2023 17:35:07 +0200
Subject: [PATCH] XWIKI-21337: Apply PDF templates with the rights of their
 authors

(cherry picked from commit d28e21a670c69880b951e415dd2ddd69d273eae9)
---
 .../com/xpn/xwiki/pdf/impl/PdfExportImpl.java |  80 +++++---
 .../xpn/xwiki/pdf/impl/PdfExportImplTest.java | 181 +++++++++++++++---
 2 files changed, 206 insertions(+), 55 deletions(-)

diff --git a/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java b/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java
index 9f471406bc61..b4d86b793d54 100644
--- a/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java
+++ b/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java
@@ -29,6 +29,7 @@
 import java.io.StringWriter;
 import java.lang.reflect.Type;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -37,9 +38,9 @@
 
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang.exception.ExceptionUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.velocity.VelocityContext;
 import org.dom4j.Element;
 import org.dom4j.io.OutputFormat;
@@ -54,8 +55,11 @@
 import org.xwiki.model.reference.DocumentReference;
 import org.xwiki.model.reference.DocumentReferenceResolver;
 import org.xwiki.model.reference.EntityReferenceSerializer;
+import org.xwiki.security.authorization.AuthorExecutor;
+import org.xwiki.security.authorization.AuthorizationManager;
+import org.xwiki.security.authorization.Right;
+import org.xwiki.user.UserReferenceSerializer;
 import org.xwiki.velocity.VelocityManager;
-import org.xwiki.velocity.XWikiVelocityException;
 import org.xwiki.xml.EntityResolver;
 import org.xwiki.xml.XMLReaderFactory;
 import org.xwiki.xml.XMLUtils;
@@ -95,30 +99,37 @@ public class PdfExportImpl implements PdfExport
     private static final Logger LOGGER = LoggerFactory.getLogger(PdfExportImpl.class);
 
     /** Document name resolver. */
-    private static DocumentReferenceResolver<String> referenceResolver =
+    private final DocumentReferenceResolver<String> referenceResolver =
         Utils.getComponent(DocumentReferenceResolver.TYPE_STRING, "currentmixed");
 
     /** Document name serializer. */
-    private static EntityReferenceSerializer<String> referenceSerializer =
+    private final EntityReferenceSerializer<String> referenceSerializer =
         Utils.getComponent(EntityReferenceSerializer.TYPE_STRING);
 
     /** Provides access to document properties. */
-    private static DocumentAccessBridge dab = Utils.getComponent(DocumentAccessBridge.class);
+    private final DocumentAccessBridge dab = Utils.getComponent(DocumentAccessBridge.class);
 
     /** Velocity engine manager, used for interpreting velocity. */
-    private static VelocityManager velocityManager = Utils.getComponent(VelocityManager.class);
+    private final VelocityManager velocityManager = Utils.getComponent(VelocityManager.class);
 
-    private static XMLReaderFactory xmlReaderFactory = Utils.getComponent(XMLReaderFactory.class);
+    private final XMLReaderFactory xmlReaderFactory = Utils.getComponent(XMLReaderFactory.class);
+
+    private final AuthorizationManager authorizationManager = Utils.getComponent(AuthorizationManager.class);
+
+    private final AuthorExecutor authorExecutor = Utils.getComponent(AuthorExecutor.class);
+
+    private final UserReferenceSerializer<DocumentReference> userReferenceSerializer =
+        Utils.getComponent(UserReferenceSerializer.TYPE_DOCUMENT_REFERENCE, "document");
 
     /**
      * Used to get the temporary directory.
      */
-    private Environment environment = Utils.getComponent((Type) Environment.class);
+    private final Environment environment = Utils.getComponent((Type) Environment.class);
 
     /**
      * Used to render XSL-FO to PDF.
      */
-    private XSLFORenderer xslFORenderer = Utils.getComponent(XSLFORenderer.class, "fop");
+    private final XSLFORenderer xslFORenderer = Utils.getComponent(XSLFORenderer.class, "fop");
 
     @Override
     public void exportToPDF(XWikiDocument doc, OutputStream out, XWikiContext context) throws XWikiException
@@ -184,7 +195,7 @@ private String convertToStrictXHtml(String input)
 
         HTMLCleaner cleaner = Utils.getComponent(HTMLCleaner.class);
         HTMLCleanerConfiguration config = cleaner.getDefaultConfiguration();
-        List<HTMLFilter> filters = new ArrayList<HTMLFilter>(config.getFilters());
+        List<HTMLFilter> filters = new ArrayList<>(config.getFilters());
         filters.add(Utils.getComponent(HTMLFilter.class, "uniqueId"));
         config.setFilters(filters);
         String result = HTMLUtils.toString(cleaner.clean(new StringReader(input), config));
@@ -261,7 +272,7 @@ private void renderXSLFO(String xmlfo, OutputStream out, ExportType type, final
         throws XWikiException
     {
         try {
-            this.xslFORenderer.render(new ByteArrayInputStream(xmlfo.getBytes("UTF-8")), out, type.getMimeType());
+            this.xslFORenderer.render(new ByteArrayInputStream(xmlfo.getBytes(StandardCharsets.UTF_8)), out, type.getMimeType());
         } catch (IllegalStateException e) {
             throw createException(e, type, XWikiException.ERROR_XWIKI_APP_SEND_RESPONSE_EXCEPTION);
         } catch (Exception e) {
@@ -338,7 +349,7 @@ String applyCSS(String html, String css, XWikiContext context)
 
             // Dom4J 2.1.1 disables external DTDs by default, so we set our own XMLReader.
             // See https://github.com/dom4j/dom4j/issues/51
-            XMLReader xmlReader = xmlReaderFactory.createXMLReader();
+            XMLReader xmlReader = this.xmlReaderFactory.createXMLReader();
             reader.setXMLReader(xmlReader);
 
             reader.setEntityResolver(new DefaultEntityResolver());
@@ -465,28 +476,47 @@ private String getPDFTemplateProperty(String propertyName, XWikiContext context)
         DocumentReference templateReference;
         DocumentReference classReference;
         if (StringUtils.isNotEmpty(pdftemplate)) {
-            templateReference = referenceResolver.resolve(pdftemplate);
+            templateReference = this.referenceResolver.resolve(pdftemplate);
             classReference = new DocumentReference(templateReference.getWikiReference().getName(), "XWiki", "PDFClass");
         } else {
-            templateReference = dab.getCurrentDocumentReference();
-            String currentWiki = dab.getCurrentDocumentReference().getRoot().getName();
+            templateReference = this.dab.getCurrentDocumentReference();
+            String currentWiki = this.dab.getCurrentDocumentReference().getRoot().getName();
             classReference = new DocumentReference(currentWiki, "XWiki", "PDFClass");
         }
 
-        String result = (String) dab.getProperty(templateReference, classReference, propertyName);
-        if (StringUtils.isBlank(result)) {
+        String templateContent = (String) this.dab.getProperty(templateReference, classReference, propertyName);
+        if (StringUtils.isBlank(templateContent)) {
             return "";
         }
-        String templateName = referenceSerializer.serialize(templateReference);
+
+        String templateName = this.referenceSerializer.serialize(templateReference);
+        DocumentReference templateAuthorReference;
+        String result = templateContent;
         try {
-            StringWriter writer = new StringWriter();
-            VelocityContext vcontext = velocityManager.getVelocityContext();
-            velocityManager.getVelocityEngine().evaluate(vcontext, writer, templateName, result);
-            result = writer.toString();
-        } catch (XWikiVelocityException e) {
-            LOGGER.warn("Error applying Velocity to the [{}] property of the [{}] document. Using the property's value "
-                + "without applying Velocity.", propertyName, templateName, ExceptionUtils.getRootCauseMessage(e));
+             templateAuthorReference = this.userReferenceSerializer.serialize(
+                 this.dab.getDocumentInstance(templateReference).getAuthors().getEffectiveMetadataAuthor());
+        } catch (Exception e) {
+            LOGGER.warn("Error fetching the author of template [{}] during PDF conversion. Using the [{}] property of "
+                + "the document's value without applying Velocity.", templateName, propertyName);
+            return result;
         }
+
+        if (this.authorizationManager.hasAccess(Right.SCRIPT, templateAuthorReference, templateReference)) {
+            try {
+                result = this.authorExecutor.call(() -> {
+                    StringWriter writer = new StringWriter();
+                    VelocityContext vcontext = this.velocityManager.getVelocityContext();
+                    this.velocityManager.getVelocityEngine().evaluate(vcontext, writer, templateName,
+                        templateContent);
+                    return writer.toString();
+                }, templateAuthorReference, templateReference);
+            } catch (Exception e) {
+                LOGGER.warn("Failed to run Velocity engine in author executor. Using the [{}] property of the [{}] "
+                    + "document's value without applying Velocity. Reason: [{}]",
+                    propertyName, templateName, ExceptionUtils.getRootCauseMessage(e));
+            }
+        }
+
         return result;
     }
 
diff --git a/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java b/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java
index 7532ee3167a9..b273f8544617 100644
--- a/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java
+++ b/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java
@@ -19,23 +19,55 @@
  */
 package com.xpn.xwiki.pdf.impl;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.StringReader;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.w3c.dom.Document;
 import org.xwiki.bridge.DocumentAccessBridge;
 import org.xwiki.environment.Environment;
-import org.xwiki.model.reference.DocumentReferenceResolver;
-import org.xwiki.model.reference.EntityReferenceSerializer;
+import org.xwiki.job.event.status.JobProgressManager;
+import org.xwiki.model.reference.DocumentReference;
+import org.xwiki.observation.ObservationManager;
+import org.xwiki.security.authorization.AuthorExecutor;
+import org.xwiki.security.authorization.AuthorizationManager;
+import org.xwiki.security.authorization.Right;
+import org.xwiki.template.TemplateManager;
 import org.xwiki.test.annotation.ComponentList;
+import org.xwiki.test.junit5.mockito.MockComponent;
+import org.xwiki.user.UserReference;
+import org.xwiki.user.UserReferenceResolver;
+import org.xwiki.velocity.VelocityEngine;
 import org.xwiki.velocity.VelocityManager;
+import org.xwiki.xml.EntityResolver;
+import org.xwiki.xml.html.HTMLCleaner;
+import org.xwiki.xml.html.HTMLCleanerConfiguration;
+import org.xwiki.xml.html.filter.HTMLFilter;
+import org.xwiki.xml.internal.XMLReaderFactoryComponent;
+import org.xwiki.xml.internal.html.DefaultHTMLCleanerConfiguration;
 
 import com.xpn.xwiki.XWikiContext;
 import com.xpn.xwiki.doc.XWikiDocument;
 import com.xpn.xwiki.internal.pdf.XSLFORenderer;
+import com.xpn.xwiki.pdf.api.PdfExport;
 import com.xpn.xwiki.test.MockitoOldcore;
 import com.xpn.xwiki.test.junit5.mockito.InjectMockitoOldcore;
 import com.xpn.xwiki.test.junit5.mockito.OldcoreTest;
+import com.xpn.xwiki.test.reference.ReferenceComponentList;
+import com.xpn.xwiki.web.XWikiServletRequestStub;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
 /**
@@ -44,40 +76,59 @@
  * @version $Id$
  */
 @ComponentList({
-    org.xwiki.xml.internal.XMLReaderFactoryComponent.class,
+    XMLReaderFactoryComponent.class,
 })
+@ReferenceComponentList
 @OldcoreTest
-public class PdfExportImplTest
+class PdfExportImplTest
 {
+    private static final DocumentReference AUTHOR_REFERENCE = new DocumentReference("xwiki", "XWiki", "XWikiAdmin");
+
+    private static final DocumentReference DOCUMENT_REFERENCE = new DocumentReference("xwiki", "XWiki", "PDFClass");
+
     @InjectMockitoOldcore
     private MockitoOldcore oldcore;
 
-    /**
-     * Verify that PDF Export can apply some CSS on the XHTML when that XHTML already has some style defined and in
-     * shorthand notation.
-     */
-    @Test
-    public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exception
+    @Mock
+    private VelocityEngine velocityEngine;
+
+    @MockComponent
+    private AuthorizationManager authorizationManager;
+
+    @MockComponent
+    private HTMLCleaner htmlCleaner;
+
+    @MockComponent
+    private AuthorExecutor authorExecutor;
+
+    private String htmlContent;
+
+    private String cssProperties;
+
+    private XWikiContext context;
+
+    private PdfExportImpl pdfExport;
+
+    @BeforeEach
+    void setUp() throws Exception
     {
-        this.oldcore.getMocker().registerMockComponent(DocumentReferenceResolver.TYPE_STRING, "currentmixed");
-        this.oldcore.getMocker().registerMockComponent(EntityReferenceSerializer.TYPE_STRING);
-        this.oldcore.getMocker().registerMockComponent(DocumentAccessBridge.class);
-        this.oldcore.getMocker().registerMockComponent(DocumentAccessBridge.class);
         this.oldcore.getMocker().registerMockComponent(PDFResourceResolver.class);
         this.oldcore.getMocker().registerMockComponent(Environment.class);
-        this.oldcore.getMocker().registerMockComponent(VelocityManager.class);
+        this.oldcore.getMocker().registerMockComponent(TemplateManager.class);
+        this.oldcore.getMocker().registerMockComponent(ObservationManager.class);
+        this.oldcore.getMocker().registerMockComponent(JobProgressManager.class);
+        this.oldcore.getMocker().registerMockComponent(EntityResolver.class);
         this.oldcore.getMocker().registerMockComponent(XSLFORenderer.class, "fop");
-
-        PdfExportImpl pdfExport = new PdfExportImpl();
+        this.oldcore.getMocker().registerMockComponent(HTMLFilter.class, "uniqueId");
 
         // The content below allows us to test several points:
         // 1) The SPAN below already has some style defined in shorthand notation( "background" is shorthand,
         //    see https://www.w3schools.com/css/css_background.asp). That's important for the test since that's what was
         //    failing in the past and why this test was written.
         // 2) We also test that HTML entities are correctly kept since we had issues with this at one point.
-        String html = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+        this.htmlContent = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
             + "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" "
-                + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
+            + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
             + "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head>\n"
             + "<title>\n"
             + "  Main.ttt - ttt\n"
@@ -98,13 +149,51 @@ public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exce
             + "\n"
             + "</body></html>";
 
-        String css = "span { color:red; }";
+        this.cssProperties = "span { color:red; }";
 
-        XWikiContext xcontext = this.oldcore.getXWikiContext();
+        // Set up HTML cleaner.
+        Document htmlDocument = DocumentBuilderFactory.newInstance().newDocumentBuilder()
+            .parse(new ByteArrayInputStream(this.htmlContent.getBytes()));
+        HTMLCleanerConfiguration cleanerConfiguration = new DefaultHTMLCleanerConfiguration();
+        when(this.htmlCleaner.getDefaultConfiguration()).thenReturn(cleanerConfiguration);
+        when(this.htmlCleaner.clean(any(StringReader.class), eq(cleanerConfiguration))).thenReturn(htmlDocument);
+
+        // Get a mocked Velocity Engine.
+        VelocityManager velocityManager = this.oldcore.getMocker().registerMockComponent(VelocityManager.class);
+        when(velocityManager.getVelocityEngine()).thenReturn(this.velocityEngine);
+
+        // Prepare a document reference and author reference for the template.
+        XWikiDocument template = new XWikiDocument(DOCUMENT_REFERENCE);
+        UserReferenceResolver<DocumentReference> userReferenceResolver =
+            this.oldcore.getMocker().getInstance(UserReferenceResolver.TYPE_DOCUMENT_REFERENCE, "document");
+        UserReference userReference = userReferenceResolver.resolve(AUTHOR_REFERENCE);
+        template.getAuthors().setEffectiveMetadataAuthor(userReference);
+
+        // Return a non-empty template property.
+        DocumentAccessBridge dab = this.oldcore.getDocumentAccessBridge();
+        when(dab.getProperty(template.getDocumentReference(), template.getDocumentReference(), "style"))
+            .thenReturn(this.cssProperties);
+        when(dab.getDocumentInstance(DOCUMENT_REFERENCE)).thenReturn(template);
+
+        // Set necessary parameters in the request.
+        this.context = this.oldcore.getXWikiContext();
+        XWikiServletRequestStub request = new XWikiServletRequestStub();
+        request.put("pdftemplate", "XWiki.PDFClass");
+        this.context.setRequest(request);
         XWikiDocument doc = mock(XWikiDocument.class);
-        when(doc.getExternalURL("view", xcontext)).thenReturn("http://localhost:8080/export");
-        xcontext.setDoc(doc);
+        when(doc.getExternalURL("view", this.context)).thenReturn("http://localhost:8080/export");
+        this.context.setDoc(doc);
 
+        this.pdfExport = new PdfExportImpl();
+    }
+
+    /**
+     * Verify that PDF Export can apply some CSS on the XHTML when that XHTML already has some style defined and in
+     * shorthand notation.
+     */
+    @Test
+    void applyCSSWhenExistingStyleDefinedUsingShorthandNotation()
+    {
         // - Verify that element's style attributes are normalized and that the SPAN's color is set to red.
         // - Verify that the accent in the content is still there.
         //   TODO: right now we output the DOM with DOM4J and use the default of converting entities when using the
@@ -113,8 +202,8 @@ public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exce
 
         String expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
             + "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" "
-                + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"
-                + "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head>\n"
+            + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"
+            + "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head>\n"
             + "<title>\n"
             + "  Main.ttt - ttt\n"
             + "</title>\n"
@@ -124,15 +213,47 @@ public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exce
             + "<div id=\"xwikimaincontainer\">\n"
             + "<div id=\"xwikimaincontainerinner\">\n\n"
             + "<div id=\"xwikicontent\">\n"
-                + "      <p><span style=\"color: #f00; background-color: #fff; background-image: none; "
-                + "background-position: 0% 0%; background-size: auto auto; background-origin: padding-box; "
-                + "background-clip: border-box; background-repeat: repeat repeat; "
-                + "background-attachment: scroll; \">Hello Clément</span></p>\n"
+            + "      <p><span style=\"color: #f00; background-color: #fff; background-image: none; "
+            + "background-position: 0% 0%; background-size: auto auto; background-origin: padding-box; "
+            + "background-clip: border-box; background-repeat: repeat repeat; "
+            + "background-attachment: scroll; \">Hello Clément</span></p>\n"
             + "          </div>\n"
             + "</div>\n"
             + "</div>\n\n"
             + "</body></html>";
 
-        assertEquals(expected, pdfExport.applyCSS(html, css, xcontext));
+        assertEquals(expected, this.pdfExport.applyCSS(this.htmlContent, this.cssProperties, this.context));
+    }
+
+    /**
+     * Verify that the Velocity Engine is never accessed if the user does not have script rights.
+     */
+    @Test
+    void applyPDFTemplateWithoutScriptRights() throws Exception
+    {
+        when(this.authorizationManager.hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE)).thenReturn(false);
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        this.pdfExport.exportHtml(this.htmlContent, baos, PdfExport.ExportType.PDF, this.context);
+        verify(this.authorizationManager).hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE);
+        verifyNoInteractions(this.authorExecutor);
+        verifyNoInteractions(this.velocityEngine);
+    }
+
+    /**
+     * Verify that the Velocity Engine is not accessed outside an Author Executor.
+     */
+    @Test
+    void applyPDFTemplateWithAuthorExecutor() throws Exception
+    {
+        when(this.authorizationManager.hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE)).thenReturn(true);
+
+        // Do not call the callable to check that the call to the Velocity engine is inside the author executor.
+        doReturn("").when(this.authorExecutor).call(any(), any(), any());
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        this.pdfExport.exportHtml(this.htmlContent, baos, PdfExport.ExportType.PDF, this.context);
+        verify(this.authorizationManager).hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE);
+        verify(this.authorExecutor).call(any(), eq(AUTHOR_REFERENCE), eq(DOCUMENT_REFERENCE));
+        verifyNoInteractions(this.velocityEngine);
     }
 }",
"url": "https://github.com/xwiki/xwiki-platform/commit/a4ad14d9c1605a5ab957237e505ebbb29f5b9d73.patch"
},
{
"commit_message": "[PATCH] XWIKI-21337: Apply PDF templates with the rights of their authors .../com/xpn/xwiki/pdf/impl/PdfExportImpl.java | 80 +++++--- .../xpn/xwiki/pdf/impl/PdfExportImplTest.java | 181 +++++++++++++++--- 2 files changed, 206 insertions(+), 55 deletions(-)",
"patch_text_b64": "From d28e21a670c69880b951e415dd2ddd69d273eae9 Mon Sep 17 00:00:00 2001
From: pjeanjean <pierre.jeanjean@xwiki.com>
Date: Thu, 19 Oct 2023 17:35:07 +0200
Subject: [PATCH] XWIKI-21337: Apply PDF templates with the rights of their
 authors

---
 .../com/xpn/xwiki/pdf/impl/PdfExportImpl.java |  80 +++++---
 .../xpn/xwiki/pdf/impl/PdfExportImplTest.java | 181 +++++++++++++++---
 2 files changed, 206 insertions(+), 55 deletions(-)

diff --git a/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java b/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java
index 9f471406bc6..b4d86b793d5 100644
--- a/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java
+++ b/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/pdf/impl/PdfExportImpl.java
@@ -29,6 +29,7 @@
 import java.io.StringWriter;
 import java.lang.reflect.Type;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -37,9 +38,9 @@
 
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang.exception.ExceptionUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.velocity.VelocityContext;
 import org.dom4j.Element;
 import org.dom4j.io.OutputFormat;
@@ -54,8 +55,11 @@
 import org.xwiki.model.reference.DocumentReference;
 import org.xwiki.model.reference.DocumentReferenceResolver;
 import org.xwiki.model.reference.EntityReferenceSerializer;
+import org.xwiki.security.authorization.AuthorExecutor;
+import org.xwiki.security.authorization.AuthorizationManager;
+import org.xwiki.security.authorization.Right;
+import org.xwiki.user.UserReferenceSerializer;
 import org.xwiki.velocity.VelocityManager;
-import org.xwiki.velocity.XWikiVelocityException;
 import org.xwiki.xml.EntityResolver;
 import org.xwiki.xml.XMLReaderFactory;
 import org.xwiki.xml.XMLUtils;
@@ -95,30 +99,37 @@ public class PdfExportImpl implements PdfExport
     private static final Logger LOGGER = LoggerFactory.getLogger(PdfExportImpl.class);
 
     /** Document name resolver. */
-    private static DocumentReferenceResolver<String> referenceResolver =
+    private final DocumentReferenceResolver<String> referenceResolver =
         Utils.getComponent(DocumentReferenceResolver.TYPE_STRING, "currentmixed");
 
     /** Document name serializer. */
-    private static EntityReferenceSerializer<String> referenceSerializer =
+    private final EntityReferenceSerializer<String> referenceSerializer =
         Utils.getComponent(EntityReferenceSerializer.TYPE_STRING);
 
     /** Provides access to document properties. */
-    private static DocumentAccessBridge dab = Utils.getComponent(DocumentAccessBridge.class);
+    private final DocumentAccessBridge dab = Utils.getComponent(DocumentAccessBridge.class);
 
     /** Velocity engine manager, used for interpreting velocity. */
-    private static VelocityManager velocityManager = Utils.getComponent(VelocityManager.class);
+    private final VelocityManager velocityManager = Utils.getComponent(VelocityManager.class);
 
-    private static XMLReaderFactory xmlReaderFactory = Utils.getComponent(XMLReaderFactory.class);
+    private final XMLReaderFactory xmlReaderFactory = Utils.getComponent(XMLReaderFactory.class);
+
+    private final AuthorizationManager authorizationManager = Utils.getComponent(AuthorizationManager.class);
+
+    private final AuthorExecutor authorExecutor = Utils.getComponent(AuthorExecutor.class);
+
+    private final UserReferenceSerializer<DocumentReference> userReferenceSerializer =
+        Utils.getComponent(UserReferenceSerializer.TYPE_DOCUMENT_REFERENCE, "document");
 
     /**
      * Used to get the temporary directory.
      */
-    private Environment environment = Utils.getComponent((Type) Environment.class);
+    private final Environment environment = Utils.getComponent((Type) Environment.class);
 
     /**
      * Used to render XSL-FO to PDF.
      */
-    private XSLFORenderer xslFORenderer = Utils.getComponent(XSLFORenderer.class, "fop");
+    private final XSLFORenderer xslFORenderer = Utils.getComponent(XSLFORenderer.class, "fop");
 
     @Override
     public void exportToPDF(XWikiDocument doc, OutputStream out, XWikiContext context) throws XWikiException
@@ -184,7 +195,7 @@ private String convertToStrictXHtml(String input)
 
         HTMLCleaner cleaner = Utils.getComponent(HTMLCleaner.class);
         HTMLCleanerConfiguration config = cleaner.getDefaultConfiguration();
-        List<HTMLFilter> filters = new ArrayList<HTMLFilter>(config.getFilters());
+        List<HTMLFilter> filters = new ArrayList<>(config.getFilters());
         filters.add(Utils.getComponent(HTMLFilter.class, "uniqueId"));
         config.setFilters(filters);
         String result = HTMLUtils.toString(cleaner.clean(new StringReader(input), config));
@@ -261,7 +272,7 @@ private void renderXSLFO(String xmlfo, OutputStream out, ExportType type, final
         throws XWikiException
     {
         try {
-            this.xslFORenderer.render(new ByteArrayInputStream(xmlfo.getBytes("UTF-8")), out, type.getMimeType());
+            this.xslFORenderer.render(new ByteArrayInputStream(xmlfo.getBytes(StandardCharsets.UTF_8)), out, type.getMimeType());
         } catch (IllegalStateException e) {
             throw createException(e, type, XWikiException.ERROR_XWIKI_APP_SEND_RESPONSE_EXCEPTION);
         } catch (Exception e) {
@@ -338,7 +349,7 @@ String applyCSS(String html, String css, XWikiContext context)
 
             // Dom4J 2.1.1 disables external DTDs by default, so we set our own XMLReader.
             // See https://github.com/dom4j/dom4j/issues/51
-            XMLReader xmlReader = xmlReaderFactory.createXMLReader();
+            XMLReader xmlReader = this.xmlReaderFactory.createXMLReader();
             reader.setXMLReader(xmlReader);
 
             reader.setEntityResolver(new DefaultEntityResolver());
@@ -465,28 +476,47 @@ private String getPDFTemplateProperty(String propertyName, XWikiContext context)
         DocumentReference templateReference;
         DocumentReference classReference;
         if (StringUtils.isNotEmpty(pdftemplate)) {
-            templateReference = referenceResolver.resolve(pdftemplate);
+            templateReference = this.referenceResolver.resolve(pdftemplate);
             classReference = new DocumentReference(templateReference.getWikiReference().getName(), "XWiki", "PDFClass");
         } else {
-            templateReference = dab.getCurrentDocumentReference();
-            String currentWiki = dab.getCurrentDocumentReference().getRoot().getName();
+            templateReference = this.dab.getCurrentDocumentReference();
+            String currentWiki = this.dab.getCurrentDocumentReference().getRoot().getName();
             classReference = new DocumentReference(currentWiki, "XWiki", "PDFClass");
         }
 
-        String result = (String) dab.getProperty(templateReference, classReference, propertyName);
-        if (StringUtils.isBlank(result)) {
+        String templateContent = (String) this.dab.getProperty(templateReference, classReference, propertyName);
+        if (StringUtils.isBlank(templateContent)) {
             return "";
         }
-        String templateName = referenceSerializer.serialize(templateReference);
+
+        String templateName = this.referenceSerializer.serialize(templateReference);
+        DocumentReference templateAuthorReference;
+        String result = templateContent;
         try {
-            StringWriter writer = new StringWriter();
-            VelocityContext vcontext = velocityManager.getVelocityContext();
-            velocityManager.getVelocityEngine().evaluate(vcontext, writer, templateName, result);
-            result = writer.toString();
-        } catch (XWikiVelocityException e) {
-            LOGGER.warn("Error applying Velocity to the [{}] property of the [{}] document. Using the property's value "
-                + "without applying Velocity.", propertyName, templateName, ExceptionUtils.getRootCauseMessage(e));
+             templateAuthorReference = this.userReferenceSerializer.serialize(
+                 this.dab.getDocumentInstance(templateReference).getAuthors().getEffectiveMetadataAuthor());
+        } catch (Exception e) {
+            LOGGER.warn("Error fetching the author of template [{}] during PDF conversion. Using the [{}] property of "
+                + "the document's value without applying Velocity.", templateName, propertyName);
+            return result;
         }
+
+        if (this.authorizationManager.hasAccess(Right.SCRIPT, templateAuthorReference, templateReference)) {
+            try {
+                result = this.authorExecutor.call(() -> {
+                    StringWriter writer = new StringWriter();
+                    VelocityContext vcontext = this.velocityManager.getVelocityContext();
+                    this.velocityManager.getVelocityEngine().evaluate(vcontext, writer, templateName,
+                        templateContent);
+                    return writer.toString();
+                }, templateAuthorReference, templateReference);
+            } catch (Exception e) {
+                LOGGER.warn("Failed to run Velocity engine in author executor. Using the [{}] property of the [{}] "
+                    + "document's value without applying Velocity. Reason: [{}]",
+                    propertyName, templateName, ExceptionUtils.getRootCauseMessage(e));
+            }
+        }
+
         return result;
     }
 
diff --git a/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java b/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java
index 7532ee3167a..b273f854461 100644
--- a/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java
+++ b/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/pdf/impl/PdfExportImplTest.java
@@ -19,23 +19,55 @@
  */
 package com.xpn.xwiki.pdf.impl;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.StringReader;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.w3c.dom.Document;
 import org.xwiki.bridge.DocumentAccessBridge;
 import org.xwiki.environment.Environment;
-import org.xwiki.model.reference.DocumentReferenceResolver;
-import org.xwiki.model.reference.EntityReferenceSerializer;
+import org.xwiki.job.event.status.JobProgressManager;
+import org.xwiki.model.reference.DocumentReference;
+import org.xwiki.observation.ObservationManager;
+import org.xwiki.security.authorization.AuthorExecutor;
+import org.xwiki.security.authorization.AuthorizationManager;
+import org.xwiki.security.authorization.Right;
+import org.xwiki.template.TemplateManager;
 import org.xwiki.test.annotation.ComponentList;
+import org.xwiki.test.junit5.mockito.MockComponent;
+import org.xwiki.user.UserReference;
+import org.xwiki.user.UserReferenceResolver;
+import org.xwiki.velocity.VelocityEngine;
 import org.xwiki.velocity.VelocityManager;
+import org.xwiki.xml.EntityResolver;
+import org.xwiki.xml.html.HTMLCleaner;
+import org.xwiki.xml.html.HTMLCleanerConfiguration;
+import org.xwiki.xml.html.filter.HTMLFilter;
+import org.xwiki.xml.internal.XMLReaderFactoryComponent;
+import org.xwiki.xml.internal.html.DefaultHTMLCleanerConfiguration;
 
 import com.xpn.xwiki.XWikiContext;
 import com.xpn.xwiki.doc.XWikiDocument;
 import com.xpn.xwiki.internal.pdf.XSLFORenderer;
+import com.xpn.xwiki.pdf.api.PdfExport;
 import com.xpn.xwiki.test.MockitoOldcore;
 import com.xpn.xwiki.test.junit5.mockito.InjectMockitoOldcore;
 import com.xpn.xwiki.test.junit5.mockito.OldcoreTest;
+import com.xpn.xwiki.test.reference.ReferenceComponentList;
+import com.xpn.xwiki.web.XWikiServletRequestStub;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
 /**
@@ -44,40 +76,59 @@
  * @version $Id$
  */
 @ComponentList({
-    org.xwiki.xml.internal.XMLReaderFactoryComponent.class,
+    XMLReaderFactoryComponent.class,
 })
+@ReferenceComponentList
 @OldcoreTest
-public class PdfExportImplTest
+class PdfExportImplTest
 {
+    private static final DocumentReference AUTHOR_REFERENCE = new DocumentReference("xwiki", "XWiki", "XWikiAdmin");
+
+    private static final DocumentReference DOCUMENT_REFERENCE = new DocumentReference("xwiki", "XWiki", "PDFClass");
+
     @InjectMockitoOldcore
     private MockitoOldcore oldcore;
 
-    /**
-     * Verify that PDF Export can apply some CSS on the XHTML when that XHTML already has some style defined and in
-     * shorthand notation.
-     */
-    @Test
-    public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exception
+    @Mock
+    private VelocityEngine velocityEngine;
+
+    @MockComponent
+    private AuthorizationManager authorizationManager;
+
+    @MockComponent
+    private HTMLCleaner htmlCleaner;
+
+    @MockComponent
+    private AuthorExecutor authorExecutor;
+
+    private String htmlContent;
+
+    private String cssProperties;
+
+    private XWikiContext context;
+
+    private PdfExportImpl pdfExport;
+
+    @BeforeEach
+    void setUp() throws Exception
     {
-        this.oldcore.getMocker().registerMockComponent(DocumentReferenceResolver.TYPE_STRING, "currentmixed");
-        this.oldcore.getMocker().registerMockComponent(EntityReferenceSerializer.TYPE_STRING);
-        this.oldcore.getMocker().registerMockComponent(DocumentAccessBridge.class);
-        this.oldcore.getMocker().registerMockComponent(DocumentAccessBridge.class);
         this.oldcore.getMocker().registerMockComponent(PDFResourceResolver.class);
         this.oldcore.getMocker().registerMockComponent(Environment.class);
-        this.oldcore.getMocker().registerMockComponent(VelocityManager.class);
+        this.oldcore.getMocker().registerMockComponent(TemplateManager.class);
+        this.oldcore.getMocker().registerMockComponent(ObservationManager.class);
+        this.oldcore.getMocker().registerMockComponent(JobProgressManager.class);
+        this.oldcore.getMocker().registerMockComponent(EntityResolver.class);
         this.oldcore.getMocker().registerMockComponent(XSLFORenderer.class, "fop");
-
-        PdfExportImpl pdfExport = new PdfExportImpl();
+        this.oldcore.getMocker().registerMockComponent(HTMLFilter.class, "uniqueId");
 
         // The content below allows us to test several points:
         // 1) The SPAN below already has some style defined in shorthand notation( "background" is shorthand,
         //    see https://www.w3schools.com/css/css_background.asp). That's important for the test since that's what was
         //    failing in the past and why this test was written.
         // 2) We also test that HTML entities are correctly kept since we had issues with this at one point.
-        String html = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+        this.htmlContent = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
             + "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" "
-                + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
+            + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
             + "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head>\n"
             + "<title>\n"
             + "  Main.ttt - ttt\n"
@@ -98,13 +149,51 @@ public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exce
             + "\n"
             + "</body></html>";
 
-        String css = "span { color:red; }";
+        this.cssProperties = "span { color:red; }";
 
-        XWikiContext xcontext = this.oldcore.getXWikiContext();
+        // Set up HTML cleaner.
+        Document htmlDocument = DocumentBuilderFactory.newInstance().newDocumentBuilder()
+            .parse(new ByteArrayInputStream(this.htmlContent.getBytes()));
+        HTMLCleanerConfiguration cleanerConfiguration = new DefaultHTMLCleanerConfiguration();
+        when(this.htmlCleaner.getDefaultConfiguration()).thenReturn(cleanerConfiguration);
+        when(this.htmlCleaner.clean(any(StringReader.class), eq(cleanerConfiguration))).thenReturn(htmlDocument);
+
+        // Get a mocked Velocity Engine.
+        VelocityManager velocityManager = this.oldcore.getMocker().registerMockComponent(VelocityManager.class);
+        when(velocityManager.getVelocityEngine()).thenReturn(this.velocityEngine);
+
+        // Prepare a document reference and author reference for the template.
+        XWikiDocument template = new XWikiDocument(DOCUMENT_REFERENCE);
+        UserReferenceResolver<DocumentReference> userReferenceResolver =
+            this.oldcore.getMocker().getInstance(UserReferenceResolver.TYPE_DOCUMENT_REFERENCE, "document");
+        UserReference userReference = userReferenceResolver.resolve(AUTHOR_REFERENCE);
+        template.getAuthors().setEffectiveMetadataAuthor(userReference);
+
+        // Return a non-empty template property.
+        DocumentAccessBridge dab = this.oldcore.getDocumentAccessBridge();
+        when(dab.getProperty(template.getDocumentReference(), template.getDocumentReference(), "style"))
+            .thenReturn(this.cssProperties);
+        when(dab.getDocumentInstance(DOCUMENT_REFERENCE)).thenReturn(template);
+
+        // Set necessary parameters in the request.
+        this.context = this.oldcore.getXWikiContext();
+        XWikiServletRequestStub request = new XWikiServletRequestStub();
+        request.put("pdftemplate", "XWiki.PDFClass");
+        this.context.setRequest(request);
         XWikiDocument doc = mock(XWikiDocument.class);
-        when(doc.getExternalURL("view", xcontext)).thenReturn("http://localhost:8080/export");
-        xcontext.setDoc(doc);
+        when(doc.getExternalURL("view", this.context)).thenReturn("http://localhost:8080/export");
+        this.context.setDoc(doc);
 
+        this.pdfExport = new PdfExportImpl();
+    }
+
+    /**
+     * Verify that PDF Export can apply some CSS on the XHTML when that XHTML already has some style defined and in
+     * shorthand notation.
+     */
+    @Test
+    void applyCSSWhenExistingStyleDefinedUsingShorthandNotation()
+    {
         // - Verify that element's style attributes are normalized and that the SPAN's color is set to red.
         // - Verify that the accent in the content is still there.
         //   TODO: right now we output the DOM with DOM4J and use the default of converting entities when using the
@@ -113,8 +202,8 @@ public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exce
 
         String expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
             + "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" "
-                + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"
-                + "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head>\n"
+            + "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"
+            + "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head>\n"
             + "<title>\n"
             + "  Main.ttt - ttt\n"
             + "</title>\n"
@@ -124,15 +213,47 @@ public void applyCSSWhenExistingStyleDefinedUsingShorthandNotation() throws Exce
             + "<div id=\"xwikimaincontainer\">\n"
             + "<div id=\"xwikimaincontainerinner\">\n\n"
             + "<div id=\"xwikicontent\">\n"
-                + "      <p><span style=\"color: #f00; background-color: #fff; background-image: none; "
-                + "background-position: 0% 0%; background-size: auto auto; background-origin: padding-box; "
-                + "background-clip: border-box; background-repeat: repeat repeat; "
-                + "background-attachment: scroll; \">Hello Clément</span></p>\n"
+            + "      <p><span style=\"color: #f00; background-color: #fff; background-image: none; "
+            + "background-position: 0% 0%; background-size: auto auto; background-origin: padding-box; "
+            + "background-clip: border-box; background-repeat: repeat repeat; "
+            + "background-attachment: scroll; \">Hello Clément</span></p>\n"
             + "          </div>\n"
             + "</div>\n"
             + "</div>\n\n"
             + "</body></html>";
 
-        assertEquals(expected, pdfExport.applyCSS(html, css, xcontext));
+        assertEquals(expected, this.pdfExport.applyCSS(this.htmlContent, this.cssProperties, this.context));
+    }
+
+    /**
+     * Verify that the Velocity Engine is never accessed if the user does not have script rights.
+     */
+    @Test
+    void applyPDFTemplateWithoutScriptRights() throws Exception
+    {
+        when(this.authorizationManager.hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE)).thenReturn(false);
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        this.pdfExport.exportHtml(this.htmlContent, baos, PdfExport.ExportType.PDF, this.context);
+        verify(this.authorizationManager).hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE);
+        verifyNoInteractions(this.authorExecutor);
+        verifyNoInteractions(this.velocityEngine);
+    }
+
+    /**
+     * Verify that the Velocity Engine is not accessed outside an Author Executor.
+     */
+    @Test
+    void applyPDFTemplateWithAuthorExecutor() throws Exception
+    {
+        when(this.authorizationManager.hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE)).thenReturn(true);
+
+        // Do not call the callable to check that the call to the Velocity engine is inside the author executor.
+        doReturn("").when(this.authorExecutor).call(any(), any(), any());
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        this.pdfExport.exportHtml(this.htmlContent, baos, PdfExport.ExportType.PDF, this.context);
+        verify(this.authorizationManager).hasAccess(Right.SCRIPT, AUTHOR_REFERENCE, DOCUMENT_REFERENCE);
+        verify(this.authorExecutor).call(any(), eq(AUTHOR_REFERENCE), eq(DOCUMENT_REFERENCE));
+        verifyNoInteractions(this.velocityEngine);
     }
 }",
"url": "https://github.com/xwiki/xwiki-platform/commit/d28e21a670c69880b951e415dd2ddd69d273eae9.patch"
}
] | null |
GHSA-hm2w-8xwc-gpv5
| null |
[
{
"commit_message": "[PATCH] Fix invalid free in RAnal.avr libr/anal/p/anal_avr.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSAyNWEzNzAzZWYyZTAxNWJiZTFkMWYxNmY2YjJmNjNiYjEwZGQzNGY0IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBwYW5jYWtlIDxwYW5jYWtlQG5vcGNvZGUub3JnPgpEYXRlOiBXZWQsIDE4IEFwciAyMDE4IDEzOjE2OjA0ICswMjAwClN1YmplY3Q6IFtQQVRDSF0gRml4IGludmFsaWQgZnJlZSBpbiBSQW5hbC5hdnIKCi0tLQogbGlici9hbmFsL3AvYW5hbF9hdnIuYyB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2xpYnIvYW5hbC9wL2FuYWxfYXZyLmMgYi9saWJyL2FuYWwvcC9hbmFsX2F2ci5jCmluZGV4IDRlNjIxNTg1MTNjYWIuLmU3NzE3YmViN2NhMTQgMTAwNjQ0Ci0tLSBhL2xpYnIvYW5hbC9wL2FuYWxfYXZyLmMKKysrIGIvbGlici9hbmFsL3AvYW5hbF9hdnIuYwpAQCAtMTI4Nyw3ICsxMjg3LDcgQEAgSU5TVF9IQU5ETEVSIChzYnJ4KSB7CS8vIFNCUkMgUnIsIGIKIAkJCS8vIFNCUlMgUnIsIGIKIAlpbnQgYiA9IGJ1ZlswXSAmIDB4NzsKIAlpbnQgciA9ICgoYnVmWzBdID4+IDQpICYgMHhmKSB8ICgoYnVmWzFdICYgMHgwMSkgPDwgNCk7Ci0JUkFuYWxPcCBuZXh0X29wOworCVJBbmFsT3AgbmV4dF9vcCA9IHswfTsKIAogCS8vIGNhbGN1bGF0ZSBuZXh0IGluc3RydWN0aW9uIHNpemUgKGNhbGwgcmVjdXJzaXZlbHkgYXZyX29wX2FuYWx5emUpCiAJLy8gYW5kIGZyZWUgbmV4dF9vcCdzIGVzaWwgc3RyaW5nICh3ZSBkb250IG5lZWQgaXQgbm93KQ==",
"url": "https://github.com/radare/radare2/commit/25a3703ef2e015bbe1d1f16f6b2f63bb10dd34f4.patch"
},
{
"commit_message": "[PATCH] Fix oobread in avr libr/anal/p/anal_avr.c | 3 +++ 1 file changed, 3 insertions(+)",
"patch_text_b64": "RnJvbSBiMzU1MzBmYTA2ODFiMjdlYmEwODRkZTU1MjcwMzdlYmZiMzk3NDIyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBwYW5jYWtlIDxwYW5jYWtlQG5vcGNvZGUub3JnPgpEYXRlOiBXZWQsIDE4IEFwciAyMDE4IDEzOjE1OjExICswMjAwClN1YmplY3Q6IFtQQVRDSF0gRml4IG9vYnJlYWQgaW4gYXZyCgotLS0KIGxpYnIvYW5hbC9wL2FuYWxfYXZyLmMgfCAzICsrKwogMSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2xpYnIvYW5hbC9wL2FuYWxfYXZyLmMgYi9saWJyL2FuYWwvcC9hbmFsX2F2ci5jCmluZGV4IDkzNjFiNDA0YTdlMjcuLjRlNjIxNTg1MTNjYWIgMTAwNjQ0Ci0tLSBhL2xpYnIvYW5hbC9wL2FuYWxfYXZyLmMKKysrIGIvbGlici9hbmFsL3AvYW5hbF9hdnIuYwpAQCAtMTUyNiw2ICsxNTI2LDkgQEAgT1BDT0RFX0RFU0Mgb3Bjb2Rlc1tdID0gewogCiBzdGF0aWMgT1BDT0RFX0RFU0MqIGF2cl9vcF9hbmFseXplKFJBbmFsICphbmFsLCBSQW5hbE9wICpvcCwgdXQ2NCBhZGRyLCBjb25zdCB1dDggKmJ1ZiwgaW50IGxlbiwgQ1BVX01PREVMICpjcHUpIHsKIAlPUENPREVfREVTQyAqb3Bjb2RlX2Rlc2M7CisJaWYgKGxlbiA8IDIpIHsKKwkJcmV0dXJuIE5VTEw7CisJfQogCXV0MTYgaW5zID0gKGJ1ZlsxXSA8PCA4KSB8IGJ1ZlswXTsKIAlpbnQgZmFpbDsKIAljaGFyICp0Ow==",
"url": "https://github.com/radare/radare2/commit/b35530fa0681b27eba084de5527037ebfb397422.patch"
}
] | null |
|
GHSA-9r4g-gmfh-6gxg
| null |
[
{
"commit_message": "[PATCH] Fix a reflected cross-site scripting vulnerability CVE-2022-1187 inc/admin.php | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSAyZDhjY2I3YjEyNzQyYmYxNmI1YTYwNjhmOWZkZWVhYzY5YmMxMWIxIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBwN2U0IDw0NDc1MDA4NytwN2U0QHVzZXJzLm5vcmVwbHkuZ2l0aHViLmNvbT4KRGF0ZTogVGh1LCAzMSBNYXIgMjAyMiAxMDoxMDozNyArMDgwMApTdWJqZWN0OiBbUEFUQ0hdIEZpeCBhIHJlZmxlY3RlZCBjcm9zcy1zaXRlIHNjcmlwdGluZyB2dWxuZXJhYmlsaXR5CgpDVkUtMjAyMi0xMTg3Ci0tLQogaW5jL2FkbWluLnBocCB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2luYy9hZG1pbi5waHAgYi9pbmMvYWRtaW4ucGhwCmluZGV4IGM3ODAzNmQuLjQ1YjFiNWYgMTAwNjQ0Ci0tLSBhL2luYy9hZG1pbi5waHAKKysrIGIvaW5jL2FkbWluLnBocApAQCAtMzQ1LDcgKzM0NSw3IEBAIGZ1bmN0aW9uIHJlZnJlc2hfeW91dHViZV9saXZlX3VwY29taW5nX2NhY2hlKCAkYWN0aW9uID0gTlVMTCwgJG5vbmNlID0gTlVMTCApIHsKICAgICB9CiAKICAgICBpZiAoICEgd3BfdmVyaWZ5X25vbmNlKCAkbm9uY2UsICd3cFlUY2FjaGVfbm9uY2UnICkgKSB7Ci0gICAgICAgIGRpZSggJ0ludmFsaWQgbm9uY2UuJyAuIHZhcl9leHBvcnQoICRfUE9TVCwgdHJ1ZSApICk7CisgICAgICAgIGRpZSggJ0ludmFsaWQgbm9uY2UuJyk7CiAgICAgfQogCiAgICAgJHlvdXR1YmVfb3B0aW9ucyA9IGdldF9vcHRpb24oICd5b3V0dWJlX2xpdmVfc2V0dGluZ3MnICk7",
"url": "https://github.com/macbookandrew/wp-youtube-live/commit/2d8ccb7b12742bf16b5a6068f9fdeeac69bc11b1.patch"
}
] | null |
|
CVE-2022-24976
|
Atheme IRC Services before 7.2.12, when used in conjunction with InspIRCd, allows authentication bypass by ending an IRC handshake at a certain point during a challenge-response login sequence.
|
[
{
"commit_message": "[PATCH] saslserv/main: Track EID we're pending login to The existing model does not remember that we've sent a SVSLOGIN for a given SASL session, and simply assumes that if a client is introduced with a SASL session open, that session must have succeeded. The security of this approach requires ircd to implicitly abort SASL sessions on client registration. This also means that if a client successfully authenticates and then does something else its pending login is forgotten about, even though a SVSLOGIN has been sent for it, and the ircd is going to think it's logged in. This change removes the dependency on ircd's state machine by keeping explicit track of the pending login, i.e. the one we've most recently sent a SVSLOGIN for. The next commit will ensure that a client abort (even an implicit one) doesn't blow that information away. include/atheme/sasl.h | 1 + modules/saslserv/main.c | 8 +++++--- 2 files changed, 6 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/atheme/atheme/commit/4e664c75d0b280a052eb8b5e81aa41944e593c52.patch"
}
] |
n/a
|
|
CVE-2014-125106
|
Nanopb before 0.3.1 allows size_t overflows in pb_dec_bytes and pb_dec_string.
|
[
{
"commit_message": "[PATCH] Protect against size_t overflows in pb_dec_bytes/pb_dec_string. Possible consequences of bug: 1) Denial of service by causing a crash Possible when all of the following apply: - Untrusted data is passed to pb_decode() - The top-level message contains a static string field as the first field. Causes a single write of '0' byte to 1 byte before the message struct. 2) Remote code execution Possible when all of the following apply: - 64-bit platform - The message or a submessage contains a static/pointer string field. - Decoding directly from a custom pb_istream_t - bytes_left on the stream is set to larger than 4 GB Causes a write of up to 4 GB of data past the string field. 3) Possible heap corruption or remote code execution Possible when all of the following apply: - less than 64-bit platform - The message or a submessage contains a pointer-type bytes field. Causes a write of sizeof(pb_size_t) bytes of data past a 0-byte long malloc()ed buffer. On many malloc() implementations, this causes at most a crash. However, remote code execution through a controlled jump cannot be ruled out. -- Detailed analysis follows In the following consideration, I define \"platform bitness\" as equal to number of bits in size_t datatype. Therefore most 8-bit platforms are regarded as 16-bit for the purposes of this discussion. 1. The overflow in pb_dec_string The overflow happens in this computation: uint32_t size; size_t alloc_size; alloc_size = size + 1; There are two ways in which the overflow can occur: In the uint32_t addition, or in the cast to size_t. This depends on the platform bitness. On 32- and 64-bit platforms, the size has to be UINT32_MAX for the overflow to occur. In that case alloc_size will be 0. On 16-bit platforms, overflow will happen whenever size is more than UINT16_MAX, and resulting alloc_size is attacker controlled. For static fields, the alloc_size value is just checked against the field data size. For pointer fields, the alloc_size value is passed to malloc(). End result in both cases is the same, the storage is 0 or just a few bytes in length. On 16-bit platforms, another overflow occurs in the call to pb_read(), when passing the original size. An attacker will want the passed value to be larger than the alloc_size, therefore the only reasonable choice is to have size = UINT16_MAX and alloc_size = 0. Any larger multiple will truncate to the same values. At this point we have read atleast the tag and the string length of the message, i.e. atleast 3 bytes. The maximum initial value for stream bytes_left is SIZE_MAX, thus at this point at most SIZE_MAX-3 bytes are remaining. On 32-bit and 16-bit platforms this means that the size passed to pb_read() is always larger than the number of remaining bytes. This causes pb_read() to fail immediately, before reading any bytes. On 64-bit platforms, it is possible for the bytes_left value to be set to a value larger than UINT32_MAX, which is the wraparound point in size calculation. In this case pb_read() will succeed and write up to 4 GB of attacker controlled data over the RAM that comes after the string field. On all platforms, there is an unconditional write of a terminating null byte. Because the size of size_t typically reflects the size of the processor address space, a write at UINT16_MAX or UINT32_MAX bytes after the string field actually wraps back to before the string field. Consequently, on 32-bit and 16-bit platforms, the bug causes a single write of '0' byte at one byte before the string field. If the string field is in the middle of a message, this will just corrupt other data in the message struct. Because the message contents is attacker controlled anyway, this is a non-issue. However, if the string field is the first field in the top-level message, it can corrupt other data on the stack/heap before it. Typically a single '0' write at a location not controlled by attacker is enough only for a denial-of-service attack. When using pointer fields and malloc(), the attacker controlled alloc_size will cause a 0-size allocation to happen. By the same logic as before, on 32-bit and 16-bit platforms this causes a '0' byte write only. On 64-bit platforms, however, it will again allow up to 4 GB of malicious data to be written over memory, if the stream length allows the read. 2. The overflow in pb_dec_bytes This overflow happens in the PB_BYTES_ARRAY_T_ALLOCSIZE macro: The computation is done in size_t data type this time. This means that an overflow is possible only when n is larger than SIZE_MAX - offsetof(..). The offsetof value in this case is equal to sizeof(pb_size_t) bytes. Because the incoming size value is limited to 32 bits, no overflow can happen here on 64-bit platforms. The size will be passed to pb_read(). Like before, on 32-bit and 16-bit platforms the read will always fail before writing anything. This leaves only the write of bdest->size as exploitable. On statically allocated fields, the size field will always be allocated, regardless of alloc_size. In this case, no buffer overflow is possible here, but user code could possibly use the attacker controlled size value and read past a buffer. If the field is allocated through malloc(), this will allow a write of sizeof(pb_size_t) attacker controlled bytes to past a 0-byte long buffer. In typical malloc implementations, this will either fit in unused alignment padding area, or cause a heap corruption and a crash. Under very exceptional situation it could allow attacker to influence the behaviour of malloc(), possibly jumping into an attacker-controlled location and thus leading to remote code execution. pb_decode.c | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-)",
"patch_text_b64": "From d2099cc8f1adb33d427a44a5e32ed27b647c7168 Mon Sep 17 00:00:00 2001
From: Petteri Aimonen <jpa@git.mail.kapsi.fi>
Date: Mon, 8 Sep 2014 17:34:16 +0300
Subject: [PATCH] Protect against size_t overflows in
 pb_dec_bytes/pb_dec_string.

Possible consequences of bug:
1) Denial of service by causing a crash
   Possible when all of the following apply:
      - Untrusted data is passed to pb_decode()
      - The top-level message contains a static string field as the first field.
   Causes a single write of '0' byte to 1 byte before the message struct.

2) Remote code execution
   Possible when all of the following apply:
      - 64-bit platform
      - The message or a submessage contains a static/pointer string field.
      - Decoding directly from a custom pb_istream_t
      - bytes_left on the stream is set to larger than 4 GB
   Causes a write of up to 4 GB of data past the string field.

3) Possible heap corruption or remote code execution
   Possible when all of the following apply:
      - less than 64-bit platform
      - The message or a submessage contains a pointer-type bytes field.
   Causes a write of sizeof(pb_size_t) bytes of data past a 0-byte long
   malloc()ed buffer. On many malloc() implementations, this causes at
   most a crash. However, remote code execution through a controlled jump
   cannot be ruled out.

--

Detailed analysis follows

In the following consideration, I define "platform bitness" as equal to
number of bits in size_t datatype. Therefore most 8-bit platforms are
regarded as 16-bit for the purposes of this discussion.

1. The overflow in pb_dec_string

The overflow happens in this computation:

uint32_t size;
size_t alloc_size;
alloc_size = size + 1;

There are two ways in which the overflow can occur: In the uint32_t
addition, or in the cast to size_t. This depends on the platform
bitness.

On 32- and 64-bit platforms, the size has to be UINT32_MAX for the
overflow to occur. In that case alloc_size will be 0.

On 16-bit platforms, overflow will happen whenever size is more than
UINT16_MAX, and resulting alloc_size is attacker controlled.

For static fields, the alloc_size value is just checked against the
field data size. For pointer fields, the alloc_size value is passed to
malloc(). End result in both cases is the same, the storage is 0 or
just a few bytes in length.

On 16-bit platforms, another overflow occurs in the call to pb_read(),
when passing the original size. An attacker will want the passed value
to be larger than the alloc_size, therefore the only reasonable choice
is to have size = UINT16_MAX and alloc_size = 0. Any larger multiple
will truncate to the same values.

At this point we have read atleast the tag and the string length of the
message, i.e. atleast 3 bytes. The maximum initial value for stream
bytes_left is SIZE_MAX, thus at this point at most SIZE_MAX-3 bytes are
remaining.

On 32-bit and 16-bit platforms this means that the size passed to
pb_read() is always larger than the number of remaining bytes. This
causes pb_read() to fail immediately, before reading any bytes.

On 64-bit platforms, it is possible for the bytes_left value to be set
to a value larger than UINT32_MAX, which is the wraparound point in
size calculation. In this case pb_read() will succeed and write up to 4
GB of attacker controlled data over the RAM that comes after the string
field.

On all platforms, there is an unconditional write of a terminating null
byte. Because the size of size_t typically reflects the size of the
processor address space, a write at UINT16_MAX or UINT32_MAX bytes
after the string field actually wraps back to before the string field.
Consequently, on 32-bit and 16-bit platforms, the bug causes a single
write of '0' byte at one byte before the string field.

If the string field is in the middle of a message, this will just
corrupt other data in the message struct. Because the message contents
is attacker controlled anyway, this is a non-issue. However, if the
string field is the first field in the top-level message, it can
corrupt other data on the stack/heap before it. Typically a single '0'
write at a location not controlled by attacker is enough only for a
denial-of-service attack.

When using pointer fields and malloc(), the attacker controlled
alloc_size will cause a 0-size allocation to happen. By the same logic
as before, on 32-bit and 16-bit platforms this causes a '0' byte write
only. On 64-bit platforms, however, it will again allow up to 4 GB of
malicious data to be written over memory, if the stream length allows
the read.

2. The overflow in pb_dec_bytes

This overflow happens in the PB_BYTES_ARRAY_T_ALLOCSIZE macro:

The computation is done in size_t data type this time. This means that
an overflow is possible only when n is larger than SIZE_MAX -
offsetof(..). The offsetof value in this case is equal to
sizeof(pb_size_t) bytes.

Because the incoming size value is limited to 32 bits, no overflow can
happen here on 64-bit platforms.

The size will be passed to pb_read(). Like before, on 32-bit and 16-bit
platforms the read will always fail before writing anything.

This leaves only the write of bdest->size as exploitable. On statically
allocated fields, the size field will always be allocated, regardless
of alloc_size. In this case, no buffer overflow is possible here, but
user code could possibly use the attacker controlled size value and
read past a buffer.

If the field is allocated through malloc(), this will allow a write of
sizeof(pb_size_t) attacker controlled bytes to past a 0-byte long
buffer. In typical malloc implementations, this will either fit in
unused alignment padding area, or cause a heap corruption and a crash.
Under very exceptional situation it could allow attacker to influence
the behaviour of malloc(), possibly jumping into an attacker-controlled
location and thus leading to remote code execution.
---
 pb_decode.c | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/pb_decode.c b/pb_decode.c
index 37f307079..d1efd1b51 100644
--- a/pb_decode.c
+++ b/pb_decode.c
@@ -1072,32 +1072,35 @@ static bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *f
 static bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
     uint32_t size;
+    size_t alloc_size;
     pb_bytes_array_t *bdest;
     
     if (!pb_decode_varint32(stream, &size))
         return false;
     
+    if (size > PB_SIZE_MAX)
+        PB_RETURN_ERROR(stream, "bytes overflow");
+    
+    alloc_size = PB_BYTES_ARRAY_T_ALLOCSIZE(size);
+    if (size > alloc_size)
+        PB_RETURN_ERROR(stream, "size too large");
+    
     if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
     {
 #ifndef PB_ENABLE_MALLOC
         PB_RETURN_ERROR(stream, "no malloc support");
 #else
-        if (!allocate_field(stream, dest, PB_BYTES_ARRAY_T_ALLOCSIZE(size), 1))
+        if (!allocate_field(stream, dest, alloc_size, 1))
             return false;
         bdest = *(pb_bytes_array_t**)dest;
 #endif
     }
     else
     {
-        if (PB_BYTES_ARRAY_T_ALLOCSIZE(size) > field->data_size)
+        if (alloc_size > field->data_size)
             PB_RETURN_ERROR(stream, "bytes overflow");
         bdest = (pb_bytes_array_t*)dest;
     }
-    
-    if (size > PB_SIZE_MAX)
-    {
-        PB_RETURN_ERROR(stream, "bytes overflow");
-    }
 
     bdest->size = (pb_size_t)size;
     return pb_read(stream, bdest->bytes, size);
@@ -1114,6 +1117,9 @@ static bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *fi
     /* Space for null terminator */
     alloc_size = size + 1;
     
+    if (alloc_size < size)
+        PB_RETURN_ERROR(stream, "size too large");
+    
     if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
     {
 #ifndef PB_ENABLE_MALLOC",
"url": "https://github.com/nanopb/nanopb/commit/d2099cc8f1adb33d427a44a5e32ed27b647c7168.patch"
}
] |
n/a
|
|
GHSA-76p3-8jx3-jpfq
|
Prototype pollution in webpack loader-utils
| null |
[
{
"commit_message": "[PATCH] fix: security problem (#220) lib/parseQuery.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA0NTA0ZTM0YzQ3OTZhNTgzNmVmNzA0NTgzMjczNTE2NzVhZWQ0OGE1IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbGV4YW5kZXIgQWthaXQgPDQ1Njc5MzQrYWxleGFuZGVyLWFrYWl0QHVzZXJzLm5vcmVwbHkuZ2l0aHViLmNvbT4KRGF0ZTogTW9uLCA3IE5vdiAyMDIyIDIzOjM5OjQ4ICswMzAwClN1YmplY3Q6IFtQQVRDSF0gZml4OiBzZWN1cml0eSBwcm9ibGVtICgjMjIwKQoKLS0tCiBsaWIvcGFyc2VRdWVyeS5qcyB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2xpYi9wYXJzZVF1ZXJ5LmpzIGIvbGliL3BhcnNlUXVlcnkuanMKaW5kZXggMTJiM2VmYy4uM2RkN2NiOSAxMDA2NDQKLS0tIGEvbGliL3BhcnNlUXVlcnkuanMKKysrIGIvbGliL3BhcnNlUXVlcnkuanMKQEAgLTI2LDcgKzI2LDcgQEAgZnVuY3Rpb24gcGFyc2VRdWVyeShxdWVyeSkgewogICB9CiAKICAgY29uc3QgcXVlcnlBcmdzID0gcXVlcnkuc3BsaXQoL1ssJl0vZyk7Ci0gIGNvbnN0IHJlc3VsdCA9IHt9OworICBjb25zdCByZXN1bHQgPSBPYmplY3QuY3JlYXRlKG51bGwpOwogCiAgIHF1ZXJ5QXJncy5mb3JFYWNoKChhcmcpID0+IHsKICAgICBjb25zdCBpZHggPSBhcmcuaW5kZXhPZignPScpOw==",
"url": "https://github.com/webpack/loader-utils/commit/4504e34c4796a5836ef70458327351675aed48a5.patch"
},
{
"commit_message": "[PATCH] fix(security): prototype polution exploit (#217) lib/parseQuery.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSBhOTNjZjZmNDcwMjAxMjAzMGY2YjVlZTgzNDBkNWM5NWVjMWM3ZDRjIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWtlIENlYnJpYW4gPG1pY2hhZWwuY2VicmlhbkBnbWFpbC5jb20+CkRhdGU6IFRodSwgMjAgT2N0IDIwMjIgMTU6NTQ6MzMgLTA0MDAKU3ViamVjdDogW1BBVENIXSBmaXgoc2VjdXJpdHkpOiBwcm90b3R5cGUgcG9sdXRpb24gZXhwbG9pdCAoIzIxNykKCi0tLQogbGliL3BhcnNlUXVlcnkuanMgfCAyICstCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9saWIvcGFyc2VRdWVyeS5qcyBiL2xpYi9wYXJzZVF1ZXJ5LmpzCmluZGV4IGZkY2EwMDcuLjRhMjAxYTIgMTAwNjQ0Ci0tLSBhL2xpYi9wYXJzZVF1ZXJ5LmpzCisrKyBiL2xpYi9wYXJzZVF1ZXJ5LmpzCkBAIC0yNiw3ICsyNiw3IEBAIGZ1bmN0aW9uIHBhcnNlUXVlcnkocXVlcnkpIHsKICAgfQogCiAgIGNvbnN0IHF1ZXJ5QXJncyA9IHF1ZXJ5LnNwbGl0KC9bLCZdL2cpOwotICBjb25zdCByZXN1bHQgPSB7fTsKKyAgY29uc3QgcmVzdWx0ID0gT2JqZWN0LmNyZWF0ZShudWxsKTsKIAogICBxdWVyeUFyZ3MuZm9yRWFjaCgoYXJnKSA9PiB7CiAgICAgY29uc3QgaWR4ID0gYXJnLmluZGV4T2YoJz0nKTs=",
"url": "https://github.com/webpack/loader-utils/commit/a93cf6f4702012030f6b5ee8340d5c95ec1c7d4c.patch"
},
{
"commit_message": "[PATCH] fix: Resolve potential prototype polution exploit lib/parseQuery.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSBmNGU0OGEyMzJmYWU5MDAyMzdjM2U1ZmY3YjU3Y2U5ZTFjNzM0ZGUxIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWNoYWVsIENlYnJpYW4gPG1pY2hhZWwuY2VicmlhbkBnbWFpbC5jb20+CkRhdGU6IFRodSwgMjAgT2N0IDIwMjIgMTU6NDA6MjUgLTA0MDAKU3ViamVjdDogW1BBVENIXSBmaXg6IFJlc29sdmUgcG90ZW50aWFsIHByb3RvdHlwZSBwb2x1dGlvbiBleHBsb2l0CgotLS0KIGxpYi9wYXJzZVF1ZXJ5LmpzIHwgMiArLQogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvbGliL3BhcnNlUXVlcnkuanMgYi9saWIvcGFyc2VRdWVyeS5qcwppbmRleCBmZGNhMDA3Li40YTIwMWEyIDEwMDY0NAotLS0gYS9saWIvcGFyc2VRdWVyeS5qcworKysgYi9saWIvcGFyc2VRdWVyeS5qcwpAQCAtMjYsNyArMjYsNyBAQCBmdW5jdGlvbiBwYXJzZVF1ZXJ5KHF1ZXJ5KSB7CiAgIH0KIAogICBjb25zdCBxdWVyeUFyZ3MgPSBxdWVyeS5zcGxpdCgvWywmXS9nKTsKLSAgY29uc3QgcmVzdWx0ID0ge307CisgIGNvbnN0IHJlc3VsdCA9IE9iamVjdC5jcmVhdGUobnVsbCk7CiAKICAgcXVlcnlBcmdzLmZvckVhY2goKGFyZykgPT4gewogICAgIGNvbnN0IGlkeCA9IGFyZy5pbmRleE9mKCc9Jyk7",
"url": "https://github.com/webpack/loader-utils/commit/f4e48a232fae900237c3e5ff7b57ce9e1c734de1.patch"
}
] | null |
GHSA-g44v-6qfm-f6ch
|
Answer has Guessable CAPTCHA
| null |
[
{
"commit_message": "[PATCH] update VerifyCaptcha internal/repo/captcha/captcha.go | 8 ++++++++ internal/service/action/captcha_service.go | 7 +++++++ 2 files changed, 15 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/answerdev/answer/commit/813ad0b9894673b1bdd489a2e9ab60a44fe990af.patch"
}
] | null |
CVE-2020-36628
|
Calsign APDE ZIP File CopyBuildTask.java handleExtract path traversal
|
A vulnerability classified as critical has been found in Calsign APDE. This affects the function handleExtract of the file APDE/src/main/java/com/calsignlabs/apde/build/dag/CopyBuildTask.java of the component ZIP File Handler. The manipulation leads to path traversal. Upgrading to version 0.5.2-pre2-alpha is able to address this issue. It is recommended to upgrade the affected component. The associated identifier of this vulnerability is VDB-216747.
|
[
{
"commit_message": "[PATCH] fix zip path traversal vulnerability .../java/com/calsignlabs/apde/build/dag/CopyBuildTask.java | 4 ++++ build.gradle | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/Calsign/APDE/commit/c6d64cbe465348c1bfd211122d89e3117afadecf.patch"
}
] |
CWE-22 Path Traversal
|
CVE-2020-36278
|
Leptonica before 1.80.0 allows a heap-based buffer over-read in findNextBorderPixel in ccbord.c.
|
[
{
"commit_message": "[PATCH] Issue 23433 in oss-fuzz: Heap-buffer-overflow in findNextBorderPixel() * Check pix boundary when looking for the next pixel. src/ccbord.c | 2 ++ 1 file changed, 2 insertions(+)",
"patch_text_b64": "RnJvbSA4ZDZlMTc1NTUxOGNmYjk4NTM2ZDZjM2RhZjA2MDFmMjI2ZDE2ODQyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEYW4gQmxvb21iZXJnIDxkYW4uYmxvb21iZXJnQGdtYWlsLmNvbT4KRGF0ZTogU3VuLCAxNCBKdW4gMjAyMCAyMjo1Mjo0MCAtMDcwMApTdWJqZWN0OiBbUEFUQ0hdIElzc3VlIDIzNDMzIGluIG9zcy1mdXp6OiBIZWFwLWJ1ZmZlci1vdmVyZmxvdyBpbgogZmluZE5leHRCb3JkZXJQaXhlbCgpICogQ2hlY2sgcGl4IGJvdW5kYXJ5IHdoZW4gbG9va2luZyBmb3IgdGhlIG5leHQgcGl4ZWwuCgotLS0KIHNyYy9jY2JvcmQuYyB8IDIgKysKIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9zcmMvY2Nib3JkLmMgYi9zcmMvY2Nib3JkLmMKaW5kZXggYzYyMzcwMjUxLi40ZTYzNjNlMjAgMTAwNjQ0Ci0tLSBhL3NyYy9jY2JvcmQuYworKysgYi9zcmMvY2Nib3JkLmMKQEAgLTEwODAsNiArMTA4MCw4IEBAIGxfdWludDMyICAqbGluZTsKICAgICAgICAgcG9zID0gKHFwb3MgKyBpKSAlIDg7CiAgICAgICAgIG5weCA9IHB4ICsgeHBvc3RhYltwb3NdOwogICAgICAgICBucHkgPSBweSArIHlwb3N0YWJbcG9zXTsKKyAgICAgICAgaWYgKG5weCA8IDAgfHwgbnB4ID49IHcgfHwgbnB5IDwgMCB8fCBucHkgPj0gaCkKKyAgICAgICAgICAgIGNvbnRpbnVlOwogICAgICAgICBsaW5lID0gZGF0YSArIG5weSAqIHdwbDsKICAgICAgICAgdmFsID0gR0VUX0RBVEFfQklUKGxpbmUsIG5weCk7CiAgICAgICAgIGlmICh2YWwpIHs=",
"url": "https://github.com/DanBloomberg/leptonica/commit/8d6e1755518cfb98536d6c3daf0601f226d16842.patch"
}
] |
n/a
|
|
GHSA-pw34-qf6c-84fc
|
phpMyAdmin XSS Vulnerability
| null |
[
{
"commit_message": "[PATCH] Fix XSS in DB_search.php Signed-off-by: Madhura Jayaratne <[email protected]> libraries/DbSearch.class.php | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA3NWE1NTgyNDAxMjQwNmEwOGM0ZGViZjVkZGI3YWU0MWMzMmE3ZGJjIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYWRodXJhIEpheWFyYXRuZSA8bWFkaHVyYS5jakBnbWFpbC5jb20+CkRhdGU6IFR1ZSwgMTkgSmFuIDIwMTYgMTA6MTI6MzIgKzExMDAKU3ViamVjdDogW1BBVENIXSBGaXggWFNTIGluIERCX3NlYXJjaC5waHAKClNpZ25lZC1vZmYtYnk6IE1hZGh1cmEgSmF5YXJhdG5lIDxtYWRodXJhLmNqQGdtYWlsLmNvbT4KLS0tCiBsaWJyYXJpZXMvRGJTZWFyY2guY2xhc3MucGhwIHwgMyArKy0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9saWJyYXJpZXMvRGJTZWFyY2guY2xhc3MucGhwIGIvbGlicmFyaWVzL0RiU2VhcmNoLmNsYXNzLnBocAppbmRleCBiY2UxMDJmOTBkNDUuLmM3OWJlYWRkZjJjZiAxMDA2NDQKLS0tIGEvbGlicmFyaWVzL0RiU2VhcmNoLmNsYXNzLnBocAorKysgYi9saWJyYXJpZXMvRGJTZWFyY2guY2xhc3MucGhwCkBAIC0zNDQsNyArMzQ0LDggQEAgcHJpdmF0ZSBmdW5jdGlvbiBfZ2V0UmVzdWx0c1JvdygkZWFjaF90YWJsZSwgJG5ld3NlYXJjaHNxbHMsICRvZGRfcm93LCAkcmVzX2NudCkKICAgICAgICAgICAgICRicm93c2VfcmVzdWx0X3BhdGggPSAnc3FsLnBocCcgLiBQTUFfVVJMX2dldENvbW1vbigkdGhpc191cmxfcGFyYW1zKTsKICAgICAgICAgICAgICRodG1sX291dHB1dCAuPSAnPHRkPjxhIG5hbWU9ImJyb3dzZV9zZWFyY2giIGNsYXNzPSJhamF4IiBocmVmPSInCiAgICAgICAgICAgICAgICAgLiAkYnJvd3NlX3Jlc3VsdF9wYXRoIC4gJyIgb25jbGljaz0ibG9hZFJlc3VsdChcJycKLSAgICAgICAgICAgICAgICAuICRicm93c2VfcmVzdWx0X3BhdGggLiAnXCcsXCcnIC4gJGVhY2hfdGFibGUgLiAnXCcsXCcnCisgICAgICAgICAgICAgICAgLiAkYnJvd3NlX3Jlc3VsdF9wYXRoIC4gJ1wnLFwnJworICAgICAgICAgICAgICAgIC4gUE1BX2VzY2FwZUpzU3RyaW5nKGh0bWxzcGVjaWFsY2hhcnMoJGVhY2hfdGFibGUpKSAuICdcJyxcJycKICAgICAgICAgICAgICAgICAuIFBNQV9VUkxfZ2V0Q29tbW9uKAogICAgICAgICAgICAgICAgICAgICBhcnJheSgKICAgICAgICAgICAgICAgICAgICAgICAgICdkYicgPT4gJEdMT0JBTFNbJ2RiJ10sICd0YWJsZScgPT4gJGVhY2hfdGFibGU=",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/75a55824012406a08c4debf5ddb7ae41c32a7dbc.patch"
},
{
"commit_message": "[PATCH] Escape javascript variable content MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Michal Čihař <[email protected]> templates/header_location.phtml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSBhY2E0MmVmYTAxOTE3Y2MwZmU4Y2ZkYjI5MjdhNjM5OWNhMTc0MmYyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/TWljaGFsPTIwPUM0PThDaWhhPUM1PTk5Pz0gPG1pY2hhbEBjaWhhci5jb20+CkRhdGU6IE1vbiwgMjUgSmFuIDIwMTYgMTI6MjE6NDggKzAxMDAKU3ViamVjdDogW1BBVENIXSBFc2NhcGUgamF2YXNjcmlwdCB2YXJpYWJsZSBjb250ZW50Ck1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CgpTaWduZWQtb2ZmLWJ5OiBNaWNoYWwgxIxpaGHFmSA8bWljaGFsQGNpaGFyLmNvbT4KLS0tCiB0ZW1wbGF0ZXMvaGVhZGVyX2xvY2F0aW9uLnBodG1sIHwgNCArKy0tCiAxIGZpbGUgY2hhbmdlZCwgMiBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3RlbXBsYXRlcy9oZWFkZXJfbG9jYXRpb24ucGh0bWwgYi90ZW1wbGF0ZXMvaGVhZGVyX2xvY2F0aW9uLnBodG1sCmluZGV4IDZlODI0NjU2OWQ5OS4uZTFkYWJkZmE1NjViIDEwMDY0NAotLS0gYS90ZW1wbGF0ZXMvaGVhZGVyX2xvY2F0aW9uLnBodG1sCisrKyBiL3RlbXBsYXRlcy9oZWFkZXJfbG9jYXRpb24ucGh0bWwKQEAgLTI1LDggKzI1LDggQEAgJHVyaSA9IGlzc2V0KCR1cmkpID8gJHVyaSA6IG51bGw7CiA8Ym9keT4KIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KICAgICAvLzwhW0NEQVRBWwotICAgIGRvY3VtZW50LndyaXRlKCc8cD48YSBocmVmPSI8P3BocCBlY2hvIGh0bWxzcGVjaWFsY2hhcnMoJHVyaSkgPz4iPjw/cGhwIGVjaG8gX18oJ0dvJykgPz48L2E+PC9wPicpOworICAgIGRvY3VtZW50LndyaXRlKCc8cD48YSBocmVmPSI8P3BocCBlY2hvIFBNQV9lc2NhcGVKc1N0cmluZyhodG1sc3BlY2lhbGNoYXJzKCR1cmkpKSA/PiI+PD9waHAgZWNobyBfXygnR28nKSA/PjwvYT48L3A+Jyk7CiAgICAgLy9dXT4KIDwvc2NyaXB0PgogPC9ib2R5PgotPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKKzwvaHRtbD4=",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/aca42efa01917cc0fe8cfdb2927a6399ca1742f2.patch"
},
{
"commit_message": "[PATCH] Fix XSS in zoom search Signed-off-by: Madhura Jayaratne <[email protected]> templates/table/search/rows_zoom.phtml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSBlZGZmYjUyODg0YjA5NTYyNDkwMDgxYzNiODY2NmVmNDZjMjk2NDE4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYWRodXJhIEpheWFyYXRuZSA8bWFkaHVyYS5jakBnbWFpbC5jb20+CkRhdGU6IE1vbiwgMTggSmFuIDIwMTYgMTU6Mzk6NTcgKzExMDAKU3ViamVjdDogW1BBVENIXSBGaXggWFNTIGluIHpvb20gc2VhcmNoCgpTaWduZWQtb2ZmLWJ5OiBNYWRodXJhIEpheWFyYXRuZSA8bWFkaHVyYS5jakBnbWFpbC5jb20+Ci0tLQogdGVtcGxhdGVzL3RhYmxlL3NlYXJjaC9yb3dzX3pvb20ucGh0bWwgfCA0ICsrLS0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvdGVtcGxhdGVzL3RhYmxlL3NlYXJjaC9yb3dzX3pvb20ucGh0bWwgYi90ZW1wbGF0ZXMvdGFibGUvc2VhcmNoL3Jvd3Nfem9vbS5waHRtbAppbmRleCAwNjU1MGNmNGU4MjMuLjE5NjRlZWZiZDA1ZiAxMDA2NDQKLS0tIGEvdGVtcGxhdGVzL3RhYmxlL3NlYXJjaC9yb3dzX3pvb20ucGh0bWwKKysrIGIvdGVtcGxhdGVzL3RhYmxlL3NlYXJjaC9yb3dzX3pvb20ucGh0bWwKQEAgLTU2LDcgKzU2LDcgQEAgZm9yICgkaSA9IDA7ICRpIDwgNDsgJGkrKyk6ID8+CiAgICAgICAgIH0gPz4KICAgICAgICAgPCEtLSBDb2x1bW4gdHlwZSAtLT4KICAgICAgICAgPHRkIGRpcj0ibHRyIj4KLSAgICAgICAgICAgIDw/cGhwIGVjaG8gKGlzc2V0KCR0eXBlWyRpXSkgPyAkdHlwZVskaV0gOiAnJyk7ID8+CisgICAgICAgICAgICA8P3BocCBlY2hvIChpc3NldCgkdHlwZVskaV0pID8gaHRtbHNwZWNpYWxjaGFycygkdHlwZVskaV0pIDogJycpOyA/PgogICAgICAgICA8L3RkPgogICAgICAgICA8IS0tIENvbHVtbiBDb2xsYXRpb24gLS0+CiAgICAgICAgIDx0ZD4KQEAgLTY4LDcgKzY4LDcgQEAgZm9yICgkaSA9IDA7ICRpIDwgNDsgJGkrKyk6ID8+CiAgICAgICAgIDwvdGQ+CiAgICAgICAgIDwhLS0gSW5wdXRib3ggZm9yIHNlYXJjaCBjcml0ZXJpYSB2YWx1ZSAtLT4KICAgICAgICAgPHRkPgotICAgICAgICAgICAgPD9waHAgZWNobyAoaXNzZXQoJHZhbHVlWyRpXSkgPyAkdmFsdWVbJGldIDogJycpOyA/PgorICAgICAgICAgICAgPD9waHAgZWNobyAoaXNzZXQoJHZhbHVlWyRpXSkgPyBodG1sc3BlY2lhbGNoYXJzKCR2YWx1ZVskaV0pIDogJycpOyA/PgogICAgICAgICA8L3RkPgogICAgIDwvdHI+CiAgICAgPCEtLSBEaXNwbGF5cyBoaWRkZW4gZmllbGRzIC0tPg==",
"url": "https://github.com/phpmyadmin/phpmyadmin/commit/edffb52884b09562490081c3b8666ef46c296418.patch"
}
] | null |
GHSA-g4fr-ffvg-p5w6
| null |
[
{
"commit_message": "[PATCH] Fix a bug in number_format() Summary: In case of error while calling snprintf, return empty string instead of malformed string. Reviewed By: binliu19 Differential Revision: D13379372 fbshipit-source-id: 1e5611598464daccc674d5a96558c9f2aee08fc8 hphp/runtime/base/zend-string.cpp | 2 ++ hphp/test/slow/string/number_format_error.php | 19 +++++++++++++++++++ .../string/number_format_error.php.expect | 2 ++ 3 files changed, 23 insertions(+) create mode 100644 hphp/test/slow/string/number_format_error.php create mode 100644 hphp/test/slow/string/number_format_error.php.expect",
"patch_text_b64": "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",
"url": "https://github.com/facebook/hhvm/commit/190ffdf6c8b1ec443be202c7d69e63a7e3da25e3.patch"
}
] | null |
|
CVE-2022-31192
|
Cross Site Scripting possible in DSpace JSPUI "Request a Copy" feature
|
DSpace open source software is a repository application which provides durable access to digital resources. dspace-jspui is a UI component for DSpace. The JSPUI "Request a Copy" feature does not properly escape values submitted and stored from the "Request a Copy" form. This means that item requests could be vulnerable to XSS attacks. This vulnerability only impacts the JSPUI. Users are advised to upgrade. There are no known workarounds for this vulnerability.
|
[
{
"commit_message": "[PATCH] [DS-4133] Improve URL handling in Controlled Vocab JSPUI servlet .../webui/servlet/ControlledVocabularyServlet.java | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/DSpace/DSpace/commit/f7758457b7ec3489d525e39aa753cc70809d9ad9.patch"
},
{
"commit_message": "[PATCH] [DS-4383] Request Item Servlet escape HTML .../dspace/app/webui/servlet/RequestItemServlet.java | 11 ++++++----- .../org/dspace/app/webui/util/RequestItemManager.java | 4 ++-- 2 files changed, 8 insertions(+), 7 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/DSpace/DSpace/commit/28eb8158210d41168a62ed5f9e044f754513bc37.patch"
}
] |
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
CVE-2024-39305
|
Envoy Proxy use after free when route hash policy is configured with cookie attributes
|
Envoy is a cloud-native, open source edge and service proxy. Prior to versions 1.30.4, 1.29.7, 1.28.5, and 1.27.7. Envoy references already freed memory when route hash policy is configured with cookie attributes. Note that this vulnerability has been fixed in the open as the effect would be immediately apparent if it was configured. Memory allocated for holding attribute values is freed after configuration was parsed. During request processing Envoy will attempt to copy content of de-allocated memory into request cookie header. This can lead to arbitrary content of Envoy's memory to be sent to the upstream service or abnormal process termination. This vulnerability is fixed in Envoy versions v1.30.4, v1.29.7, v1.28.5, and v1.27.7. As a workaround, do not use cookie attributes in route action hash policy.
|
[
{
"commit_message": "[PATCH] http: fix cookie attributes (#34885) Signed-off-by: Rama Chavali <[email protected]> changelogs/current.yaml | 4 ++ source/common/http/hash_policy.cc | 14 +++++-- .../multiplexed_integration_test.cc | 39 +++++++++++++++++++ 3 files changed, 54 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/envoyproxy/envoy/commit/02a06681fbe0e039b1c7a9215257a7537eddb518.patch"
},
{
"commit_message": "[PATCH] http: fix cookie attributes (#34885) Signed-off-by: Rama Chavali <[email protected]> changelogs/current.yaml | 4 ++ source/common/http/hash_policy.cc | 14 +++++-- .../multiplexed_integration_test.cc | 39 +++++++++++++++++++ 3 files changed, 54 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/envoyproxy/envoy/commit/50b384cb203a1f2894324cbae64b6d9bc44cce45.patch"
},
{
"commit_message": "[PATCH] http: fix cookie attributes (#34885) Signed-off-by: Rama Chavali <[email protected]> changelogs/current.yaml | 4 ++ source/common/http/hash_policy.cc | 14 +++++-- .../multiplexed_integration_test.cc | 39 +++++++++++++++++++ 3 files changed, 54 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/envoyproxy/envoy/commit/99b6e525fb9f6f6f19a0425f779bc776f121c7e5.patch"
},
{
"commit_message": "[PATCH] http: fix cookie attributes (#34885) Signed-off-by: Rama Chavali <[email protected]> changelogs/current.yaml | 4 ++ source/common/http/hash_policy.cc | 14 +++++-- .../multiplexed_integration_test.cc | 39 +++++++++++++++++++ 3 files changed, 54 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/envoyproxy/envoy/commit/b7f509607ad860fd6a63cde4f7d6f0197f9f63bb.patch"
}
] |
CWE-416: Use After Free
|
CVE-2023-41049
|
Improper Neutralization of Script in Attributes in @dcl/single-sign-on-client
|
@dcl/single-sign-on-client is an open source npm library which deals with single sign on authentication flows. Improper input validation in the `init` function allows arbitrary javascript to be executed using the `javascript:` prefix. This vulnerability has been patched on version `0.1.0`. Users are advised to upgrade. Users unable to upgrade should limit untrusted user input to the `init` function.
|
[
{
"commit_message": "[PATCH] feat: verify url package-lock.json | 18 +++++++++++++++++- packages/lib/package.json | 4 +++- packages/lib/src/SingleSignOn.shared.ts | 2 +- packages/lib/src/SingleSignOn.ts | 14 ++++++++++++-- 4 files changed, 33 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/decentraland/single-sign-on-client/commit/bd20ea9533d0cda30809d929db85b1b76cef855a.patch"
}
] |
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
CVE-2024-34080
|
MantisBT Vulnerable to Exposure of Sensitive Information to an Unauthorized Actor
|
MantisBT (Mantis Bug Tracker) is an open source issue tracker. If an issue references a note that belongs to another issue that the user doesn't have access to, then it gets hyperlinked. Clicking on the link gives an access denied error as expected, yet some information remains available via the link, link label, and tooltip. This can result in disclosure of the existence of the note, the note author name, the note creation timestamp, and the issue id the note belongs to. Version 2.26.2 contains a patch for the issue. No known workarounds are available.
|
[
{
"commit_message": "[PATCH] Fix access level check for note links Fixes #34434 core/string_api.php | 42 +++++++++++++++++++++++++----------------- 1 file changed, 25 insertions(+), 17 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/mantisbt/mantisbt/commit/0a50562369d823689c9b946066d1e49d3c2df226.patch"
}
] |
CWE-200: Exposure of Sensitive Information to an Unauthorized Actor
|
GHSA-jwrv-x6rx-8vfm
|
Macaron i18n Open Redirect vulnerability
| null |
[
{
"commit_message": "<[email protected]> [PATCH] security: fix Open Redirection vulnerability .gitignore | 1 + go.mod | 3 +- go.sum | 13 +++- i18n.go | 18 +++-- i18n_test.go | 208 +++++++++++++++++++++++++++++---------------------- 5 files changed, 141 insertions(+), 102 deletions(-) create mode 100644 .gitignore",
"patch_text_b64": "From 329b0c4844cc16a5a253c011b55180598e707735 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E1=B4=9C=C9=B4=E1=B4=8B=C9=B4=E1=B4=A1=E1=B4=8F=C9=B4?=
 <u@gogs.io>
Date: Mon, 17 Feb 2020 00:13:52 +0800
Subject: [PATCH] security: fix Open Redirection vulnerability

---
 .gitignore   |   1 +
 go.mod       |   3 +-
 go.sum       |  13 +++-
 i18n.go      |  18 +++--
 i18n_test.go | 208 +++++++++++++++++++++++++++++----------------------
 5 files changed, 141 insertions(+), 102 deletions(-)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a09c56d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/.idea
diff --git a/go.mod b/go.mod
index c0e4f8f..e958e8d 100644
--- a/go.mod
+++ b/go.mod
@@ -3,8 +3,7 @@ module github.com/go-macaron/i18n
 go 1.12
 
 require (
-	github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337
-	github.com/unknwon/com v0.0.0-20190804042917-757f69c95f3e
+	github.com/stretchr/testify v1.4.0
 	github.com/unknwon/i18n v0.0.0-20190805065654-5c6446a380b6
 	golang.org/x/text v0.3.2
 	gopkg.in/macaron.v1 v1.3.4
diff --git a/go.sum b/go.sum
index 8447b40..1d9a316 100644
--- a/go.sum
+++ b/go.sum
@@ -1,21 +1,26 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/go-macaron/inject v0.0.0-20160627170012-d8a0b8677191 h1:NjHlg70DuOkcAMqgt0+XA+NHwtu66MkTVVgR4fFWbcI=
 github.com/go-macaron/inject v0.0.0-20160627170012-d8a0b8677191/go.mod h1:VFI2o2q9kYsC4o7VP1HrEVosiZZTd+MVT3YZx4gqvJw=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
-github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e h1:JKmoR8x90Iww1ks85zJ1lfDGgIiMDuIptTOhJq+zKyg=
 github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gopherjs/gopherjs v0.0.0-20190430165422-3e4dfb77656c h1:7lF+Vz0LqiRidnzC1Oq86fpX1q/iEv2KJdrCtttYjT4=
 github.com/gopherjs/gopherjs v0.0.0-20190430165422-3e4dfb77656c/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
-github.com/smartystreets/assertions v0.0.0-20190116191733-b6c0e53d7304 h1:Jpy1PXuP99tXNrhbq2BaPz9B+jNAvH1JPQQpG/9GCXY=
 github.com/smartystreets/assertions v0.0.0-20190116191733-b6c0e53d7304/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/assertions v1.0.1 h1:voD4ITNjPL5jjBfgR/r8fPIIBrliWrWHeiJApdr3r4w=
 github.com/smartystreets/assertions v1.0.1/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM=
 github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
 github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337 h1:WN9BUFbdyOsSH/XohnWpXOlq9NBD5sGAB2FciQMUEe8=
 github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/unknwon/com v0.0.0-20190804042917-757f69c95f3e h1:GSGeB9EAKY2spCABz6xOX5DbxZEXolK+nBSvmsQwRjM=
 github.com/unknwon/com v0.0.0-20190804042917-757f69c95f3e/go.mod h1:tOOxU81rwgoCLoOVVPHb6T/wt8HZygqH5id+GNnlCXM=
 github.com/unknwon/i18n v0.0.0-20190805065654-5c6446a380b6 h1:sRrkJEHtNoaSvyXMbRgofEOX4/3gMiraevQKJdIBhYE=
@@ -37,7 +42,11 @@ golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190802220118-1d1727260058/go.mod h1:jcCCGcm9btYwXyDqrUWc6MKQKKGJCWEQ3AfLSRIbEuI=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/ini.v1 v1.46.0 h1:VeDZbLYGaupuvIrsYCEOe/L/2Pcs5n7hdO1ZTjporag=
 gopkg.in/ini.v1 v1.46.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/macaron.v1 v1.3.4 h1:HvIscOwxhFhx3swWM/979wh2QMYyuXrNmrF9l+j3HZs=
 gopkg.in/macaron.v1 v1.3.4/go.mod h1:/RoHTdC8ALpyJ3+QR36mKjwnT1F1dyYtsGM9Ate6ZFI=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/i18n.go b/i18n.go
index 33cc0ef..a6daed6 100644
--- a/i18n.go
+++ b/i18n.go
@@ -17,19 +17,23 @@ package i18n
 
 import (
 	"fmt"
+	"os"
 	"path"
 	"strings"
 
-	"github.com/unknwon/com"
 	"github.com/unknwon/i18n"
 	"golang.org/x/text/language"
 	"gopkg.in/macaron.v1"
 )
 
-const _VERSION = "0.4.1"
-
-func Version() string {
-	return _VERSION
+// isFile returns true if given path is a file,
+// or returns false when it's a directory or does not exist.
+func isFile(filePath string) bool {
+	f, e := os.Stat(filePath)
+	if e != nil {
+		return false
+	}
+	return !f.IsDir()
 }
 
 // initLocales initializes language type list and Accept-Language header matcher.
@@ -41,7 +45,7 @@ func initLocales(opt Options) language.Matcher {
 		// Append custom locale file.
 		custom := []interface{}{}
 		customPath := path.Join(opt.CustomDirectory, fname)
-		if com.IsFile(customPath) {
+		if isFile(customPath) {
 			custom = append(custom, customPath)
 		}
 
@@ -221,7 +225,7 @@ func I18n(options ...Options) macaron.Handler {
 		ctx.Data["RestLangs"] = restLangs
 
 		if opt.Redirect && isNeedRedir {
-			ctx.Redirect(opt.SubURL + ctx.Req.RequestURI[:strings.Index(ctx.Req.RequestURI, "?")])
+			ctx.Redirect(opt.SubURL + path.Clean(ctx.Req.RequestURI[:strings.Index(ctx.Req.RequestURI, "?")]))
 		}
 	}
 }
diff --git a/i18n_test.go b/i18n_test.go
index eb1d5dd..33f8325 100644
--- a/i18n_test.go
+++ b/i18n_test.go
@@ -15,118 +15,144 @@
 package i18n
 
 import (
+	"errors"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 
-	. "github.com/smartystreets/goconvey/convey"
+	"github.com/stretchr/testify/assert"
 	"gopkg.in/macaron.v1"
 )
 
-func Test_Version(t *testing.T) {
-	Convey("Check package version", t, func() {
-		So(Version(), ShouldEqual, _VERSION)
-	})
-}
-
-func Test_I18n(t *testing.T) {
-	Convey("Use i18n middleware", t, func() {
-		Convey("No langauge", func() {
-			defer func() {
-				So(recover(), ShouldNotBeNil)
-			}()
+func TestI18n(t *testing.T) {
+	t.Run("no language", func(t *testing.T) {
+		defer func() {
+			assert.Equal(t, "no language is specified", recover())
+		}()
 
-			m := macaron.New()
-			m.Use(I18n(Options{}))
-		})
+		m := macaron.New()
+		m.Use(I18n(Options{}))
+	})
 
-		Convey("Languages and names not match", func() {
-			defer func() {
-				So(recover(), ShouldNotBeNil)
-			}()
+	t.Run("languages and names not match", func(t *testing.T) {
+		defer func() {
+			assert.Equal(t, "length of langs is not same as length of names", recover())
+		}()
 
-			m := macaron.New()
-			m.Use(I18n(Options{
-				Langs: []string{"en-US"},
-			}))
-		})
+		m := macaron.New()
+		m.Use(I18n(Options{
+			Langs: []string{"en-US"},
+		}))
+	})
 
-		Convey("Invalid directory", func() {
-			defer func() {
-				So(recover(), ShouldNotBeNil)
-			}()
-
-			m := macaron.New()
-			m.Use(I18n(Options{
-				Directory: "404",
-				Langs:     []string{"en-US"},
-				Names:     []string{"English"},
-			}))
-		})
+	t.Run("invalid directory", func(t *testing.T) {
+		defer func() {
+			assert.Equal(t, errors.New("fail to set message file(en-US): open 404/locale_en-US.ini: no such file or directory"), recover())
+		}()
+
+		m := macaron.New()
+		m.Use(I18n(Options{
+			Directory: "404",
+			Langs:     []string{"en-US"},
+			Names:     []string{"English"},
+		}))
+	})
 
-		Convey("With correct options", func() {
-			m := macaron.New()
-			m.Use(I18n(Options{
-				Files: map[string][]byte{"locale_en-US.ini": []byte("")},
-				Langs: []string{"en-US"},
-				Names: []string{"English"},
-			}))
-			m.Get("/", func() {})
+	t.Run("with correct options", func(t *testing.T) {
+		m := macaron.New()
+		m.Use(I18n(Options{
+			Files: map[string][]byte{"locale_en-US.ini": []byte("")},
+			Langs: []string{"en-US"},
+			Names: []string{"English"},
+		}))
+		m.Get("/", func() {})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		m.ServeHTTP(resp, req)
+	})
 
-			resp := httptest.NewRecorder()
-			req, err := http.NewRequest("GET", "/", nil)
-			So(err, ShouldBeNil)
-			m.ServeHTTP(resp, req)
+	t.Run("set by Accept-Language", func(t *testing.T) {
+		m := macaron.New()
+		m.Use(I18n(Options{
+			Langs: []string{"en-US", "zh-CN", "it-IT"},
+			Names: []string{"English", "简体中文", "Italiano"},
+		}))
+		m.Get("/", func(l Locale) {
+			assert.Equal(t, "it-IT", l.Language())
 		})
 
-		Convey("Set by redirect of URL parameter", func() {
-			m := macaron.New()
-			m.Use(I18n(Options{
-				Langs:    []string{"en-US"},
-				Names:    []string{"English"},
-				Redirect: true,
-			}))
-			m.Get("/", func() {})
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		req.Header.Set("Accept-Language", "it")
+		m.ServeHTTP(resp, req)
+	})
 
-			resp := httptest.NewRecorder()
-			req, err := http.NewRequest("GET", "/?lang=en-US", nil)
-			So(err, ShouldBeNil)
-			req.RequestURI = "/?lang=en-US"
-			m.ServeHTTP(resp, req)
+	t.Run("set to default language", func(t *testing.T) {
+		m := macaron.New()
+		m.Use(I18n(Options{
+			Langs: []string{"en-US", "zh-CN", "it-IT"},
+			Names: []string{"English", "简体中文", "Italiano"},
+		}))
+		m.Get("/", func(l Locale) {
+			assert.Equal(t, "en-US", l.Language())
 		})
 
-		Convey("Set by Accept-Language", func() {
-			m := macaron.New()
-			m.Use(I18n(Options{
-				Langs: []string{"en-US", "zh-CN", "it-IT"},
-				Names: []string{"English", "简体中文", "Italiano"},
-			}))
-			m.Get("/", func(l Locale) {
-				So(l.Language(), ShouldEqual, "it-IT")
-			})
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		req.Header.Set("Accept-Language", "ru")
+		m.ServeHTTP(resp, req)
+	})
+}
 
+func TestRedirect(t *testing.T) {
+	m := macaron.New()
+	m.Use(I18n(Options{
+		Langs:    []string{"en-US"},
+		Names:    []string{"English"},
+		Redirect: true,
+	}))
+	m.Get("/", func() {})
+
+	tests := []struct {
+		url    string
+		expURL string
+	}{
+		{
+			url:    "/?lang=en-US",
+			expURL: "/",
+		}, {
+			url:    "//example.com?lang=en-US",
+			expURL: "/example.com",
+		}, {
+			url:    "/abc/../../../example.com?lang=en-US",
+			expURL: "/example.com",
+		}, {
+			url:    "/../abc/../example.com?lang=en-US",
+			expURL: "/example.com",
+		},
+	}
+	for _, test := range tests {
+		t.Run("", func(t *testing.T) {
 			resp := httptest.NewRecorder()
-			req, err := http.NewRequest("GET", "/", nil)
-			So(err, ShouldBeNil)
-			req.Header.Set("Accept-Language", "it")
+			req, err := http.NewRequest("GET", test.url, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			req.RequestURI = test.url
 			m.ServeHTTP(resp, req)
-		})
-
-		Convey("Set to default language", func() {
-			m := macaron.New()
-			m.Use(I18n(Options{
-				Langs: []string{"en-US", "zh-CN", "it-IT"},
-				Names: []string{"English", "简体中文", "Italiano"},
-			}))
-			m.Get("/", func(l Locale) {
-				So(l.Language(), ShouldEqual, "en-US")
-			})
 
-			resp := httptest.NewRecorder()
-			req, err := http.NewRequest("GET", "/", nil)
-			So(err, ShouldBeNil)
-			req.Header.Set("Accept-Language", "ru")
-			m.ServeHTTP(resp, req)
+			assert.Equal(t, http.StatusFound, resp.Code)
+			assert.Equal(t, "<a href=\""+test.expURL+"\">Found</a>.\n\n", resp.Body.String())
 		})
-	})
+	}
 }",
"url": "https://github.com/go-macaron/i18n/commit/329b0c4844cc16a5a253c011b55180598e707735.patch"
}
] | null |
CVE-2020-36315
|
In RELIC before 2020-08-01, RSA PKCS#1 v1.5 signature forgery can occur because certain checks of the padding (and of the first two bytes) are inadequate. NOTE: this requires that a low public exponent (such as 3) is being used. The product, by default, does not generate RSA keys with such a low number.
|
[
{
"commit_message": "[PATCH] Fix #154 and #155 by inverting the padding check logic and being more rigorous. src/cp/relic_cp_rsa.c | 234 +++++++++++++++++++++--------------------- 1 file changed, 117 insertions(+), 117 deletions(-)",
"patch_text_b64": "From 76c9a1fdf19d9e92e566a77376673e522aae9f80 Mon Sep 17 00:00:00 2001
From: "Diego F. Aranha" <dfaranha@gmail.com>
Date: Sun, 2 Aug 2020 01:53:19 +0200
Subject: [PATCH] Fix #154 and #155 by inverting the padding check logic and
 being more rigorous.

---
 src/cp/relic_cp_rsa.c | 234 +++++++++++++++++++++---------------------
 1 file changed, 117 insertions(+), 117 deletions(-)

diff --git a/src/cp/relic_cp_rsa.c b/src/cp/relic_cp_rsa.c
index 9cb4850b2..c36364cd5 100644
--- a/src/cp/relic_cp_rsa.c
+++ b/src/cp/relic_cp_rsa.c
@@ -129,7 +129,7 @@
  */
 static int pad_basic(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 	uint8_t pad = 0;
-	int result = RLC_OK;
+	int result = RLC_ERR;
 	bn_t t;
 
 	RLC_TRY {
@@ -146,6 +146,7 @@ static int pad_basic(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_add_dig(m, m, RSA_PAD);
 				/* Make room for the real message. */
 				bn_lsh(m, m, m_len * 8);
+				result = RLC_OK;
 				break;
 			case RSA_DEC:
 			case RSA_VER:
@@ -153,20 +154,19 @@ static int pad_basic(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				/* EB = 00 | FF | D. */
 				m_len = k_len - 1;
 				bn_rsh(t, m, 8 * m_len);
-				if (!bn_is_zero(t)) {
-					result = RLC_ERR;
-				}
-				*p_len = 1;
-				do {
-					(*p_len)++;
-					m_len--;
-					bn_rsh(t, m, 8 * m_len);
-					pad = (uint8_t)t->dp[0];
-				} while (pad == 0 && m_len > 0);
-				if (pad != RSA_PAD) {
-					result = RLC_ERR;
+				if (bn_is_zero(t)) {
+					*p_len = 1;
+					do {
+						(*p_len)++;
+						m_len--;
+						bn_rsh(t, m, 8 * m_len);
+						pad = (uint8_t)t->dp[0];
+					} while (pad == 0 && m_len > 0);
+					if (pad == RSA_PAD) {
+						result = RLC_OK;
+					}
+					bn_mod_2b(m, m, (k_len - *p_len) * 8);
 				}
-				bn_mod_2b(m, m, (k_len - *p_len) * 8);
 				break;
 		}
 	}
@@ -251,7 +251,7 @@ static uint8_t *hash_id(int md, int *len) {
  */
 static int pad_pkcs1(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 	uint8_t *id, pad = 0;
-	int len, result = RLC_OK;
+	int len, result = RLC_ERR;
 	bn_t t;
 
 	bn_null(t);
@@ -278,29 +278,28 @@ static int pad_pkcs1(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_add_dig(m, m, 0);
 				/* Make room for the real message. */
 				bn_lsh(m, m, m_len * 8);
+				result = RLC_OK;
 				break;
 			case RSA_DEC:
 				m_len = k_len - 1;
 				bn_rsh(t, m, 8 * m_len);
-				if (!bn_is_zero(t)) {
-					result = RLC_ERR;
-				}
-
-				*p_len = m_len;
-				m_len--;
-				bn_rsh(t, m, 8 * m_len);
-				pad = (uint8_t)t->dp[0];
-				if (pad != RSA_PUB) {
-					result = RLC_ERR;
-				}
-				do {
+				if (bn_is_zero(t)) {
+					*p_len = m_len;
 					m_len--;
 					bn_rsh(t, m, 8 * m_len);
 					pad = (uint8_t)t->dp[0];
-				} while (pad != 0 && m_len > 0);
-				/* Remove padding and trailing zero. */
-				*p_len -= (m_len - 1);
-				bn_mod_2b(m, m, (k_len - *p_len) * 8);
+					if (pad == RSA_PUB) {
+						do {
+							m_len--;
+							bn_rsh(t, m, 8 * m_len);
+							pad = (uint8_t)t->dp[0];
+						} while (pad != 0 && m_len > 0);
+						/* Remove padding and trailing zero. */
+						*p_len -= (m_len - 1);
+						bn_mod_2b(m, m, (k_len - *p_len) * 8);
+						result = (m_len > 0 ? RLC_OK : RLC_ERR);
+					}
+				}
 				break;
 			case RSA_SIG:
 				/* EB = 00 | 01 | PS | 00 | D. */
@@ -321,6 +320,7 @@ static int pad_pkcs1(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_add(m, m, t);
 				/* Make room for the real message. */
 				bn_lsh(m, m, m_len * 8);
+				result = RLC_OK;
 				break;
 			case RSA_SIG_HASH:
 				/* EB = 00 | 01 | PS | 00 | D. */
@@ -337,65 +337,65 @@ static int pad_pkcs1(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_add_dig(m, m, 0);
 				/* Make room for the real message. */
 				bn_lsh(m, m, m_len * 8);
+				result = RLC_OK;
 				break;
 			case RSA_VER:
 				m_len = k_len - 1;
 				bn_rsh(t, m, 8 * m_len);
-				if (!bn_is_zero(t)) {
-					result = RLC_ERR;
-				}
-				m_len--;
-				bn_rsh(t, m, 8 * m_len);
-				pad = (uint8_t)t->dp[0];
-				if (pad != RSA_PRV) {
-					result = RLC_ERR;
-				}
-				do {
+				if (bn_is_zero(t)) {
 					m_len--;
 					bn_rsh(t, m, 8 * m_len);
 					pad = (uint8_t)t->dp[0];
-				} while (pad != 0 && m_len > 0);
-				if (m_len == 0) {
-					result = RLC_ERR;
-				}
-				/* Remove padding and trailing zero. */
-				id = hash_id(MD_MAP, &len);
-				m_len -= len;
-
-				bn_rsh(t, m, m_len * 8);
-				int r = 0;
-				for (int i = 0; i < len; i++) {
-					pad = (uint8_t)t->dp[0];
-					r |= pad - id[len - i - 1];
-					bn_rsh(t, t, 8);
+					if (pad == RSA_PRV) {
+						int counter = 0;
+						do {
+							counter++;
+							m_len--;
+							bn_rsh(t, m, 8 * m_len);
+							pad = (uint8_t)t->dp[0];
+						} while (pad == RSA_PAD && m_len > 0);
+						/* Remove padding and trailing zero. */
+						id = hash_id(MD_MAP, &len);
+						m_len -= len;
+
+						bn_rsh(t, m, m_len * 8);
+						int r = 0;
+						for (int i = 0; i < len; i++) {
+							pad = (uint8_t)t->dp[0];
+							r |= pad ^ id[len - i - 1];
+							bn_rsh(t, t, 8);
+						}
+						*p_len = k_len - m_len;
+						bn_mod_2b(m, m, m_len * 8);
+						if (r && m_len > 0 && counter >= 8) {
+							result = RLC_OK;
+						}
+					}
 				}
-				*p_len = k_len - m_len;
-				bn_mod_2b(m, m, m_len * 8);
-				result = (r == 0 ? RLC_OK : RLC_ERR);
 				break;
 			case RSA_VER_HASH:
 				m_len = k_len - 1;
 				bn_rsh(t, m, 8 * m_len);
-				if (!bn_is_zero(t)) {
-					result = RLC_ERR;
-				}
-				m_len--;
-				bn_rsh(t, m, 8 * m_len);
-				pad = (uint8_t)t->dp[0];
-				if (pad != RSA_PRV) {
-					result = RLC_ERR;
-				}
-				do {
+				if (bn_is_zero(t)) {
 					m_len--;
 					bn_rsh(t, m, 8 * m_len);
 					pad = (uint8_t)t->dp[0];
-				} while (pad != 0 && m_len > 0);
-				if (m_len == 0) {
-					result = RLC_ERR;
+					if (pad == RSA_PRV) {
+						int counter = 0;
+						do {
+							counter++;
+							m_len--;
+							bn_rsh(t, m, 8 * m_len);
+							pad = (uint8_t)t->dp[0];
+						} while (pad == RSA_PAD && m_len > 0);
+						/* Remove padding and trailing zero. */
+						*p_len = k_len - m_len;
+						bn_mod_2b(m, m, m_len * 8);
+						if (m_len > 0 && counter >= 8) {
+							result = RLC_OK;
+						}
+					}
 				}
-				/* Remove padding and trailing zero. */
-				*p_len = k_len - m_len;
-				bn_mod_2b(m, m, m_len * 8);
 				break;
 		}
 	}
@@ -426,7 +426,7 @@ static int pad_pkcs2(bn_t m, int *p_len, int m_len, int k_len, int operation) {
         uint8_t pad, h1[RLC_MD_LEN], h2[RLC_MD_LEN];
         /* MSVC does not allow dynamic stack arrays */
         uint8_t *mask = RLC_ALLOCA(uint8_t, k_len);
-	int result = RLC_OK;
+	int result = RLC_ERR;
 	bn_t t;
 
 	bn_null(t);
@@ -445,6 +445,7 @@ static int pad_pkcs2(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_add_dig(m, m, 0x01);
 				/* Make room for the real message. */
 				bn_lsh(m, m, m_len * 8);
+				result = RLC_OK;
 				break;
 			case RSA_ENC_FIN:
 				/* EB = 00 | maskedSeed | maskedDB. */
@@ -463,47 +464,44 @@ static int pad_pkcs2(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_lsh(t, t, 8 * (k_len - RLC_MD_LEN - 1));
 				bn_add(t, t, m);
 				bn_copy(m, t);
+				result = RLC_OK;
 				break;
 			case RSA_DEC:
 				m_len = k_len - 1;
 				bn_rsh(t, m, 8 * m_len);
-				if (!bn_is_zero(t)) {
-					result = RLC_ERR;
-				}
-				m_len -= RLC_MD_LEN;
-				bn_rsh(t, m, 8 * m_len);
-				bn_write_bin(h1, RLC_MD_LEN, t);
-				bn_mod_2b(m, m, 8 * m_len);
-				bn_write_bin(mask, m_len, m);
-				md_mgf(h2, RLC_MD_LEN, mask, m_len);
-				for (int i = 0; i < RLC_MD_LEN; i++) {
-					h1[i] ^= h2[i];
-				}
-				md_mgf(mask, k_len - RLC_MD_LEN - 1, h1, RLC_MD_LEN);
-				bn_read_bin(t, mask, k_len - RLC_MD_LEN - 1);
-				for (int i = 0; i < t->used; i++) {
-					m->dp[i] ^= t->dp[i];
-				}
-				m_len -= RLC_MD_LEN;
-				bn_rsh(t, m, 8 * m_len);
-				bn_write_bin(h2, RLC_MD_LEN, t);
-				md_map(h1, NULL, 0);
-				pad = 0;
-				for (int i = 0; i < RLC_MD_LEN; i++) {
-					pad |= h1[i] - h2[i];
-				}
-				if (result == RLC_OK) {
-					result = (pad ? RLC_ERR : RLC_OK);
-				}
-				bn_mod_2b(m, m, 8 * m_len);
-				*p_len = bn_size_bin(m);
-				(*p_len)--;
-				bn_rsh(t, m, *p_len * 8);
-				if (bn_cmp_dig(t, 1) != RLC_EQ) {
-					result = RLC_ERR;
+				if (bn_is_zero(t)) {
+					m_len -= RLC_MD_LEN;
+					bn_rsh(t, m, 8 * m_len);
+					bn_write_bin(h1, RLC_MD_LEN, t);
+					bn_mod_2b(m, m, 8 * m_len);
+					bn_write_bin(mask, m_len, m);
+					md_mgf(h2, RLC_MD_LEN, mask, m_len);
+					for (int i = 0; i < RLC_MD_LEN; i++) {
+						h1[i] ^= h2[i];
+					}
+					md_mgf(mask, k_len - RLC_MD_LEN - 1, h1, RLC_MD_LEN);
+					bn_read_bin(t, mask, k_len - RLC_MD_LEN - 1);
+					for (int i = 0; i < t->used; i++) {
+						m->dp[i] ^= t->dp[i];
+					}
+					m_len -= RLC_MD_LEN;
+					bn_rsh(t, m, 8 * m_len);
+					bn_write_bin(h2, RLC_MD_LEN, t);
+					md_map(h1, NULL, 0);
+					pad = 0;
+					for (int i = 0; i < RLC_MD_LEN; i++) {
+						pad |= h1[i] ^ h2[i];
+					}
+					bn_mod_2b(m, m, 8 * m_len);
+					*p_len = bn_size_bin(m);
+					(*p_len)--;
+					bn_rsh(t, m, *p_len * 8);
+					if (pad == 0 && bn_cmp_dig(t, 1) == RLC_EQ) {
+						result = RLC_OK;
+					}
+					bn_mod_2b(m, m, *p_len * 8);
+					*p_len = k_len - *p_len;
 				}
-				bn_mod_2b(m, m, *p_len * 8);
-				*p_len = k_len - *p_len;
 				break;
 			case RSA_SIG:
 			case RSA_SIG_HASH:
@@ -512,6 +510,7 @@ static int pad_pkcs2(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_lsh(m, m, 64);
 				/* Make room for the real message. */
 				bn_lsh(m, m, RLC_MD_LEN * 8);
+				result = RLC_OK;
 				break;
 			case RSA_SIG_FIN:
 				memset(mask, 0, 8);
@@ -529,16 +528,17 @@ static int pad_pkcs2(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				for (int i = m_len - 1; i < 8 * k_len; i++) {
 					bn_set_bit(m, i, 0);
 				}
+				result = RLC_OK;
 				break;
 			case RSA_VER:
 			case RSA_VER_HASH:
 				bn_mod_2b(t, m, 8);
-				if (bn_cmp_dig(t, RSA_PSS) != RLC_EQ) {
-					result = RLC_ERR;
-				} else {
+				pad = (uint8_t)t->dp[0];
+				if (pad == RSA_PSS) {
+					int r = 1;
 					for (int i = m_len; i < 8 * k_len; i++) {
 						if (bn_get_bit(m, i) != 0) {
-							result = RLC_ERR;
+							r = 0;
 						}
 					}
 					bn_rsh(m, m, 8);
@@ -555,8 +555,8 @@ static int pad_pkcs2(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 					for (int i = m_len - 1; i < 8 * k_len; i++) {
 						bn_set_bit(m, i - ((RLC_MD_LEN + 1) * 8), 0);
 					}
-					if (!bn_is_zero(m)) {
-						result = RLC_ERR;
+					if (r == 1 && bn_is_zero(m)) {
+						result = RLC_OK;
 					}
 					bn_read_bin(m, h2, RLC_MD_LEN);
 					*p_len = k_len - RLC_MD_LEN;",
"url": "https://github.com/relic-toolkit/relic/commit/76c9a1fdf19d9e92e566a77376673e522aae9f80.patch"
}
] |
n/a
|
|
GHSA-cwx2-736x-mf6w
|
Prototype pollution in object-path
| null |
[
{
"commit_message": "[PATCH] Fix prototype pollution in set() index.js | 4 + test.js | 1480 ++++++++++++++++++++++++++++-------------------------- 2 files changed, 765 insertions(+), 719 deletions(-)",
"patch_text_b64": "From 2be3354c6c46215c7635eb1b76d80f1319403c68 Mon Sep 17 00:00:00 2001
From: Mario Casciaro <mariocasciaro@gmail.com>
Date: Sat, 10 Oct 2020 17:25:50 +0100
Subject: [PATCH] Fix prototype pollution in set()

---
 index.js |    4 +
 test.js  | 1480 ++++++++++++++++++++++++++++--------------------------
 2 files changed, 765 insertions(+), 719 deletions(-)

diff --git a/index.js b/index.js
index 6eb85eb..2a0af82 100644
--- a/index.js
+++ b/index.js
@@ -112,6 +112,10 @@
       }
       var currentPath = path[0];
       var currentValue = getShallowProperty(obj, currentPath);
+      if (options.includeInheritedProps && (currentPath === '__proto__' ||
+        (currentPath === 'constructor' && typeof currentValue === 'function'))) {
+        throw new Error('For security reasons, object\'s magic properties cannot be set')
+      }
       if (path.length === 1) {
         if (currentValue === void 0 || !doNotReplace) {
           obj[currentPath] = value;
diff --git a/test.js b/test.js
index d3a3f01..c1503cc 100644
--- a/test.js
+++ b/test.js
@@ -1,331 +1,368 @@
-'use strict';
+'use strict'
 var expect = require('chai').expect,
-objectPath = require('./index.js');
+  objectPath = require('./index.js')
 
 
-function getTestObj() {
+function getTestObj () {
   return {
     a: 'b',
     b: {
       c: [],
       d: ['a', 'b'],
-      e: [{},{f: 'g'}],
+      e: [{}, {f: 'g'}],
       f: 'i'
     }
-  };
+  }
 }
 
-describe('get', function() {
-  it('should return the value using unicode key', function() {
+describe('get', function () {
+  it('should return the value using unicode key', function () {
     var obj = {
       '15\u00f8C': {
         '3\u0111': 1
       }
-    };
-    expect(objectPath.get(obj, '15\u00f8C.3\u0111')).to.be.equal(1);
-    expect(objectPath.get(obj, ['15\u00f8C','3\u0111'])).to.be.equal(1);
-  });
+    }
+    expect(objectPath.get(obj, '15\u00f8C.3\u0111')).to.be.equal(1)
+    expect(objectPath.get(obj, ['15\u00f8C', '3\u0111'])).to.be.equal(1)
+  })
 
-  it('should return the value using dot in key', function() {
+  it('should return the value using dot in key', function () {
     var obj = {
       'a.b': {
         'looks.like': 1
       }
-    };
-    expect(objectPath.get(obj, 'a.b.looks.like')).to.be.equal(void 0);
-    expect(objectPath.get(obj, ['a.b','looks.like'])).to.be.equal(1);
-  });
-
-  it('should return the value under shallow object', function() {
-    var obj = getTestObj();
-    expect(objectPath.get(obj, 'a')).to.be.equal('b');
-    expect(objectPath.get(obj, ['a'])).to.be.equal('b');
-  });
-
-  it('should work with number path', function() {
-    var obj = getTestObj();
-    expect(objectPath.get(obj.b.d, 0)).to.be.equal('a');
-    expect(objectPath.get(obj.b, 0)).to.be.equal(void 0);
-  });
-
-  it('should return the value under deep object', function() {
-    var obj = getTestObj();
-    expect(objectPath.get(obj, 'b.f')).to.be.equal('i');
-    expect(objectPath.get(obj, ['b','f'])).to.be.equal('i');
-  });
-
-  it('should return the value under array', function() {
-    var obj = getTestObj();
-    expect(objectPath.get(obj, 'b.d.0')).to.be.equal('a');
-    expect(objectPath.get(obj, ['b','d',0])).to.be.equal('a');
-  });
-
-  it('should return the value under array deep', function() {
-    var obj = getTestObj();
-    expect(objectPath.get(obj, 'b.e.1.f')).to.be.equal('g');
-    expect(objectPath.get(obj, ['b','e',1,'f'])).to.be.equal('g');
-  });
-
-  it('should return undefined for missing values under object', function() {
-    var obj = getTestObj();
-    expect(objectPath.get(obj, 'a.b')).to.not.exist;
-    expect(objectPath.get(obj, ['a','b'])).to.not.exist;
-  });
-
-  it('should return undefined for missing values under array', function() {
-    var obj = getTestObj();
-    expect(objectPath.get(obj, 'b.d.5')).to.not.exist;
-    expect(objectPath.get(obj, ['b','d','5'])).to.not.exist;
-  });
-
-  it('should return the value under integer-like key', function() {
-    var obj = { '1a': 'foo' };
-    expect(objectPath.get(obj, '1a')).to.be.equal('foo');
-    expect(objectPath.get(obj, ['1a'])).to.be.equal('foo');
-  });
-
-  it('should return the default value when the key doesnt exist', function() {
-    var obj = { '1a': 'foo' };
-    expect(objectPath.get(obj, '1b', null)).to.be.equal(null);
-    expect(objectPath.get(obj, ['1b'], null)).to.be.equal(null);
-  });
-
-  it('should return the default value when path is empty', function() {
-    var obj = { '1a': 'foo' };
-    expect(objectPath.get(obj, '', null)).to.be.deep.equal({ '1a': 'foo' });
-    expect(objectPath.get(obj, [])).to.be.deep.equal({ '1a': 'foo' });
-    expect(objectPath.get({  }, ['1'])).to.be.equal(undefined);
-  });
-
-  it('should return the default value when object is null or undefined', function() {
-    expect(objectPath.get(null, 'test', 'a')).to.be.deep.equal('a');
-    expect(objectPath.get(undefined, 'test', 'a')).to.be.deep.equal('a');
-  });
+    }
+    expect(objectPath.get(obj, 'a.b.looks.like')).to.be.equal(void 0)
+    expect(objectPath.get(obj, ['a.b', 'looks.like'])).to.be.equal(1)
+  })
+
+  it('should return the value under shallow object', function () {
+    var obj = getTestObj()
+    expect(objectPath.get(obj, 'a')).to.be.equal('b')
+    expect(objectPath.get(obj, ['a'])).to.be.equal('b')
+  })
+
+  it('should work with number path', function () {
+    var obj = getTestObj()
+    expect(objectPath.get(obj.b.d, 0)).to.be.equal('a')
+    expect(objectPath.get(obj.b, 0)).to.be.equal(void 0)
+  })
+
+  it('should return the value under deep object', function () {
+    var obj = getTestObj()
+    expect(objectPath.get(obj, 'b.f')).to.be.equal('i')
+    expect(objectPath.get(obj, ['b', 'f'])).to.be.equal('i')
+  })
+
+  it('should return the value under array', function () {
+    var obj = getTestObj()
+    expect(objectPath.get(obj, 'b.d.0')).to.be.equal('a')
+    expect(objectPath.get(obj, ['b', 'd', 0])).to.be.equal('a')
+  })
+
+  it('should return the value under array deep', function () {
+    var obj = getTestObj()
+    expect(objectPath.get(obj, 'b.e.1.f')).to.be.equal('g')
+    expect(objectPath.get(obj, ['b', 'e', 1, 'f'])).to.be.equal('g')
+  })
+
+  it('should return undefined for missing values under object', function () {
+    var obj = getTestObj()
+    expect(objectPath.get(obj, 'a.b')).to.not.exist
+    expect(objectPath.get(obj, ['a', 'b'])).to.not.exist
+  })
+
+  it('should return undefined for missing values under array', function () {
+    var obj = getTestObj()
+    expect(objectPath.get(obj, 'b.d.5')).to.not.exist
+    expect(objectPath.get(obj, ['b', 'd', '5'])).to.not.exist
+  })
+
+  it('should return the value under integer-like key', function () {
+    var obj = {'1a': 'foo'}
+    expect(objectPath.get(obj, '1a')).to.be.equal('foo')
+    expect(objectPath.get(obj, ['1a'])).to.be.equal('foo')
+  })
+
+  it('should return the default value when the key doesnt exist', function () {
+    var obj = {'1a': 'foo'}
+    expect(objectPath.get(obj, '1b', null)).to.be.equal(null)
+    expect(objectPath.get(obj, ['1b'], null)).to.be.equal(null)
+  })
+
+  it('should return the default value when path is empty', function () {
+    var obj = {'1a': 'foo'}
+    expect(objectPath.get(obj, '', null)).to.be.deep.equal({'1a': 'foo'})
+    expect(objectPath.get(obj, [])).to.be.deep.equal({'1a': 'foo'})
+    expect(objectPath.get({}, ['1'])).to.be.equal(undefined)
+  })
+
+  it('should return the default value when object is null or undefined', function () {
+    expect(objectPath.get(null, 'test', 'a')).to.be.deep.equal('a')
+    expect(objectPath.get(undefined, 'test', 'a')).to.be.deep.equal('a')
+  })
 
   it(
     'should not fail on an object with a null prototype',
-    function assertSuccessForObjWithNullProto(){
-      var foo = 'FOO';
-      var objWithNullProto = Object.create(null);
-      objWithNullProto.foo = foo;
-      expect(objectPath.get(objWithNullProto, 'foo')).to.equal(foo);
+    function assertSuccessForObjWithNullProto () {
+      var foo = 'FOO'
+      var objWithNullProto = Object.create(null)
+      objWithNullProto.foo = foo
+      expect(objectPath.get(objWithNullProto, 'foo')).to.equal(foo)
     }
-  );
+  )
 
-  it('should skip non own properties', function() {
-    var Base = function(enabled){ };
+  it('should skip non own properties', function () {
+    var Base = function (enabled) {
+    }
     Base.prototype = {
       one: {
         two: true
       }
-    };
-    var Extended = function(){
-      Base.call(this,  true);
-    };
-    Extended.prototype = Object.create(Base.prototype);
+    }
+    var Extended = function () {
+      Base.call(this, true)
+    }
+    Extended.prototype = Object.create(Base.prototype)
 
-    var extended = new Extended();
+    var extended = new Extended()
 
-    expect(objectPath.get(extended, ['one','two'])).to.be.equal(undefined);
-    extended.enabled = true;
+    expect(objectPath.get(extended, ['one', 'two'])).to.be.equal(undefined)
+    extended.enabled = true
 
-    expect(objectPath.get(extended, 'enabled')).to.be.equal(true);
-    expect(objectPath.get(extended, 'one')).to.be.equal(undefined);
-  });
-});
+    expect(objectPath.get(extended, 'enabled')).to.be.equal(true)
+    expect(objectPath.get(extended, 'one')).to.be.equal(undefined)
+  })
+})
 
 
-describe('set', function() {
-  it('should set the value using unicode key', function() {
+describe('set', function () {
+  it('should set the value using unicode key', function () {
     var obj = {
       '15\u00f8C': {
         '3\u0111': 1
       }
-    };
-    objectPath.set(obj, '15\u00f8C.3\u0111', 2);
-    expect(objectPath.get(obj, '15\u00f8C.3\u0111')).to.be.equal(2);
-    objectPath.set(obj, '15\u00f8C.3\u0111', 3);
-    expect(objectPath.get(obj, ['15\u00f8C','3\u0111'])).to.be.equal(3);
-  });
-
-  it('should set the value using dot in key', function() {
+    }
+    objectPath.set(obj, '15\u00f8C.3\u0111', 2)
+    expect(objectPath.get(obj, '15\u00f8C.3\u0111')).to.be.equal(2)
+    objectPath.set(obj, '15\u00f8C.3\u0111', 3)
+    expect(objectPath.get(obj, ['15\u00f8C', '3\u0111'])).to.be.equal(3)
+  })
+
+  it('should set the value using dot in key', function () {
     var obj = {
       'a.b': {
         'looks.like': 1
       }
-    };
-    objectPath.set(obj, ['a.b','looks.like'], 2);
-    expect(objectPath.get(obj, ['a.b','looks.like'])).to.be.equal(2);
-  });
-
-  it('should set value under shallow object', function() {
-    var obj = getTestObj();
-    objectPath.set(obj, 'c', {m: 'o'});
-    expect(obj).to.include.nested.property('c.m', 'o');
-    obj = getTestObj();
-    objectPath.set(obj, ['c'], {m: 'o'});
-    expect(obj).to.include.nested.property('c.m', 'o');
-  });
-
-  it('should set value using number path', function() {
-    var obj = getTestObj();
-    objectPath.set(obj.b.d, 0, 'o');
-    expect(obj).to.have.nested.property('b.d.0', 'o');
-  });
-
-  it('should set value under deep object', function() {
-    var obj = getTestObj();
-    objectPath.set(obj, 'b.c', 'o');
-    expect(obj).to.have.nested.property('b.c', 'o');
-    obj = getTestObj();
-    objectPath.set(obj, ['b','c'], 'o');
-    expect(obj).to.have.nested.property('b.c', 'o');
-  });
-
-  it('should set value under array', function() {
-    var obj = getTestObj();
-    objectPath.set(obj, 'b.e.1.g', 'f');
-    expect(obj).to.have.nested.property('b.e.1.g', 'f');
-    obj = getTestObj();
-    objectPath.set(obj, ['b','e',1,'g'], 'f');
-    expect(obj).to.have.nested.property('b.e.1.g', 'f');
+    }
+    objectPath.set(obj, ['a.b', 'looks.like'], 2)
+    expect(objectPath.get(obj, ['a.b', 'looks.like'])).to.be.equal(2)
+  })
+
+  it('should set value under shallow object', function () {
+    var obj = getTestObj()
+    objectPath.set(obj, 'c', {m: 'o'})
+    expect(obj).to.include.nested.property('c.m', 'o')
+    obj = getTestObj()
+    objectPath.set(obj, ['c'], {m: 'o'})
+    expect(obj).to.include.nested.property('c.m', 'o')
+  })
+
+  it('should set value using number path', function () {
+    var obj = getTestObj()
+    objectPath.set(obj.b.d, 0, 'o')
+    expect(obj).to.have.nested.property('b.d.0', 'o')
+  })
+
+  it('should set value under deep object', function () {
+    var obj = getTestObj()
+    objectPath.set(obj, 'b.c', 'o')
+    expect(obj).to.have.nested.property('b.c', 'o')
+    obj = getTestObj()
+    objectPath.set(obj, ['b', 'c'], 'o')
+    expect(obj).to.have.nested.property('b.c', 'o')
+  })
+
+  it('should set value under array', function () {
+    var obj = getTestObj()
+    objectPath.set(obj, 'b.e.1.g', 'f')
+    expect(obj).to.have.nested.property('b.e.1.g', 'f')
+    obj = getTestObj()
+    objectPath.set(obj, ['b', 'e', 1, 'g'], 'f')
+    expect(obj).to.have.nested.property('b.e.1.g', 'f')
 
     obj = {}
-    objectPath.set(obj, 'b.0', 'a');
-    objectPath.set(obj, 'b.1', 'b');
-    expect(obj.b).to.be.deep.equal(['a', 'b']);
-  });
-
-  it('should create intermediate objects', function() {
-    var obj = getTestObj();
-    objectPath.set(obj, 'c.d.e.f', 'l');
-    expect(obj).to.have.nested.property('c.d.e.f', 'l');
-    obj = getTestObj();
-    objectPath.set(obj, ['c','d','e','f'], 'l');
-    expect(obj).to.have.nested.property('c.d.e.f', 'l');
-  });
-
-  it('should create intermediate arrays', function() {
-    var obj = getTestObj();
-    objectPath.set(obj, 'c.0.1.m', 'l');
-    expect(obj.c).to.be.an('array');
-    expect(obj.c[0]).to.be.an('array');
-    expect(obj).to.have.nested.property('c.0.1.m', 'l');
-    obj = getTestObj();
-    objectPath.set(obj, ['c','0', 1,'m'], 'l');
-    expect(obj.c).to.be.an('object');
-    expect(obj.c[0]).to.be.an('array');
-    expect(obj).to.have.nested.property('c.0.1.m', 'l');
-  });
-
-  it('should set value under integer-like key', function() {
-    var obj = getTestObj();
-    objectPath.set(obj, '1a', 'foo');
-    expect(obj).to.have.nested.property('1a', 'foo');
-    obj = getTestObj();
-    objectPath.set(obj, ['1a'], 'foo');
-    expect(obj).to.have.nested.property('1a', 'foo');
-  });
-
-  it('should set value under empty array', function() {
-    var obj = [];
-    objectPath.set(obj, [0], 'foo');
-    expect(obj[0]).to.be.equal('foo');
-    obj = [];
-    objectPath.set(obj, '0', 'foo');
-    expect(obj[0]).to.be.equal('foo');
-  });
-});
-
-
-describe('push', function() {
-  it('should push value to existing array using unicode key', function() {
-    var obj = getTestObj();
-    objectPath.push(obj, 'b.\u1290c', 'l');
-    expect(obj).to.have.nested.property('b.\u1290c.0', 'l');
-    objectPath.push(obj, ['b','\u1290c'], 'l');
-    expect(obj).to.have.nested.property('b.\u1290c.1', 'l');
-  });
-
-  it('should push value to existing array using dot key', function() {
-    var obj = getTestObj();
-    objectPath.push(obj, ['b','z.d'], 'l');
-    expect(objectPath.get(obj, ['b','z.d', 0])).to.be.equal('l');
-  });
-
-  it('should push value to existing array', function() {
-    var obj = getTestObj();
-    objectPath.push(obj, 'b.c', 'l');
-    expect(obj).to.have.nested.property('b.c.0', 'l');
-    obj = getTestObj();
-    objectPath.push(obj, ['b','c'], 'l');
-    expect(obj).to.have.nested.property('b.c.0', 'l');
-  });
-
-  it('should push value to new array', function() {
-    var obj = getTestObj();
-    objectPath.push(obj, 'b.h', 'l');
-    expect(obj).to.have.nested.property('b.h.0', 'l');
-    obj = getTestObj();
-    objectPath.push(obj, ['b','h'], 'l');
-    expect(obj).to.have.nested.property('b.h.0', 'l');
-  });
-
-  it('should push value to existing array using number path', function() {
-    var obj = getTestObj();
-    objectPath.push(obj.b.e, 0, 'l');
-    expect(obj).to.have.nested.property('b.e.0.0', 'l');
-  });
-
-});
-
-
-describe('ensureExists', function() {
-  it('should create the path if it does not exists', function() {
-    var obj = getTestObj();
-    var oldVal = objectPath.ensureExists(obj, 'b.g.1.l', 'test');
-    expect(oldVal).to.not.exist;
-    expect(obj).to.have.nested.property('b.g.1.l', 'test');
-    oldVal = objectPath.ensureExists(obj, 'b.g.1.l', 'test1');
-    expect(oldVal).to.be.equal('test');
-    expect(obj).to.have.nested.property('b.g.1.l', 'test');
-    oldVal = objectPath.ensureExists(obj, 'b.\u8210', 'ok');
-    expect(oldVal).to.not.exist;
-    expect(obj).to.have.nested.property('b.\u8210', 'ok');
-    oldVal = objectPath.ensureExists(obj, ['b','dot.dot'], 'ok');
-    expect(oldVal).to.not.exist;
-    expect(objectPath.get(obj, ['b','dot.dot'])).to.be.equal('ok');
-  });
-
-
-  it('should return the object if path is empty', function() {
-    var obj = getTestObj();
-    expect(objectPath.ensureExists(obj, [], 'test')).to.have.property('a', 'b');
-  });
-
-  it('Issue #26', function() {
-    var any = {};
-    objectPath.ensureExists(any, ['1','1'], {});
-    expect(any).to.be.an('object');
-    expect(any[1]).to.be.an('object');
-    expect(any[1][1]).to.be.an('object');
-  });
-});
-
-describe('coalesce', function(){
-  it('should return the first non-undefined value', function(){
+    objectPath.set(obj, 'b.0', 'a')
+    objectPath.set(obj, 'b.1', 'b')
+    expect(obj.b).to.be.deep.equal(['a', 'b'])
+  })
+
+  it('should create intermediate objects', function () {
+    var obj = getTestObj()
+    objectPath.set(obj, 'c.d.e.f', 'l')
+    expect(obj).to.have.nested.property('c.d.e.f', 'l')
+    obj = getTestObj()
+    objectPath.set(obj, ['c', 'd', 'e', 'f'], 'l')
+    expect(obj).to.have.nested.property('c.d.e.f', 'l')
+  })
+
+  it('should create intermediate arrays', function () {
+    var obj = getTestObj()
+    objectPath.set(obj, 'c.0.1.m', 'l')
+    expect(obj.c).to.be.an('array')
+    expect(obj.c[0]).to.be.an('array')
+    expect(obj).to.have.nested.property('c.0.1.m', 'l')
+    obj = getTestObj()
+    objectPath.set(obj, ['c', '0', 1, 'm'], 'l')
+    expect(obj.c).to.be.an('object')
+    expect(obj.c[0]).to.be.an('array')
+    expect(obj).to.have.nested.property('c.0.1.m', 'l')
+  })
+
+  it('should set value under integer-like key', function () {
+    var obj = getTestObj()
+    objectPath.set(obj, '1a', 'foo')
+    expect(obj).to.have.nested.property('1a', 'foo')
+    obj = getTestObj()
+    objectPath.set(obj, ['1a'], 'foo')
+    expect(obj).to.have.nested.property('1a', 'foo')
+  })
+
+  it('should set value under empty array', function () {
+    var obj = []
+    objectPath.set(obj, [0], 'foo')
+    expect(obj[0]).to.be.equal('foo')
+    obj = []
+    objectPath.set(obj, '0', 'foo')
+    expect(obj[0]).to.be.equal('foo')
+  })
+
+  it('[security] should not set magic properties in default mode', function () {
+    objectPath.set({}, '__proto__.injected', 'this is bad')
+    expect(Object.prototype.injected).to.be.undefined
+
+    function Clazz() {}
+    Clazz.prototype.test = 'original'
+
+    objectPath.set(new Clazz(), '__proto__.test', 'this is bad')
+    expect(Clazz.prototype.test).to.be.equal('original')
+
+    objectPath.set(new Clazz(), 'constructor.prototype.test', 'this is bad')
+    expect(Clazz.prototype.test).to.be.equal('original')
+  })
+
+  it('[security] should throw an exception if trying to set magic properties in inheritedProps mode', function () {
+    expect(function() {objectPath.withInheritedProps.set({}, '__proto__.injected', 'this is bad')})
+      .to.throw('For security reasons')
+    expect(Object.prototype.injected).to.be.undefined
+
+    function Clazz() {}
+    Clazz.prototype.test = 'original'
+
+    expect(function() {objectPath.withInheritedProps.set(new Clazz(), '__proto__.test', 'this is bad')})
+      .to.throw('For security reasons')
+    expect(Clazz.prototype.test).to.be.equal('original')
+
+    expect(function() {objectPath.withInheritedProps.set(new Clazz(), 'constructor.prototype.test', 'this is bad')})
+      .to.throw('For security reasons')
+    expect(Clazz.prototype.test).to.be.equal('original')
+
+    const obj = {}
+    expect(function() {objectPath.withInheritedProps.set(obj, 'constructor.prototype.injected', 'this is OK')})
+      .to.throw('For security reasons')
+    expect(Object.prototype.injected).to.be.undefined
+  })
+})
+
+
+describe('push', function () {
+  it('should push value to existing array using unicode key', function () {
+    var obj = getTestObj()
+    objectPath.push(obj, 'b.\u1290c', 'l')
+    expect(obj).to.have.nested.property('b.\u1290c.0', 'l')
+    objectPath.push(obj, ['b', '\u1290c'], 'l')
+    expect(obj).to.have.nested.property('b.\u1290c.1', 'l')
+  })
+
+  it('should push value to existing array using dot key', function () {
+    var obj = getTestObj()
+    objectPath.push(obj, ['b', 'z.d'], 'l')
+    expect(objectPath.get(obj, ['b', 'z.d', 0])).to.be.equal('l')
+  })
+
+  it('should push value to existing array', function () {
+    var obj = getTestObj()
+    objectPath.push(obj, 'b.c', 'l')
+    expect(obj).to.have.nested.property('b.c.0', 'l')
+    obj = getTestObj()
+    objectPath.push(obj, ['b', 'c'], 'l')
+    expect(obj).to.have.nested.property('b.c.0', 'l')
+  })
+
+  it('should push value to new array', function () {
+    var obj = getTestObj()
+    objectPath.push(obj, 'b.h', 'l')
+    expect(obj).to.have.nested.property('b.h.0', 'l')
+    obj = getTestObj()
+    objectPath.push(obj, ['b', 'h'], 'l')
+    expect(obj).to.have.nested.property('b.h.0', 'l')
+  })
+
+  it('should push value to existing array using number path', function () {
+    var obj = getTestObj()
+    objectPath.push(obj.b.e, 0, 'l')
+    expect(obj).to.have.nested.property('b.e.0.0', 'l')
+  })
+
+})
+
+
+describe('ensureExists', function () {
+  it('should create the path if it does not exists', function () {
+    var obj = getTestObj()
+    var oldVal = objectPath.ensureExists(obj, 'b.g.1.l', 'test')
+    expect(oldVal).to.not.exist
+    expect(obj).to.have.nested.property('b.g.1.l', 'test')
+    oldVal = objectPath.ensureExists(obj, 'b.g.1.l', 'test1')
+    expect(oldVal).to.be.equal('test')
+    expect(obj).to.have.nested.property('b.g.1.l', 'test')
+    oldVal = objectPath.ensureExists(obj, 'b.\u8210', 'ok')
+    expect(oldVal).to.not.exist
+    expect(obj).to.have.nested.property('b.\u8210', 'ok')
+    oldVal = objectPath.ensureExists(obj, ['b', 'dot.dot'], 'ok')
+    expect(oldVal).to.not.exist
+    expect(objectPath.get(obj, ['b', 'dot.dot'])).to.be.equal('ok')
+  })
+
+
+  it('should return the object if path is empty', function () {
+    var obj = getTestObj()
+    expect(objectPath.ensureExists(obj, [], 'test')).to.have.property('a', 'b')
+  })
+
+  it('Issue #26', function () {
+    var any = {}
+    objectPath.ensureExists(any, ['1', '1'], {})
+    expect(any).to.be.an('object')
+    expect(any[1]).to.be.an('object')
+    expect(any[1][1]).to.be.an('object')
+  })
+})
+
+describe('coalesce', function () {
+  it('should return the first non-undefined value', function () {
     var obj = {
       should: {have: 'prop'}
-    };
+    }
 
     expect(objectPath.coalesce(obj, [
       'doesnt.exist',
-      ['might','not','exist'],
+      ['might', 'not', 'exist'],
       'should.have'
-    ])).to.equal('prop');
-  });
+    ])).to.equal('prop')
+  })
 
-  it('should work with falsy values (null, 0, \'\', false)', function(){
+  it('should work with falsy values (null, 0, \'\', false)', function () {
     var obj = {
       is: {
         false: false,
@@ -333,81 +370,82 @@ describe('coalesce', function(){
         empty: '',
         zero: 0
       }
-    };
+    }
 
     expect(objectPath.coalesce(obj, [
       'doesnt.exist',
       'is.zero'
-    ])).to.equal(0);
+    ])).to.equal(0)
 
     expect(objectPath.coalesce(obj, [
       'doesnt.exist',
       'is.false'
-    ])).to.equal(false);
+    ])).to.equal(false)
 
     expect(objectPath.coalesce(obj, [
       'doesnt.exist',
       'is.null'
-    ])).to.equal(null);
+    ])).to.equal(null)
 
     expect(objectPath.coalesce(obj, [
       'doesnt.exist',
       'is.empty'
-    ])).to.equal('');
-  });
+    ])).to.equal('')
+  })
 
-  it('returns defaultValue if no paths found', function(){
+  it('returns defaultValue if no paths found', function () {
     var obj = {
       doesnt: 'matter'
-    };
+    }
 
-    expect(objectPath.coalesce(obj, ['some.inexistant','path',['on','object']], 'false')).to.equal('false');
-  });
+    expect(objectPath.coalesce(obj, ['some.inexistant', 'path', ['on', 'object']], 'false')).to.equal('false')
+  })
 
-  it('works with unicode and dot keys', function(){
+  it('works with unicode and dot keys', function () {
     var obj = {
       '\u7591': true,
       'dot.dot': false
-    };
+    }
 
-    expect(objectPath.coalesce(obj, ['1', '\u7591', 'a.b'])).to.equal(true);
-    expect(objectPath.coalesce(obj, ['1', ['dot.dot'], '\u7591'])).to.equal(false);
-  });
-});
+    expect(objectPath.coalesce(obj, ['1', '\u7591', 'a.b'])).to.equal(true)
+    expect(objectPath.coalesce(obj, ['1', ['dot.dot'], '\u7591'])).to.equal(false)
+  })
+})
 
-describe('empty', function(){
-  it('should ignore invalid arguments safely', function(){
-    var obj = {};
-    expect(objectPath.empty()).to.equal(void 0);
-    expect(objectPath.empty(obj, 'path')).to.equal(void 0);
-    expect(objectPath.empty(obj, '')).to.equal(void 0);
+describe('empty', function () {
+  it('should ignore invalid arguments safely', function () {
+    var obj = {}
+    expect(objectPath.empty()).to.equal(void 0)
+    expect(objectPath.empty(obj, 'path')).to.equal(void 0)
+    expect(objectPath.empty(obj, '')).to.equal(void 0)
 
-    obj.path = true;
+    obj.path = true
 
-    expect(objectPath.empty(obj, 'inexistant')).to.equal(void 0);
+    expect(objectPath.empty(obj, 'inexistant')).to.equal(void 0)
 
-    expect(objectPath.empty(null, 'path')).to.equal(void 0);
-    expect(objectPath.empty(void 0, 'path')).to.equal(void 0);
-  });
+    expect(objectPath.empty(null, 'path')).to.equal(void 0)
+    expect(objectPath.empty(void 0, 'path')).to.equal(void 0)
+  })
 
-  it('should empty each path according to their types', function(){
-    function Instance(){
-      this.notOwn = true;
+  it('should empty each path according to their types', function () {
+    function Instance () {
+      this.notOwn = true
     }
 
     /*istanbul ignore next: not part of code */
-    Instance.prototype.test = function(){};
+    Instance.prototype.test = function () {
+    }
     /*istanbul ignore next: not part of code */
-    Instance.prototype.arr = [];
+    Instance.prototype.arr = []
 
     var
       obj = {
         string: 'some string',
-        array: ['some','array',[1,2,3]],
+        array: ['some', 'array', [1, 2, 3]],
         number: 21,
         boolean: true,
         object: {
-          some:'property',
+          some: 'property',
           sub: {
             'property': true
           },
@@ -415,533 +453,537 @@ describe('empty', function(){
           undefinedProp: void 0
         },
         instance: new Instance()
-      };
+      }
 
     /*istanbul ignore next: not part of code */
-    obj['function'] = function(){};
+    obj['function'] = function () {
+    }
 
-    objectPath.empty(obj, ['array','2']);
-    expect(obj.array[2]).to.deep.equal([]);
+    objectPath.empty(obj, ['array', '2'])
+    expect(obj.array[2]).to.deep.equal([])
 
-    objectPath.empty(obj, 'object.sub');
-    expect(obj.object.sub).to.deep.equal({});
+    objectPath.empty(obj, 'object.sub')
+    expect(obj.object.sub).to.deep.equal({})
 
-    objectPath.empty(obj, 'object.nullProp');
-    expect(obj.object.nullProp).to.equal(null);
+    objectPath.empty(obj, 'object.nullProp')
+    expect(obj.object.nullProp).to.equal(null)
 
-    objectPath.empty(obj, 'object.undefinedProp');
-    expect(obj.object.undefinedProp).to.equal(void 0);
-    expect(obj.object).to.have.property('undefinedProp');
+    objectPath.empty(obj, 'object.undefinedProp')
+    expect(obj.object.undefinedProp).to.equal(void 0)
+    expect(obj.object).to.have.property('undefinedProp')
 
-    objectPath.empty(obj, 'object.notAProp');
-    expect(obj.object.notAProp).to.equal(void 0);
-    expect(obj.object).to.not.have.property('notAProp');
+    objectPath.empty(obj, 'object.notAProp')
+    expect(obj.object.notAProp).to.equal(void 0)
+    expect(obj.object).to.not.have.property('notAProp')
 
-    objectPath.empty(obj, 'instance.test');
+    objectPath.empty(obj, 'instance.test')
     //instance.test is not own property, so it shouldn't be emptied
-    expect(obj.instance.test).to.be.a('function');
-    expect(Instance.prototype.test).to.be.a('function');
-
-    objectPath.empty(obj, 'string');
-    objectPath.empty(obj, 'number');
-    objectPath.empty(obj, 'boolean');
-    objectPath.empty(obj, 'function');
-    objectPath.empty(obj, 'array');
-    objectPath.empty(obj, 'object');
-    objectPath.empty(obj, 'instance');
-
-    expect(obj.string).to.equal('');
-    expect(obj.array).to.deep.equal([]);
-    expect(obj.number).to.equal(0);
-    expect(obj.boolean).to.equal(false);
-    expect(obj.object).to.deep.equal({});
-    expect(obj.instance.notOwn).to.be.an('undefined');
-    expect(obj.instance.arr).to.be.an('array');
-    expect(obj['function']).to.equal(null);
-  });
-});
-
-describe('del', function(){
-  it('should work with number path', function(){
-    var obj = getTestObj();
-    objectPath.del(obj.b.d, 1);
-    expect(obj.b.d).to.deep.equal(['a']);
-  });
-
-  it('should remove null and undefined props (but not explode on nested)', function(){
-    var obj = { nullProp: null, undefinedProp: void 0 };
-    expect(obj).to.have.property('nullProp');
-    expect(obj).to.have.property('undefinedProp');
-
-    objectPath.del(obj, 'nullProp.foo');
-    objectPath.del(obj, 'undefinedProp.bar');
-    expect(obj).to.have.property('nullProp');
-    expect(obj).to.have.property('undefinedProp');
-    expect(obj).to.deep.equal({ nullProp: null, undefinedProp: void 0 });
-
-    objectPath.del(obj, 'nullProp');
-    objectPath.del(obj, 'undefinedProp');
-    expect(obj).to.not.have.property('nullProp');
-    expect(obj).to.not.have.property('undefinedProp');
-    expect(obj).to.deep.equal({});
-  });
-
-  it('should delete deep paths', function(){
-    var obj = getTestObj();
-
-    expect(objectPath.del(obj)).to.be.equal(obj);
-
-    objectPath.set(obj, 'b.g.1.0', 'test');
-    objectPath.set(obj, 'b.g.1.1', 'test');
-    objectPath.set(obj, 'b.h.az', 'test');
-    objectPath.set(obj, 'b.\ubeef', 'test');
-    objectPath.set(obj, ['b','dot.dot'], 'test');
-
-    expect(obj).to.have.nested.property('b.g.1.0','test');
-    expect(obj).to.have.nested.property('b.g.1.1','test');
-    expect(obj).to.have.nested.property('b.h.az','test');
-    expect(obj).to.have.nested.property('b.\ubeef','test');
-
-    objectPath.del(obj, 'b.h.az');
-    expect(obj).to.not.have.nested.property('b.h.az');
-    expect(obj).to.have.nested.property('b.h');
-
-    objectPath.del(obj, 'b.g.1.1');
-    expect(obj).to.not.have.nested.property('b.g.1.1');
-    expect(obj).to.have.nested.property('b.g.1.0','test');
-
-    objectPath.del(obj, 'b.\ubeef');
-    expect(obj).to.not.have.nested.property('b.\ubeef');
-
-    objectPath.del(obj, ['b','dot.dot']);
-    expect(objectPath.get(obj, ['b','dot.dot'])).to.be.equal(void 0);
-
-    objectPath.del(obj, ['b','g','1','0']);
-    expect(obj).to.not.have.nested.property('b.g.1.0');
-    expect(obj).to.have.nested.property('b.g.1');
-
-    expect(objectPath.del(obj, ['b'])).to.not.have.nested.property('b.g');
-    expect(obj).to.be.deep.equal({'a':'b'});
-  });
-
-  it('should remove items from existing array', function(){
-    var obj = getTestObj();
-
-    objectPath.del(obj, 'b.d.0');
-    expect(obj.b.d).to.have.length(1);
-    expect(obj.b.d).to.be.deep.equal(['b']);
-
-    objectPath.del(obj, 'b.d.0');
-    expect(obj.b.d).to.have.length(0);
-    expect(obj.b.d).to.be.deep.equal([]);
-  });
-});
-
-describe('insert', function(){
-  it('should insert value into existing array', function(){
-    var obj = getTestObj();
-
-    objectPath.insert(obj, 'b.c', 'asdf');
-    expect(obj).to.have.nested.property('b.c.0', 'asdf');
-    expect(obj).to.not.have.nested.property('b.c.1');
-  });
-
-  it('should create intermediary array', function(){
-    var obj = getTestObj();
-
-    objectPath.insert(obj, 'b.c.0', 'asdf');
-    expect(obj).to.have.nested.property('b.c.0.0', 'asdf');
-  });
-
-  it('should insert in another index', function(){
-    var obj = getTestObj();
-
-    objectPath.insert(obj, 'b.d', 'asdf', 1);
-    expect(obj).to.have.nested.property('b.d.1', 'asdf');
-    expect(obj).to.have.nested.property('b.d.0', 'a');
-    expect(obj).to.have.nested.property('b.d.2', 'b');
-  });
-
-  it('should handle sparse array', function(){
-    var obj = getTestObj();
-    obj.b.d = new Array(4);
-    obj.b.d[0] = 'a';
-    obj.b.d[1] = 'b';
-
-    objectPath.insert(obj, 'b.d', 'asdf', 3);
+    expect(obj.instance.test).to.be.a('function')
+    expect(Instance.prototype.test).to.be.a('function')
+
+    objectPath.empty(obj, 'string')
+    objectPath.empty(obj, 'number')
+    objectPath.empty(obj, 'boolean')
+    objectPath.empty(obj, 'function')
+    objectPath.empty(obj, 'array')
+    objectPath.empty(obj, 'object')
+    objectPath.empty(obj, 'instance')
+
+    expect(obj.string).to.equal('')
+    expect(obj.array).to.deep.equal([])
+    expect(obj.number).to.equal(0)
+    expect(obj.boolean).to.equal(false)
+    expect(obj.object).to.deep.equal({})
+    expect(obj.instance.notOwn).to.be.an('undefined')
+    expect(obj.instance.arr).to.be.an('array')
+    expect(obj['function']).to.equal(null)
+  })
+})
+
+describe('del', function () {
+  it('should work with number path', function () {
+    var obj = getTestObj()
+    objectPath.del(obj.b.d, 1)
+    expect(obj.b.d).to.deep.equal(['a'])
+  })
+
+  it('should remove null and undefined props (but not explode on nested)', function () {
+    var obj = {nullProp: null, undefinedProp: void 0}
+    expect(obj).to.have.property('nullProp')
+    expect(obj).to.have.property('undefinedProp')
+
+    objectPath.del(obj, 'nullProp.foo')
+    objectPath.del(obj, 'undefinedProp.bar')
+    expect(obj).to.have.property('nullProp')
+    expect(obj).to.have.property('undefinedProp')
+    expect(obj).to.deep.equal({nullProp: null, undefinedProp: void 0})
+
+    objectPath.del(obj, 'nullProp')
+    objectPath.del(obj, 'undefinedProp')
+    expect(obj).to.not.have.property('nullProp')
+    expect(obj).to.not.have.property('undefinedProp')
+    expect(obj).to.deep.equal({})
+  })
+
+  it('should delete deep paths', function () {
+    var obj = getTestObj()
+
+    expect(objectPath.del(obj)).to.be.equal(obj)
+
+    objectPath.set(obj, 'b.g.1.0', 'test')
+    objectPath.set(obj, 'b.g.1.1', 'test')
+    objectPath.set(obj, 'b.h.az', 'test')
+    objectPath.set(obj, 'b.\ubeef', 'test')
+    objectPath.set(obj, ['b', 'dot.dot'], 'test')
+
+    expect(obj).to.have.nested.property('b.g.1.0', 'test')
+    expect(obj).to.have.nested.property('b.g.1.1', 'test')
+    expect(obj).to.have.nested.property('b.h.az', 'test')
+    expect(obj).to.have.nested.property('b.\ubeef', 'test')
+
+    objectPath.del(obj, 'b.h.az')
+    expect(obj).to.not.have.nested.property('b.h.az')
+    expect(obj).to.have.nested.property('b.h')
+
+    objectPath.del(obj, 'b.g.1.1')
+    expect(obj).to.not.have.nested.property('b.g.1.1')
+    expect(obj).to.have.nested.property('b.g.1.0', 'test')
+
+    objectPath.del(obj, 'b.\ubeef')
+    expect(obj).to.not.have.nested.property('b.\ubeef')
+
+    objectPath.del(obj, ['b', 'dot.dot'])
+    expect(objectPath.get(obj, ['b', 'dot.dot'])).to.be.equal(void 0)
+
+    objectPath.del(obj, ['b', 'g', '1', '0'])
+    expect(obj).to.not.have.nested.property('b.g.1.0')
+    expect(obj).to.have.nested.property('b.g.1')
+
+    expect(objectPath.del(obj, ['b'])).to.not.have.nested.property('b.g')
+    expect(obj).to.be.deep.equal({'a': 'b'})
+  })
+
+  it('should remove items from existing array', function () {
+    var obj = getTestObj()
+
+    objectPath.del(obj, 'b.d.0')
+    expect(obj.b.d).to.have.length(1)
+    expect(obj.b.d).to.be.deep.equal(['b'])
+
+    objectPath.del(obj, 'b.d.0')
+    expect(obj.b.d).to.have.length(0)
+    expect(obj.b.d).to.be.deep.equal([])
+  })
+})
+
+describe('insert', function () {
+  it('should insert value into existing array', function () {
+    var obj = getTestObj()
+
+    objectPath.insert(obj, 'b.c', 'asdf')
+    expect(obj).to.have.nested.property('b.c.0', 'asdf')
+    expect(obj).to.not.have.nested.property('b.c.1')
+  })
+
+  it('should create intermediary array', function () {
+    var obj = getTestObj()
+
+    objectPath.insert(obj, 'b.c.0', 'asdf')
+    expect(obj).to.have.nested.property('b.c.0.0', 'asdf')
+  })
+
+  it('should insert in another index', function () {
+    var obj = getTestObj()
+
+    objectPath.insert(obj, 'b.d', 'asdf', 1)
+    expect(obj).to.have.nested.property('b.d.1', 'asdf')
+    expect(obj).to.have.nested.property('b.d.0', 'a')
+    expect(obj).to.have.nested.property('b.d.2', 'b')
+  })
+
+  it('should handle sparse array', function () {
+    var obj = getTestObj()
+    obj.b.d = new Array(4)
+    obj.b.d[0] = 'a'
+    obj.b.d[1] = 'b'
+
+    objectPath.insert(obj, 'b.d', 'asdf', 3)
     expect(obj.b.d).to.have.members([
       'a',
       'b',
       ,
       ,
       'asdf'
-    ]);
-  });
-});
+    ])
+  })
+})
 
 describe('has', function () {
   it('should return false for empty object', function () {
-    expect(objectPath.has({}, 'a')).to.be.equal(false);
-  });
+    expect(objectPath.has({}, 'a')).to.be.equal(false)
+  })
 
   it('should handle empty paths properly', function () {
-    var obj = getTestObj();
-    expect(objectPath.has(obj, '')).to.be.equal(false);
-    expect(objectPath.has(obj, [''])).to.be.equal(false);
+    var obj = getTestObj()
+    expect(objectPath.has(obj, '')).to.be.equal(false)
+    expect(objectPath.has(obj, [''])).to.be.equal(false)
     obj[''] = 1
-    expect(objectPath.has(obj, '')).to.be.equal(true);
-    expect(objectPath.has(obj, [''])).to.be.equal(true);
-
-    expect(objectPath.has(obj, [])).to.be.equal(true);
-    expect(objectPath.has(null, [])).to.be.equal(false);
-  });
-
-  it('should test under shallow object', function() {
-    var obj = getTestObj();
-    expect(objectPath.has(obj, 'a')).to.be.equal(true);
-    expect(objectPath.has(obj, ['a'])).to.be.equal(true);
-    expect(objectPath.has(obj, 'z')).to.be.equal(false);
-    expect(objectPath.has(obj, ['z'])).to.be.equal(false);
-  });
-
-  it('should work with number path', function() {
-    var obj = getTestObj();
-    expect(objectPath.has(obj.b.d, 0)).to.be.equal(true);
-    expect(objectPath.has(obj.b, 0)).to.be.equal(false);
-    expect(objectPath.has(obj.b.d, 10)).to.be.equal(false);
-    expect(objectPath.has(obj.b, 10)).to.be.equal(false);
-  });
-
-  it('should test under deep object', function() {
-    var obj = getTestObj();
-    expect(objectPath.has(obj, 'b.f')).to.be.equal(true);
-    expect(objectPath.has(obj, ['b','f'])).to.be.equal(true);
-    expect(objectPath.has(obj, 'b.g')).to.be.equal(false);
-    expect(objectPath.has(obj, ['b','g'])).to.be.equal(false);
-  });
-
-  it('should test value under array', function() {
+    expect(objectPath.has(obj, '')).to.be.equal(true)
+    expect(objectPath.has(obj, [''])).to.be.equal(true)
+
+    expect(objectPath.has(obj, [])).to.be.equal(true)
+    expect(objectPath.has(null, [])).to.be.equal(false)
+  })
+
+  it('should test under shallow object', function () {
+    var obj = getTestObj()
+    expect(objectPath.has(obj, 'a')).to.be.equal(true)
+    expect(objectPath.has(obj, ['a'])).to.be.equal(true)
+    expect(objectPath.has(obj, 'z')).to.be.equal(false)
+    expect(objectPath.has(obj, ['z'])).to.be.equal(false)
+  })
+
+  it('should work with number path', function () {
+    var obj = getTestObj()
+    expect(objectPath.has(obj.b.d, 0)).to.be.equal(true)
+    expect(objectPath.has(obj.b, 0)).to.be.equal(false)
+    expect(objectPath.has(obj.b.d, 10)).to.be.equal(false)
+    expect(objectPath.has(obj.b, 10)).to.be.equal(false)
+  })
+
+  it('should test under deep object', function () {
+    var obj = getTestObj()
+    expect(objectPath.has(obj, 'b.f')).to.be.equal(true)
+    expect(objectPath.has(obj, ['b', 'f'])).to.be.equal(true)
+    expect(objectPath.has(obj, 'b.g')).to.be.equal(false)
+    expect(objectPath.has(obj, ['b', 'g'])).to.be.equal(false)
+  })
+
+  it('should test value under array', function () {
     var obj = {
       b: ['a']
-    };
+    }
     obj.b[3] = {o: 'a'}
-    expect(objectPath.has(obj, 'b.0')).to.be.equal(true);
-    expect(objectPath.has(obj, 'b.1')).to.be.equal(true);
-    expect(objectPath.has(obj, 'b.3.o')).to.be.equal(true);
-    expect(objectPath.has(obj, 'b.3.qwe')).to.be.equal(false);
-    expect(objectPath.has(obj, 'b.4')).to.be.equal(false);
-  });
-
-  it('should test the value under array deep', function() {
-    var obj = getTestObj();
-    expect(objectPath.has(obj, 'b.e.1.f')).to.be.equal(true);
-    expect(objectPath.has(obj, ['b','e',1,'f'])).to.be.equal(true);
-    expect(objectPath.has(obj, 'b.e.1.f.g.h.i')).to.be.equal(false);
-    expect(objectPath.has(obj, ['b','e',1,'f','g','h','i'])).to.be.equal(false);
-  });
-
-  it('should test the value under integer-like key', function() {
-    var obj = { '1a': 'foo' };
-    expect(objectPath.has(obj, '1a')).to.be.equal(true);
-    expect(objectPath.has(obj, ['1a'])).to.be.equal(true);
-  });
-
-  it('should distinct nonexistent key and key = undefined', function() {
-    var obj = {};
-    expect(objectPath.has(obj, 'key')).to.be.equal(false);
-
-    obj.key = undefined;
-    expect(objectPath.has(obj, 'key')).to.be.equal(true);
-  });
-
-  it('should work with deep undefined/null values', function() {
-    var obj = {};
-    expect(objectPath.has(obj, 'missing.test')).to.be.equal(false);
-
-    obj.missing = null;
-    expect(objectPath.has(obj, 'missing.test')).to.be.equal(false);
+    expect(objectPath.has(obj, 'b.0')).to.be.equal(true)
+    expect(objectPath.has(obj, 'b.1')).to.be.equal(true)
+    expect(objectPath.has(obj, 'b.3.o')).to.be.equal(true)
+    expect(objectPath.has(obj, 'b.3.qwe')).to.be.equal(false)
+    expect(objectPath.has(obj, 'b.4')).to.be.equal(false)
+  })
+
+  it('should test the value under array deep', function () {
+    var obj = getTestObj()
+    expect(objectPath.has(obj, 'b.e.1.f')).to.be.equal(true)
+    expect(objectPath.has(obj, ['b', 'e', 1, 'f'])).to.be.equal(true)
+    expect(objectPath.has(obj, 'b.e.1.f.g.h.i')).to.be.equal(false)
+    expect(objectPath.has(obj, ['b', 'e', 1, 'f', 'g', 'h', 'i'])).to.be.equal(false)
+  })
+
+  it('should test the value under integer-like key', function () {
+    var obj = {'1a': 'foo'}
+    expect(objectPath.has(obj, '1a')).to.be.equal(true)
+    expect(objectPath.has(obj, ['1a'])).to.be.equal(true)
+  })
+
+  it('should distinct nonexistent key and key = undefined', function () {
+    var obj = {}
+    expect(objectPath.has(obj, 'key')).to.be.equal(false)
+
+    obj.key = undefined
+    expect(objectPath.has(obj, 'key')).to.be.equal(true)
+  })
+
+  it('should work with deep undefined/null values', function () {
+    var obj = {}
+    expect(objectPath.has(obj, 'missing.test')).to.be.equal(false)
+
+    obj.missing = null
+    expect(objectPath.has(obj, 'missing.test')).to.be.equal(false)
 
     obj.sparseArray = [1, undefined, 3]
-    expect(objectPath.has(obj, 'sparseArray.1.test')).to.be.equal(false);
-  });
-});
-
+    expect(objectPath.has(obj, 'sparseArray.1.test')).to.be.equal(false)
+  })
+})
 
 
 describe('bind object', function () {
   // just get one scenario from each feature, so whole functionality is proxied well
-  it('should return the value under shallow object', function() {
-    var obj = getTestObj();
-    var model = objectPath(obj);
-    expect(model.get('a')).to.be.equal('b');
-    expect(model.get(['a'])).to.be.equal('b');
-  });
-
-  it('should set value under shallow object', function() {
-    var obj = getTestObj();
-    var model = objectPath(obj);
-    model.set('c', {m: 'o'});
-    expect(obj).to.have.nested.property('c.m', 'o');
-    obj = getTestObj();
-    model = objectPath(obj);
-    model.set(['c'], {m: 'o'});
-    expect(obj).to.have.nested.property('c.m', 'o');
-  });
-
-  it('should push value to existing array', function() {
-    var obj = getTestObj();
-    var model = objectPath(obj);
-    model.push('b.c', 'l');
-    expect(obj).to.have.nested.property('b.c.0', 'l');
-    obj = getTestObj();
-    model = objectPath(obj);
-    model.push(['b','c'], 'l');
-    expect(obj).to.have.nested.property('b.c.0', 'l');
-  });
-
-  it('should create the path if it does not exists', function() {
-    var obj = getTestObj();
-    var model = objectPath(obj);
-    var oldVal = model.ensureExists('b.g.1.l', 'test');
-    expect(oldVal).to.not.exist;
-    expect(obj).to.have.nested.property('b.g.1.l', 'test');
-    oldVal = model.ensureExists('b.g.1.l', 'test1');
-    expect(oldVal).to.be.equal('test');
-    expect(obj).to.have.nested.property('b.g.1.l', 'test');
-  });
-
-  it('should return the first non-undefined value', function(){
+  it('should return the value under shallow object', function () {
+    var obj = getTestObj()
+    var model = objectPath(obj)
+    expect(model.get('a')).to.be.equal('b')
+    expect(model.get(['a'])).to.be.equal('b')
+  })
+
+  it('should set value under shallow object', function () {
+    var obj = getTestObj()
+    var model = objectPath(obj)
+    model.set('c', {m: 'o'})
+    expect(obj).to.have.nested.property('c.m', 'o')
+    obj = getTestObj()
+    model = objectPath(obj)
+    model.set(['c'], {m: 'o'})
+    expect(obj).to.have.nested.property('c.m', 'o')
+  })
+
+  it('should push value to existing array', function () {
+    var obj = getTestObj()
+    var model = objectPath(obj)
+    model.push('b.c', 'l')
+    expect(obj).to.have.nested.property('b.c.0', 'l')
+    obj = getTestObj()
+    model = objectPath(obj)
+    model.push(['b', 'c'], 'l')
+    expect(obj).to.have.nested.property('b.c.0', 'l')
+  })
+
+  it('should create the path if it does not exists', function () {
+    var obj = getTestObj()
+    var model = objectPath(obj)
+    var oldVal = model.ensureExists('b.g.1.l', 'test')
+    expect(oldVal).to.not.exist
+    expect(obj).to.have.nested.property('b.g.1.l', 'test')
+    oldVal = model.ensureExists('b.g.1.l', 'test1')
+    expect(oldVal).to.be.equal('test')
+    expect(obj).to.have.nested.property('b.g.1.l', 'test')
+  })
+
+  it('should return the first non-undefined value', function () {
     var obj = {
       should: {have: 'prop'}
-    };
-    var model = objectPath(obj);
+    }
+    var model = objectPath(obj)
 
     expect(model.coalesce([
       'doesnt.exist',
-      ['might','not','exist'],
+      ['might', 'not', 'exist'],
       'should.have'
-    ])).to.equal('prop');
-  });
+    ])).to.equal('prop')
+  })
 
-  it('should empty each path according to their types', function(){
-    function Instance(){
-      this.notOwn = true;
+  it('should empty each path according to their types', function () {
+    function Instance () {
+      this.notOwn = true
     }
 
     /*istanbul ignore next: not part of code */
-    Instance.prototype.test = function(){};
+    Instance.prototype.test = function () {
+    }
     /*istanbul ignore next: not part of code */
-    Instance.prototype.arr = [];
+    Instance.prototype.arr = []
 
     var
       obj = {
         string: 'some string',
-        array: ['some','array',[1,2,3]],
+        array: ['some', 'array', [1, 2, 3]],
         number: 21,
         boolean: true,
         object: {
-          some:'property',
+          some: 'property',
           sub: {
             'property': true
           }
         },
         instance: new Instance()
-      };
+      }
 
     /*istanbul ignore next: not part of code */
-    obj['function'] = function(){};
+    obj['function'] = function () {
+    }
 
-    var model = objectPath(obj);
+    var model = objectPath(obj)
 
-    model.empty(['array','2']);
-    expect(obj.array[2]).to.deep.equal([]);
+    model.empty(['array', '2'])
+    expect(obj.array[2]).to.deep.equal([])
 
-    model.empty('object.sub');
-    expect(obj.object.sub).to.deep.equal({});
+    model.empty('object.sub')
+    expect(obj.object.sub).to.deep.equal({})
 
-    model.empty('instance.test');
+    model.empty('instance.test')
     //instance.test is not own property so it shouldn't be emptied
-    expect(obj.instance.test).to.be.a('function');
-    expect(Instance.prototype.test).to.be.a('function');
-
-    model.empty('string');
-    model.empty('number');
-    model.empty('boolean');
-    model.empty('function');
-    model.empty('array');
-    model.empty('object');
-    model.empty('instance');
-
-    expect(obj.string).to.equal('');
-    expect(obj.array).to.deep.equal([]);
-    expect(obj.number).to.equal(0);
-    expect(obj.boolean).to.equal(false);
-    expect(obj.object).to.deep.equal({});
-    expect(obj.instance.notOwn).to.be.an('undefined');
-    expect(obj.instance.arr).to.be.an('array');
-    expect(obj['function']).to.equal(null);
-  });
-
-  it('should delete deep paths', function(){
-    var obj = getTestObj();
-    var model = objectPath(obj);
-
-    expect(model.del()).to.be.equal(obj);
-
-    model.set('b.g.1.0', 'test');
-    model.set('b.g.1.1', 'test');
-    model.set('b.h.az', 'test');
-
-    expect(obj).to.have.nested.property('b.g.1.0','test');
-    expect(obj).to.have.nested.property('b.g.1.1','test');
-    expect(obj).to.have.nested.property('b.h.az','test');
-
-    model.del('b.h.az');
-    expect(obj).to.not.have.nested.property('b.h.az');
-    expect(obj).to.have.nested.property('b.h');
-
-    model.del('b.g.1.1');
-    expect(obj).to.not.have.nested.property('b.g.1.1');
-    expect(obj).to.have.nested.property('b.g.1.0','test');
-
-    model.del(['b','g','1','0']);
-    expect(obj).to.not.have.nested.property('b.g.1.0');
-    expect(obj).to.have.nested.property('b.g.1');
-
-    expect(model.del(['b'])).to.not.have.nested.property('b.g');
-    expect(obj).to.be.deep.equal({'a':'b'});
-  });
-
-  it('should insert value into existing array', function(){
-    var obj = getTestObj();
-    var model = objectPath(obj);
-
-    model.insert('b.c', 'asdf');
-    expect(obj).to.have.nested.property('b.c.0', 'asdf');
-    expect(obj).to.not.have.nested.property('b.c.1');
-  });
-
-  it('should test under shallow object', function() {
-    var obj = getTestObj();
-    var model = objectPath(obj);
-
-    expect(model.has('a')).to.be.equal(true);
-    expect(model.has(['a'])).to.be.equal(true);
-    expect(model.has('z')).to.be.equal(false);
-    expect(model.has(['z'])).to.be.equal(false);
-  });
-});
+    expect(obj.instance.test).to.be.a('function')
+    expect(Instance.prototype.test).to.be.a('function')
+
+    model.empty('string')
+    model.empty('number')
+    model.empty('boolean')
+    model.empty('function')
+    model.empty('array')
+    model.empty('object')
+    model.empty('instance')
+
+    expect(obj.string).to.equal('')
+    expect(obj.array).to.deep.equal([])
+    expect(obj.number).to.equal(0)
+    expect(obj.boolean).to.equal(false)
+    expect(obj.object).to.deep.equal({})
+    expect(obj.instance.notOwn).to.be.an('undefined')
+    expect(obj.instance.arr).to.be.an('array')
+    expect(obj['function']).to.equal(null)
+  })
+
+  it('should delete deep paths', function () {
+    var obj = getTestObj()
+    var model = objectPath(obj)
+
+    expect(model.del()).to.be.equal(obj)
+
+    model.set('b.g.1.0', 'test')
+    model.set('b.g.1.1', 'test')
+    model.set('b.h.az', 'test')
+
+    expect(obj).to.have.nested.property('b.g.1.0', 'test')
+    expect(obj).to.have.nested.property('b.g.1.1', 'test')
+    expect(obj).to.have.nested.property('b.h.az', 'test')
+
+    model.del('b.h.az')
+    expect(obj).to.not.have.nested.property('b.h.az')
+    expect(obj).to.have.nested.property('b.h')
+
+    model.del('b.g.1.1')
+    expect(obj).to.not.have.nested.property('b.g.1.1')
+    expect(obj).to.have.nested.property('b.g.1.0', 'test')
+
+    model.del(['b', 'g', '1', '0'])
+    expect(obj).to.not.have.nested.property('b.g.1.0')
+    expect(obj).to.have.nested.property('b.g.1')
+
+    expect(model.del(['b'])).to.not.have.nested.property('b.g')
+    expect(obj).to.be.deep.equal({'a': 'b'})
+  })
+
+  it('should insert value into existing array', function () {
+    var obj = getTestObj()
+    var model = objectPath(obj)
+
+    model.insert('b.c', 'asdf')
+    expect(obj).to.have.nested.property('b.c.0', 'asdf')
+    expect(obj).to.not.have.nested.property('b.c.1')
+  })
+
+  it('should test under shallow object', function () {
+    var obj = getTestObj()
+    var model = objectPath(obj)
+
+    expect(model.has('a')).to.be.equal(true)
+    expect(model.has(['a'])).to.be.equal(true)
+    expect(model.has('z')).to.be.equal(false)
+    expect(model.has(['z'])).to.be.equal(false)
+  })
+})
 
 describe('Don\'t access not own properties [default]', function () {
-  it('should not get a not own property', function() {
-    var Obj = function() {};
-    Obj.prototype.notOwn = {a: 'a'};
-    var obj = new Obj();
+  it('should not get a not own property', function () {
+    var Obj = function () {
+    }
+    Obj.prototype.notOwn = {a: 'a'}
+    var obj = new Obj()
 
     expect(objectPath.get(obj, 'notOwn')).to.be.undefined
-  });
+  })
 
-  it('should set a not own property on the instance (not the prototype)', function() {
+  it('should set a not own property on the instance (not the prototype)', function () {
     var proto = {
       notOwn: {}
     }
     var obj = Object.create(proto)
 
-    objectPath.set(obj, 'notOwn.test', 'a');
-    expect(obj.notOwn.test).to.be.equal('a');
-    expect(proto.notOwn).to.be.deep.equal({});
-  });
+    objectPath.set(obj, 'notOwn.test', 'a')
+    expect(obj.notOwn.test).to.be.equal('a')
+    expect(proto.notOwn).to.be.deep.equal({})
+  })
 
-  it('has should return false on a not own property', function() {
+  it('has should return false on a not own property', function () {
     var proto = {
       notOwn: {a: 'a'}
     }
     var obj = Object.create(proto)
 
 
-    expect(objectPath.has(obj, 'notOwn')).to.be.false;
-    expect(objectPath.has(obj, 'notOwn.a')).to.be.false;
-  });
+    expect(objectPath.has(obj, 'notOwn')).to.be.false
+    expect(objectPath.has(obj, 'notOwn.a')).to.be.false
+  })
 
-  it('empty should not empty on a not own property', function() {
+  it('empty should not empty on a not own property', function () {
     var proto = {
       notOwn: {a: 'a'}
     }
-    var obj = Object.create(proto);
+    var obj = Object.create(proto)
 
-    objectPath.empty(obj, 'notOwn');
-    expect(proto.notOwn).to.be.deep.equal({a: 'a'});
-    expect(obj.notOwn).to.be.deep.equal({a: 'a'});
-  });
+    objectPath.empty(obj, 'notOwn')
+    expect(proto.notOwn).to.be.deep.equal({a: 'a'})
+    expect(obj.notOwn).to.be.deep.equal({a: 'a'})
+  })
 
-  it('del should not delete not own property', function() {
+  it('del should not delete not own property', function () {
     var proto = {
       notOwn: {a: 'a'}
     }
-    var obj = Object.create(proto);
+    var obj = Object.create(proto)
 
-    objectPath.del(obj, 'notOwn.a');
-    expect(proto.notOwn).to.be.deep.equal({a: 'a'});
+    objectPath.del(obj, 'notOwn.a')
+    expect(proto.notOwn).to.be.deep.equal({a: 'a'})
     //expect(obj.notOwn).to.be.deep.equal({a: 'a'});
     //objectPath.del(obj, 'notOwn');
     //expect(proto).to.be.deep.equal({notOwn: {a: 'a'}});
     //expect(obj).to.be.deep.equal({notOwn: {a: 'a'}});
-  });
-});
+  })
+})
 
 describe('Access own properties [optional]', function () {
-  it('should get a not own property', function() {
-    var Obj = function() {};
-    Obj.prototype.notOwn = {a: 'a'};
-    var obj = new Obj();
+  it('should get a not own property', function () {
+    var Obj = function () {
+    }
+    Obj.prototype.notOwn = {a: 'a'}
+    var obj = new Obj()
 
     expect(objectPath.withInheritedProps.get(obj, 'notOwn.a')).to.be.equal('a')
-  });
+  })
 
-  it('should set a deep not own property on the prototype (if exists)', function() {
+  it('should set a deep not own property on the prototype (if exists)', function () {
     var proto = {
       notOwn: {}
     }
     var obj = Object.create(proto)
 
-    objectPath.withInheritedProps.set(obj, 'notOwn.test', 'a');
-    expect(obj.notOwn.test).to.be.equal('a');
-    expect(proto.notOwn).to.be.deep.equal({test: 'a'});
-  });
+    objectPath.withInheritedProps.set(obj, 'notOwn.test', 'a')
+    expect(obj.notOwn.test).to.be.equal('a')
+    expect(proto.notOwn).to.be.deep.equal({test: 'a'})
+  })
 
 
-  it('has should return true on a not own property', function() {
+  it('has should return true on a not own property', function () {
     var proto = {
       notOwn: {a: 'a'}
     }
     var obj = Object.create(proto)
 
-    expect(objectPath.withInheritedProps.has(obj, 'notOwn')).to.be.true;
-    expect(objectPath.withInheritedProps.has(obj, 'notOwn.a')).to.be.true;
-  });
+    expect(objectPath.withInheritedProps.has(obj, 'notOwn')).to.be.true
+    expect(objectPath.withInheritedProps.has(obj, 'notOwn.a')).to.be.true
+  })
 
-  it('empty should empty a not own property', function() {
+  it('empty should empty a not own property', function () {
     var proto = {
       notOwn: {a: 'a'}
     }
-    var obj = Object.create(proto);
+    var obj = Object.create(proto)
 
-    objectPath.withInheritedProps.empty(obj, 'notOwn');
-    expect(proto.notOwn).to.be.deep.equal({});
-    expect(obj.notOwn).to.be.deep.equal({});
-  });
+    objectPath.withInheritedProps.empty(obj, 'notOwn')
+    expect(proto.notOwn).to.be.deep.equal({})
+    expect(obj.notOwn).to.be.deep.equal({})
+  })
 
-  it('del should delete a not own property', function() {
+  it('del should delete a not own property', function () {
     var proto = {
       notOwn: {a: 'a'}
     }
-    var obj = Object.create(proto);
+    var obj = Object.create(proto)
 
-    objectPath.withInheritedProps.del(obj, 'notOwn.a');
-    expect(proto.notOwn).to.be.deep.equal({});
+    objectPath.withInheritedProps.del(obj, 'notOwn.a')
+    expect(proto.notOwn).to.be.deep.equal({})
     //expect(obj.notOwn).to.be.deep.equal({});
-    objectPath.withInheritedProps.del(obj, 'notOwn');
+    objectPath.withInheritedProps.del(obj, 'notOwn')
     //expect(proto).to.be.deep.equal({notOwn: {}});
     //expect(obj).to.be.deep.equal({notOwn: {}});
-  });
-});
+  })
+})",
"url": "https://github.com/mariocasciaro/object-path/commit/2be3354c6c46215c7635eb1b76d80f1319403c68.patch"
}
] | null |
PYSEC-2024-23
| null |
[
{
"commit_message": "[PATCH] Validate urls in `element` and `window` endpoints Domains were previously not validated before being handled, leading to a potential scenario where someone could pass something like \"element_url=127.0.0.1:<port>/<resource>\" to access other resources on a machine running Whoogle. This change ensures that the resource used in both endpoints is a valid domain. This also includes validation of config names to prevent names from including path values such as \"../../(etc)\". app/routes.py | 33 ++++++++++++++++++++++++++------- 1 file changed, 26 insertions(+), 7 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/benbusby/whoogle-search/commit/3a2e0b262e4a076a20416b45e6b6f23fd265aeda.patch"
}
] | null |
|
CVE-2017-7856
|
LibreOffice before 2017-03-11 has an out-of-bounds write caused by a heap-based buffer overflow in the SVMConverter::ImplConvertFromSVM1 function in vcl/source/gdi/svmconverter.cxx.
|
[
{
"commit_message": "[PATCH] ofz#817 nStrLen-1 changed to nStrLen-3 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit regression from... commit ff8f6629287d0d1bdbcf4f8ed16cb8d077d08c7a Author: Caolán McNamara <[email protected]> Resolves: ofz#424 guard against broken dxary length but this weird typo doesn't appears in the 5-2 and 5-3 backports, odd how I managed that Change-Id: I5fb1db2284d48ee78e717d41274a3d37ab0255cf vcl/source/gdi/svmconverter.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/LibreOffice/core/commit/28e61b634353110445e334ccaa415d7fb6629d62.patch"
}
] |
n/a
|
|
PYSEC-2021-812
| null |
[
{
"commit_message": "[PATCH] Don't constant-fold DT_RESOURCE constants. PiperOrigin-RevId: 391803952 Change-Id: I0ea3ec31d3e7dfda0f03b4027a237f08d00a3091 tensorflow/core/common_runtime/constant_folding.cc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSA3NzMxZThkZmJlNGE1Njc3M2JlNWRjOTRkNjMxNjExMjExMTU2NjU5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiAiQS4gVW5pcXVlIFRlbnNvckZsb3dlciIgPGdhcmRlbmVyQHRlbnNvcmZsb3cub3JnPgpEYXRlOiBUaHUsIDE5IEF1ZyAyMDIxIDExOjI1OjMyIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gRG9uJ3QgY29uc3RhbnQtZm9sZCBEVF9SRVNPVVJDRSBjb25zdGFudHMuCgpQaXBlck9yaWdpbi1SZXZJZDogMzkxODAzOTUyCkNoYW5nZS1JZDogSTBlYTNlYzMxZDNlN2RmZGEwZjAzYjQwMjdhMjM3ZjA4ZDAwYTMwOTEKLS0tCiB0ZW5zb3JmbG93L2NvcmUvY29tbW9uX3J1bnRpbWUvY29uc3RhbnRfZm9sZGluZy5jYyB8IDQgKysrLQogMSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL3RlbnNvcmZsb3cvY29yZS9jb21tb25fcnVudGltZS9jb25zdGFudF9mb2xkaW5nLmNjIGIvdGVuc29yZmxvdy9jb3JlL2NvbW1vbl9ydW50aW1lL2NvbnN0YW50X2ZvbGRpbmcuY2MKaW5kZXggODM2N2U1ZmY2YWZmMzQuLmNhNzVkYzlmMTkxNjBhIDEwMDY0NAotLS0gYS90ZW5zb3JmbG93L2NvcmUvY29tbW9uX3J1bnRpbWUvY29uc3RhbnRfZm9sZGluZy5jYworKysgYi90ZW5zb3JmbG93L2NvcmUvY29tbW9uX3J1bnRpbWUvY29uc3RhbnRfZm9sZGluZy5jYwpAQCAtMzAsNiArMzAsNyBAQCBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS4KICNpbmNsdWRlICJ0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL2xvZ19tZW1vcnkuaCIKICNpbmNsdWRlICJ0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL29wX2tlcm5lbC5oIgogI2luY2x1ZGUgInRlbnNvcmZsb3cvY29yZS9mcmFtZXdvcmsvdHlwZXMuaCIKKyNpbmNsdWRlICJ0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL3R5cGVzLnBiLmgiCiAjaW5jbHVkZSAidGVuc29yZmxvdy9jb3JlL2dyYXBoL2FsZ29yaXRobS5oIgogI2luY2x1ZGUgInRlbnNvcmZsb3cvY29yZS9ncmFwaC9ub2RlX2J1aWxkZXIuaCIKICNpbmNsdWRlICJ0ZW5zb3JmbG93L2NvcmUvZ3JhcGgvc3ViZ3JhcGguaCIKQEAgLTIyMyw3ICsyMjQsOCBAQCBib29sIElzQ29uc3RhbnRGb2xkYWJsZSgKICAgICBzdGQ6OnVub3JkZXJlZF9tYXA8Y29uc3QgTm9kZSosIHN0ZDo6dmVjdG9yPFRlbnNvcj4+KgogICAgICAgICBzaGFwZV9yZXBsYWNlbWVudF9tYXApIHsKICAgaWYgKG4tPklzQ29uc3RhbnQoKSkgewotICAgIHJldHVybiB0cnVlOworICAgIC8vIFNraXAgY29uc3RhbnQgZm9sZGluZyByZXNvdXJjZXMgYXMgdGhleSBjYW5ub3QgYmUgZGVlcCBjb3BpZWQuCisgICAgcmV0dXJuIG4tPm91dHB1dF90eXBlKDApICE9IERUX1JFU09VUkNFOwogICB9CiAgIGlmIChNYXliZVJlcGxhY2VTaGFwZU9wKG4sIHNoYXBlX21hcCwgc2hhcGVfcmVwbGFjZW1lbnRfbWFwKSkgewogICAgIHJldHVybiB0cnVlOw==",
"url": "https://github.com/tensorflow/tensorflow/commit/7731e8dfbe4a56773be5dc94d631611211156659.patch"
}
] | null |
|
GHSA-g6hf-f9cq-q7w7
|
Cross-Site Request Forgery in Spring Framework
| null |
[
{
"commit_message": "[PATCH] Disable ext entities in SourceHttpMessageConverter This change disables the processing of external entities in SourceHttpMessageConverter by default and provides an option to enable it if required. .../xml/SourceHttpMessageConverter.java | 152 +++++++++++++----- .../xml/SourceHttpMessageConverterTests.java | 101 ++++++++++-- .../http/converter/xml/external.txt | 1 + 3 files changed, 204 insertions(+), 50 deletions(-) create mode 100644 spring-web/src/test/resources/org/springframework/http/converter/xml/external.txt",
"patch_text_b64": "From 2ae6a6a3415eebc57babcb9d3e5505887eda6d8a Mon Sep 17 00:00:00 2001
From: Rossen Stoyanchev <rstoyanchev@gopivotal.com>
Date: Tue, 5 Nov 2013 09:21:57 -0500
Subject: [PATCH] Disable ext entities in SourceHttpMessageConverter

This change disables the processing of external entities in
SourceHttpMessageConverter by default and provides an option to enable
it if required.
---
 .../xml/SourceHttpMessageConverter.java       | 152 +++++++++++++-----
 .../xml/SourceHttpMessageConverterTests.java  | 101 ++++++++++--
 .../http/converter/xml/external.txt           |   1 +
 3 files changed, 204 insertions(+), 50 deletions(-)
 create mode 100644 spring-web/src/test/resources/org/springframework/http/converter/xml/external.txt

diff --git a/spring-web/src/main/java/org/springframework/http/converter/xml/SourceHttpMessageConverter.java b/spring-web/src/main/java/org/springframework/http/converter/xml/SourceHttpMessageConverter.java
index e94950326322..1236940d27fb 100644
--- a/spring-web/src/main/java/org/springframework/http/converter/xml/SourceHttpMessageConverter.java
+++ b/spring-web/src/main/java/org/springframework/http/converter/xml/SourceHttpMessageConverter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,73 +17,144 @@
 package org.springframework.http.converter.xml;
 
 import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.OutputStream;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
 import javax.xml.transform.Result;
 import javax.xml.transform.Source;
 import javax.xml.transform.TransformerException;
-import javax.xml.transform.dom.DOMResult;
+import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.sax.SAXSource;
+import javax.xml.transform.stax.StAXSource;
 import javax.xml.transform.stream.StreamResult;
 import javax.xml.transform.stream.StreamSource;
 
+import org.w3c.dom.Document;
 import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.XMLReader;
+import org.xml.sax.helpers.XMLReaderFactory;
 
-import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpInputMessage;
+import org.springframework.http.HttpOutputMessage;
 import org.springframework.http.MediaType;
+import org.springframework.http.converter.AbstractHttpMessageConverter;
 import org.springframework.http.converter.HttpMessageConversionException;
 import org.springframework.http.converter.HttpMessageNotReadableException;
 import org.springframework.http.converter.HttpMessageNotWritableException;
+import org.springframework.util.StreamUtils;
 
 /**
- * Implementation of {@link org.springframework.http.converter.HttpMessageConverter} that can read and write {@link
- * Source} objects.
+ * Implementation of {@link org.springframework.http.converter.HttpMessageConverter}
+ * that can read and write {@link Source} objects.
  *
  * @author Arjen Poutsma
  * @since 3.0
  */
-public class SourceHttpMessageConverter<T extends Source> extends AbstractXmlHttpMessageConverter<T> {
+public class SourceHttpMessageConverter<T extends Source> extends AbstractHttpMessageConverter<T> {
+
+	private final TransformerFactory transformerFactory = TransformerFactory.newInstance();
+
+	private boolean processExternalEntities = false;
+
+	/**
+	 * Sets the {@link #setSupportedMediaTypes(java.util.List) supportedMediaTypes}
+	 * to {@code text/xml} and {@code application/xml}, and {@code application/*-xml}.
+	 */
+	public SourceHttpMessageConverter() {
+		super(MediaType.APPLICATION_XML, MediaType.TEXT_XML, new MediaType("application", "*+xml"));
+	}
+
+
+	/**
+	 * Indicates whether external XML entities are processed when converting
+	 * to a Source.
+	 * <p>Default is {@code false}, meaning that external entities are not resolved.
+	 */
+	public void setProcessExternalEntities(boolean processExternalEntities) {
+		this.processExternalEntities = processExternalEntities;
+	}
 
 	@Override
 	public boolean supports(Class<?> clazz) {
-		return DOMSource.class.equals(clazz) || SAXSource.class.equals(clazz) || StreamSource.class.equals(clazz) ||
-				Source.class.equals(clazz);
+		return DOMSource.class.equals(clazz) || SAXSource.class.equals(clazz)
+				|| StreamSource.class.equals(clazz) || Source.class.equals(clazz);
 	}
 
 	@Override
-	@SuppressWarnings("unchecked")
-	protected T readFromSource(Class clazz, HttpHeaders headers, Source source) throws IOException {
+	protected T readInternal(Class<? extends T> clazz, HttpInputMessage inputMessage)
+			throws IOException, HttpMessageNotReadableException {
+
+		InputStream body = inputMessage.getBody();
+		if (DOMSource.class.equals(clazz)) {
+			return (T) readDOMSource(body);
+		}
+		else if (SAXSource.class.equals(clazz)) {
+			return (T) readSAXSource(body);
+		}
+		else if (StAXSource.class.equals(clazz)) {
+			return (T) readStAXSource(body);
+		}
+		else if (StreamSource.class.equals(clazz) || Source.class.equals(clazz)) {
+			return (T) readStreamSource(body);
+		}
+		else {
+			throw new HttpMessageConversionException("Could not read class [" + clazz +
+					"]. Only DOMSource, SAXSource, and StreamSource are supported.");
+		}
+	}
+
+	private DOMSource readDOMSource(InputStream body) throws IOException {
 		try {
-			if (DOMSource.class.equals(clazz)) {
-				DOMResult domResult = new DOMResult();
-				transform(source, domResult);
-				return (T) new DOMSource(domResult.getNode());
-			}
-			else if (SAXSource.class.equals(clazz)) {
-				ByteArrayInputStream bis = transformToByteArrayInputStream(source);
-				return (T) new SAXSource(new InputSource(bis));
-			}
-			else if (StreamSource.class.equals(clazz) || Source.class.equals(clazz)) {
-				ByteArrayInputStream bis = transformToByteArrayInputStream(source);
-				return (T) new StreamSource(bis);
-			}
-			else {
-				throw new HttpMessageConversionException("Could not read class [" + clazz +
-						"]. Only DOMSource, SAXSource, and StreamSource are supported.");
-			}
+			DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
+			documentBuilderFactory.setNamespaceAware(true);
+			documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", processExternalEntities);
+			DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
+			Document document = documentBuilder.parse(body);
+			return new DOMSource(document);
 		}
-		catch (TransformerException ex) {
-			throw new HttpMessageNotReadableException("Could not transform from [" + source + "] to [" + clazz + "]",
-					ex);
+		catch (ParserConfigurationException ex) {
+			throw new HttpMessageNotReadableException("Could not set feature: " + ex.getMessage(), ex);
+		}
+		catch (SAXException ex) {
+			throw new HttpMessageNotReadableException("Could not parse document: " + ex.getMessage(), ex);
 		}
 	}
 
-	private ByteArrayInputStream transformToByteArrayInputStream(Source source) throws TransformerException {
-		ByteArrayOutputStream bos = new ByteArrayOutputStream();
-		transform(source, new StreamResult(bos));
-		return new ByteArrayInputStream(bos.toByteArray());
+	private SAXSource readSAXSource(InputStream body) throws IOException {
+		try {
+			XMLReader reader = XMLReaderFactory.createXMLReader();
+			reader.setFeature("http://xml.org/sax/features/external-general-entities", processExternalEntities);
+			byte[] bytes = StreamUtils.copyToByteArray(body);
+			return new SAXSource(reader, new InputSource(new ByteArrayInputStream(bytes)));
+		}
+		catch (SAXException ex) {
+			throw new HttpMessageNotReadableException("Could not parse document: " + ex.getMessage(), ex);
+		}
+	}
+
+	private Source readStAXSource(InputStream body) {
+		try {
+			XMLInputFactory inputFactory = XMLInputFactory.newFactory();
+			inputFactory.setProperty("javax.xml.stream.isSupportingExternalEntities", processExternalEntities);
+			XMLStreamReader streamReader = inputFactory.createXMLStreamReader(body);
+			return new StAXSource(streamReader);
+		}
+		catch (XMLStreamException ex) {
+			throw new HttpMessageNotReadableException("Could not parse document: " + ex.getMessage(), ex);
+		}
+	}
+
+	private StreamSource readStreamSource(InputStream body) throws IOException {
+		byte[] bytes = StreamUtils.copyToByteArray(body);
+		return new StreamSource(new ByteArrayInputStream(bytes));
 	}
 
 	@Override
@@ -102,15 +173,22 @@ protected Long getContentLength(T t, MediaType contentType) {
 	}
 
 	@Override
-	protected void writeToResult(T t, HttpHeaders headers, Result result) throws IOException {
+	protected void writeInternal(T t, HttpOutputMessage outputMessage)
+			throws IOException, HttpMessageNotWritableException {
 		try {
+			Result result = new StreamResult(outputMessage.getBody());
 			transform(t, result);
 		}
 		catch (TransformerException ex) {
-			throw new HttpMessageNotWritableException("Could not transform [" + t + "] to [" + result + "]", ex);
+			throw new HttpMessageNotWritableException("Could not transform [" + t + "] to output message", ex);
 		}
 	}
 
+	private void transform(Source source, Result result) throws TransformerException {
+		this.transformerFactory.newTransformer().transform(source, result);
+	}
+
+
 	private static class CountingOutputStream extends OutputStream {
 
 		private long count = 0;
diff --git a/spring-web/src/test/java/org/springframework/http/converter/xml/SourceHttpMessageConverterTests.java b/spring-web/src/test/java/org/springframework/http/converter/xml/SourceHttpMessageConverterTests.java
index c34e202330d1..b907b96935b0 100644
--- a/spring-web/src/test/java/org/springframework/http/converter/xml/SourceHttpMessageConverterTests.java
+++ b/spring-web/src/test/java/org/springframework/http/converter/xml/SourceHttpMessageConverterTests.java
@@ -17,21 +17,29 @@
 package org.springframework.http.converter.xml;
 
 import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
+import static org.junit.Assert.assertNotEquals;
 
+import java.io.IOException;
+import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.StringReader;
 import java.nio.charset.Charset;
 
 import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
 import javax.xml.transform.Source;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.sax.SAXSource;
+import javax.xml.transform.stax.StAXSource;
 import javax.xml.transform.stream.StreamSource;
 
 import org.junit.Before;
 import org.junit.Test;
+
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
 import org.springframework.http.MediaType;
 import org.springframework.http.MockHttpInputMessage;
 import org.springframework.http.MockHttpOutputMessage;
@@ -39,17 +47,29 @@
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.XMLReader;
+import org.xml.sax.helpers.DefaultHandler;
 
 /**
  * @author Arjen Poutsma
  */
 public class SourceHttpMessageConverterTests {
 
+	private static final String BODY = "<root>Hello World</root>";
+
 	private SourceHttpMessageConverter<Source> converter;
 
+	private String bodyExternal;
+
 	@Before
-	public void setUp() {
+	public void setUp() throws IOException {
 		converter = new SourceHttpMessageConverter<Source>();
+		Resource external = new ClassPathResource("external.txt", getClass());
+
+		bodyExternal = "<!DOCTYPE root [" +
+				"  <!ELEMENT root ANY >\n" +
+				"  <!ENTITY ext SYSTEM \"" + external.getURI() + "\" >]><root>&ext;</root>";
 	}
 
 	@Test
@@ -67,39 +87,94 @@ public void canWrite() {
 
 	@Test
 	public void readDOMSource() throws Exception {
-		String body = "<root>Hello World</root>";
-		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(BODY.getBytes("UTF-8"));
 		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
 		DOMSource result = (DOMSource) converter.read(DOMSource.class, inputMessage);
 		Document document = (Document) result.getNode();
 		assertEquals("Invalid result", "root", document.getDocumentElement().getLocalName());
 	}
 
+	@Test
+	public void readDOMSourceExternal() throws Exception {
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(bodyExternal.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		DOMSource result = (DOMSource) converter.read(DOMSource.class, inputMessage);
+		Document document = (Document) result.getNode();
+		assertEquals("Invalid result", "root", document.getDocumentElement().getLocalName());
+		assertNotEquals("Invalid result", "Foo Bar", document.getDocumentElement().getTextContent());
+	}
+
 	@Test
 	public void readSAXSource() throws Exception {
-		String body = "<root>Hello World</root>";
-		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(BODY.getBytes("UTF-8"));
 		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
 		SAXSource result = (SAXSource) converter.read(SAXSource.class, inputMessage);
 		InputSource inputSource = result.getInputSource();
 		String s = FileCopyUtils.copyToString(new InputStreamReader(inputSource.getByteStream()));
-		assertXMLEqual("Invalid result", body, s);
+		assertXMLEqual("Invalid result", BODY, s);
+	}
+
+	@Test
+	public void readSAXSourceExternal() throws Exception {
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(bodyExternal.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		SAXSource result = (SAXSource) converter.read(SAXSource.class, inputMessage);
+		InputSource inputSource = result.getInputSource();
+		XMLReader reader = result.getXMLReader();
+		reader.setContentHandler(new DefaultHandler() {
+			@Override
+			public void characters(char[] ch, int start, int length) throws SAXException {
+				String s = new String(ch, start, length);
+				assertNotEquals("Invalid result", "Foo Bar", s);
+			}
+		});
+		reader.parse(inputSource);
 	}
 
+	@Test
+	public void readStAXSource() throws Exception {
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(BODY.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		StAXSource result = (StAXSource) converter.read(StAXSource.class, inputMessage);
+		XMLStreamReader streamReader = result.getXMLStreamReader();
+		assertTrue(streamReader.hasNext());
+		streamReader.nextTag();
+		String s = streamReader.getLocalName();
+		assertEquals("root", s);
+		s = streamReader.getElementText();
+		assertEquals("Hello World", s);
+		streamReader.close();
+	}
+
+	@Test
+	public void readStAXSourceExternal() throws Exception {
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(bodyExternal.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		StAXSource result = (StAXSource) converter.read(StAXSource.class, inputMessage);
+		XMLStreamReader streamReader = result.getXMLStreamReader();
+		assertTrue(streamReader.hasNext());
+		streamReader.next();
+		streamReader.next();
+		String s = streamReader.getLocalName();
+		assertEquals("root", s);
+		s = streamReader.getElementText();
+		assertNotEquals("Foo Bar", s);
+		streamReader.close();
+	}
+
+
 	@Test
 	public void readStreamSource() throws Exception {
-		String body = "<root>Hello World</root>";
-		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(BODY.getBytes("UTF-8"));
 		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
 		StreamSource result = (StreamSource) converter.read(StreamSource.class, inputMessage);
 		String s = FileCopyUtils.copyToString(new InputStreamReader(result.getInputStream()));
-		assertXMLEqual("Invalid result", body, s);
+		assertXMLEqual("Invalid result", BODY, s);
 	}
 
 	@Test
 	public void readSource() throws Exception {
-		String body = "<root>Hello World</root>";
-		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(BODY.getBytes("UTF-8"));
 		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
 		converter.read(Source.class, inputMessage);
 	}
diff --git a/spring-web/src/test/resources/org/springframework/http/converter/xml/external.txt b/spring-web/src/test/resources/org/springframework/http/converter/xml/external.txt
new file mode 100644
index 000000000000..76c7ac2d0ce6
--- /dev/null
+++ b/spring-web/src/test/resources/org/springframework/http/converter/xml/external.txt
@@ -0,0 +1 @@
+Foo Bar",
"url": "https://github.com/spring-projects/spring-framework/commit/2ae6a6a3415eebc57babcb9d3e5505887eda6d8.patch"
},
{
"commit_message": "[PATCH] Disable ext entities in SourceHttpMessageConverter This change disables the processing of external entities in SourceHttpMessageConverter by default and provides an option to enable it if required. .../springframework/util/xml/StaxUtils.java | 15 +- .../xml/SourceHttpMessageConverter.java | 169 +++++++++++++----- .../xml/SourceHttpMessageConverterTests.java | 103 +++++++++-- .../http/converter/xml/external.txt | 1 + 4 files changed, 229 insertions(+), 59 deletions(-) create mode 100644 spring-web/src/test/resources/org/springframework/http/converter/xml/external.txt",
"patch_text_b64": "From 7387cb990e35b0f1b573faf29d4f9ae183d7a5ef Mon Sep 17 00:00:00 2001
From: Rossen Stoyanchev <rstoyanchev@gopivotal.com>
Date: Tue, 5 Nov 2013 09:02:46 -0500
Subject: [PATCH] Disable ext entities in SourceHttpMessageConverter

This change disables the processing of external entities in
SourceHttpMessageConverter by default and provides an option to enable
it if required.
---
 .../springframework/util/xml/StaxUtils.java   |  15 +-
 .../xml/SourceHttpMessageConverter.java       | 169 +++++++++++++-----
 .../xml/SourceHttpMessageConverterTests.java  | 103 +++++++++--
 .../http/converter/xml/external.txt           |   1 +
 4 files changed, 229 insertions(+), 59 deletions(-)
 create mode 100644 spring-web/src/test/resources/org/springframework/http/converter/xml/external.txt

diff --git a/spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java b/spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java
index efafa259d43c..41fd3f63dc91 100644
--- a/spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java
+++ b/spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java
@@ -111,7 +111,16 @@ public static Source createStaxSource(XMLEventReader eventReader) throws XMLStre
 	 * 1.4 {@link StAXSource}; {@code false} otherwise.
 	 */
 	public static boolean isStaxSource(Source source) {
-		return (source instanceof StaxSource || (jaxp14Available && Jaxp14StaxHandler.isStaxSource(source)));
+		return ((source instanceof StaxSource) || (jaxp14Available && Jaxp14StaxHandler.isStaxSource(source)));
+	}
+
+	/**
+	 * Indicate whether the given class is a StAX Source class.
+	 * @return {@code true} if {@code source} is a custom StAX source or JAXP
+	 * 1.4 {@link StAXSource} class; {@code false} otherwise.
+	 */
+	public static boolean isStaxSourceClass(Class<? extends Source> clazz) {
+		return (StaxSource.class.equals(clazz) || (jaxp14Available && Jaxp14StaxHandler.isStaxSourceClass(clazz)));
 	}
 
 
@@ -348,6 +357,10 @@ private static boolean isStaxSource(Source source) {
 			return (source instanceof StAXSource);
 		}
 
+		private static boolean isStaxSourceClass(Class<? extends Source> clazz) {
+            return StAXSource.class.equals(clazz);
+        }
+
 		private static boolean isStaxResult(Result result) {
 			return (result instanceof StAXResult);
 		}
diff --git a/spring-web/src/main/java/org/springframework/http/converter/xml/SourceHttpMessageConverter.java b/spring-web/src/main/java/org/springframework/http/converter/xml/SourceHttpMessageConverter.java
index e94950326322..15b7d8e781f9 100644
--- a/spring-web/src/main/java/org/springframework/http/converter/xml/SourceHttpMessageConverter.java
+++ b/spring-web/src/main/java/org/springframework/http/converter/xml/SourceHttpMessageConverter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,73 +19,147 @@
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.OutputStream;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
 import javax.xml.transform.Result;
 import javax.xml.transform.Source;
 import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.dom.DOMResult;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.sax.SAXSource;
 import javax.xml.transform.stream.StreamResult;
 import javax.xml.transform.stream.StreamSource;
 
+import org.w3c.dom.Document;
 import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.XMLReader;
+import org.xml.sax.helpers.XMLReaderFactory;
 
 import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpInputMessage;
+import org.springframework.http.HttpOutputMessage;
 import org.springframework.http.MediaType;
+import org.springframework.http.converter.AbstractHttpMessageConverter;
 import org.springframework.http.converter.HttpMessageConversionException;
 import org.springframework.http.converter.HttpMessageNotReadableException;
 import org.springframework.http.converter.HttpMessageNotWritableException;
+import org.springframework.util.StreamUtils;
+import org.springframework.util.xml.StaxUtils;
 
 /**
- * Implementation of {@link org.springframework.http.converter.HttpMessageConverter} that can read and write {@link
- * Source} objects.
+ * Implementation of {@link org.springframework.http.converter.HttpMessageConverter}
+ * that can read and write {@link Source} objects.
  *
  * @author Arjen Poutsma
  * @since 3.0
  */
-public class SourceHttpMessageConverter<T extends Source> extends AbstractXmlHttpMessageConverter<T> {
+public class SourceHttpMessageConverter<T extends Source> extends AbstractHttpMessageConverter<T> {
 
-	@Override
-	public boolean supports(Class<?> clazz) {
-		return DOMSource.class.equals(clazz) || SAXSource.class.equals(clazz) || StreamSource.class.equals(clazz) ||
-				Source.class.equals(clazz);
-	}
+    private final TransformerFactory transformerFactory = TransformerFactory.newInstance();
 
-	@Override
-	@SuppressWarnings("unchecked")
-	protected T readFromSource(Class clazz, HttpHeaders headers, Source source) throws IOException {
-		try {
-			if (DOMSource.class.equals(clazz)) {
-				DOMResult domResult = new DOMResult();
-				transform(source, domResult);
-				return (T) new DOMSource(domResult.getNode());
-			}
-			else if (SAXSource.class.equals(clazz)) {
-				ByteArrayInputStream bis = transformToByteArrayInputStream(source);
-				return (T) new SAXSource(new InputSource(bis));
-			}
-			else if (StreamSource.class.equals(clazz) || Source.class.equals(clazz)) {
-				ByteArrayInputStream bis = transformToByteArrayInputStream(source);
-				return (T) new StreamSource(bis);
-			}
-			else {
-				throw new HttpMessageConversionException("Could not read class [" + clazz +
-						"]. Only DOMSource, SAXSource, and StreamSource are supported.");
-			}
-		}
-		catch (TransformerException ex) {
-			throw new HttpMessageNotReadableException("Could not transform from [" + source + "] to [" + clazz + "]",
-					ex);
-		}
-	}
+    private boolean processExternalEntities = false;
+
+    /**
+     * Sets the {@link #setSupportedMediaTypes(java.util.List) supportedMediaTypes}
+     * to {@code text/xml} and {@code application/xml}, and {@code application/*-xml}.
+     */
+    public SourceHttpMessageConverter() {
+        super(MediaType.APPLICATION_XML, MediaType.TEXT_XML, new MediaType("application", "*+xml"));
+    }
+
+
+    /**
+     * Indicates whether external XML entities are processed when converting
+     * to a Source.
+     * <p>Default is {@code false}, meaning that external entities are not resolved.
+     */
+    public void setProcessExternalEntities(boolean processExternalEntities) {
+        this.processExternalEntities = processExternalEntities;
+    }
 
-	private ByteArrayInputStream transformToByteArrayInputStream(Source source) throws TransformerException {
-		ByteArrayOutputStream bos = new ByteArrayOutputStream();
-		transform(source, new StreamResult(bos));
-		return new ByteArrayInputStream(bos.toByteArray());
+    @Override
+	public boolean supports(Class<?> clazz) {
+		return DOMSource.class.equals(clazz) || SAXSource.class.equals(clazz)
+				|| StreamSource.class.equals(clazz) || Source.class.equals(clazz);
 	}
 
+    @Override
+    protected T readInternal(Class<? extends T> clazz, HttpInputMessage inputMessage)
+            throws IOException, HttpMessageNotReadableException {
+
+        InputStream body = inputMessage.getBody();
+        if (DOMSource.class.equals(clazz)) {
+            return (T) readDOMSource(body);
+        }
+        else if (StaxUtils.isStaxSourceClass(clazz)) {
+            return (T) readStAXSource(body);
+        }
+        else if (SAXSource.class.equals(clazz)) {
+            return (T) readSAXSource(body);
+        }
+        else if (StreamSource.class.equals(clazz) || Source.class.equals(clazz)) {
+            return (T) readStreamSource(body);
+        }
+        else {
+            throw new HttpMessageConversionException("Could not read class [" + clazz +
+                    "]. Only DOMSource, SAXSource, and StreamSource are supported.");
+        }
+    }
+
+    private DOMSource readDOMSource(InputStream body) throws IOException {
+        try {
+            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
+            documentBuilderFactory.setNamespaceAware(true);
+            documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", processExternalEntities);
+            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
+            Document document = documentBuilder.parse(body);
+            return new DOMSource(document);
+        }
+        catch (ParserConfigurationException ex) {
+            throw new HttpMessageNotReadableException("Could not set feature: " + ex.getMessage(), ex);
+        }
+        catch (SAXException ex) {
+            throw new HttpMessageNotReadableException("Could not parse document: " + ex.getMessage(), ex);
+        }
+    }
+
+    private SAXSource readSAXSource(InputStream body) throws IOException {
+        try {
+            XMLReader reader = XMLReaderFactory.createXMLReader();
+            reader.setFeature("http://xml.org/sax/features/external-general-entities", processExternalEntities);
+            byte[] bytes = StreamUtils.copyToByteArray(body);
+            return new SAXSource(reader, new InputSource(new ByteArrayInputStream(bytes)));
+        }
+        catch (SAXException ex) {
+            throw new HttpMessageNotReadableException("Could not parse document: " + ex.getMessage(), ex);
+        }
+    }
+
+    private Source readStAXSource(InputStream body) {
+        try {
+            XMLInputFactory inputFactory = XMLInputFactory.newFactory();
+            inputFactory.setProperty("javax.xml.stream.isSupportingExternalEntities", processExternalEntities);
+            XMLStreamReader streamReader = inputFactory.createXMLStreamReader(body);
+            return StaxUtils.createStaxSource(streamReader);
+        }
+        catch (XMLStreamException ex) {
+            throw new HttpMessageNotReadableException("Could not parse document: " + ex.getMessage(), ex);
+        }
+    }
+
+    private StreamSource readStreamSource(InputStream body) throws IOException {
+        byte[] bytes = StreamUtils.copyToByteArray(body);
+        return new StreamSource(new ByteArrayInputStream(bytes));
+    }
+
 	@Override
 	protected Long getContentLength(T t, MediaType contentType) {
 		if (t instanceof DOMSource) {
@@ -101,17 +175,24 @@ protected Long getContentLength(T t, MediaType contentType) {
 		return null;
 	}
 
-	@Override
-	protected void writeToResult(T t, HttpHeaders headers, Result result) throws IOException {
+    @Override
+    protected void writeInternal(T t, HttpOutputMessage outputMessage)
+            throws IOException, HttpMessageNotWritableException {
 		try {
+            Result result = new StreamResult(outputMessage.getBody());
 			transform(t, result);
 		}
 		catch (TransformerException ex) {
-			throw new HttpMessageNotWritableException("Could not transform [" + t + "] to [" + result + "]", ex);
+			throw new HttpMessageNotWritableException("Could not transform [" + t + "] to output message", ex);
 		}
 	}
 
-	private static class CountingOutputStream extends OutputStream {
+    private void transform(Source source, Result result) throws TransformerException {
+        this.transformerFactory.newTransformer().transform(source, result);
+    }
+
+
+    private static class CountingOutputStream extends OutputStream {
 
 		private long count = 0;
 
diff --git a/spring-web/src/test/java/org/springframework/http/converter/xml/SourceHttpMessageConverterTests.java b/spring-web/src/test/java/org/springframework/http/converter/xml/SourceHttpMessageConverterTests.java
index c34e202330d1..8d47c221d1cd 100644
--- a/spring-web/src/test/java/org/springframework/http/converter/xml/SourceHttpMessageConverterTests.java
+++ b/spring-web/src/test/java/org/springframework/http/converter/xml/SourceHttpMessageConverterTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,21 +17,29 @@
 package org.springframework.http.converter.xml;
 
 import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
+import static org.junit.Assert.assertNotEquals;
 
+import java.io.IOException;
+import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.StringReader;
 import java.nio.charset.Charset;
 
 import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
 import javax.xml.transform.Source;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.sax.SAXSource;
+import javax.xml.transform.stax.StAXSource;
 import javax.xml.transform.stream.StreamSource;
 
 import org.junit.Before;
 import org.junit.Test;
+
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
 import org.springframework.http.MediaType;
 import org.springframework.http.MockHttpInputMessage;
 import org.springframework.http.MockHttpOutputMessage;
@@ -39,17 +47,29 @@
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.XMLReader;
+import org.xml.sax.helpers.DefaultHandler;
 
 /**
  * @author Arjen Poutsma
  */
 public class SourceHttpMessageConverterTests {
 
+	private static final String BODY = "<root>Hello World</root>";
+
 	private SourceHttpMessageConverter<Source> converter;
 
+	private String bodyExternal;
+
 	@Before
-	public void setUp() {
+	public void setUp() throws IOException {
 		converter = new SourceHttpMessageConverter<Source>();
+		Resource external = new ClassPathResource("external.txt", getClass());
+
+		bodyExternal = "<!DOCTYPE root [" +
+				"  <!ELEMENT root ANY >\n" +
+				"  <!ENTITY ext SYSTEM \"" + external.getURI() + "\" >]><root>&ext;</root>";
 	}
 
 	@Test
@@ -67,39 +87,94 @@ public void canWrite() {
 
 	@Test
 	public void readDOMSource() throws Exception {
-		String body = "<root>Hello World</root>";
-		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(BODY.getBytes("UTF-8"));
 		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
 		DOMSource result = (DOMSource) converter.read(DOMSource.class, inputMessage);
 		Document document = (Document) result.getNode();
 		assertEquals("Invalid result", "root", document.getDocumentElement().getLocalName());
 	}
 
+	@Test
+	public void readDOMSourceExternal() throws Exception {
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(bodyExternal.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		DOMSource result = (DOMSource) converter.read(DOMSource.class, inputMessage);
+		Document document = (Document) result.getNode();
+		assertEquals("Invalid result", "root", document.getDocumentElement().getLocalName());
+		assertNotEquals("Invalid result", "Foo Bar", document.getDocumentElement().getTextContent());
+	}
+
 	@Test
 	public void readSAXSource() throws Exception {
-		String body = "<root>Hello World</root>";
-		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(BODY.getBytes("UTF-8"));
 		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
 		SAXSource result = (SAXSource) converter.read(SAXSource.class, inputMessage);
 		InputSource inputSource = result.getInputSource();
 		String s = FileCopyUtils.copyToString(new InputStreamReader(inputSource.getByteStream()));
-		assertXMLEqual("Invalid result", body, s);
+		assertXMLEqual("Invalid result", BODY, s);
+	}
+
+	@Test
+	public void readSAXSourceExternal() throws Exception {
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(bodyExternal.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		SAXSource result = (SAXSource) converter.read(SAXSource.class, inputMessage);
+		InputSource inputSource = result.getInputSource();
+		XMLReader reader = result.getXMLReader();
+		reader.setContentHandler(new DefaultHandler() {
+			@Override
+			public void characters(char[] ch, int start, int length) throws SAXException {
+				String s = new String(ch, start, length);
+				assertNotEquals("Invalid result", "Foo Bar", s);
+			}
+		});
+		reader.parse(inputSource);
 	}
 
+	@Test
+	public void readStAXSource() throws Exception {
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(BODY.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		StAXSource result = (StAXSource) converter.read(StAXSource.class, inputMessage);
+		XMLStreamReader streamReader = result.getXMLStreamReader();
+		assertTrue(streamReader.hasNext());
+		streamReader.nextTag();
+		String s = streamReader.getLocalName();
+		assertEquals("root", s);
+		s = streamReader.getElementText();
+		assertEquals("Hello World", s);
+		streamReader.close();
+	}
+
+	@Test
+	public void readStAXSourceExternal() throws Exception {
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(bodyExternal.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		StAXSource result = (StAXSource) converter.read(StAXSource.class, inputMessage);
+		XMLStreamReader streamReader = result.getXMLStreamReader();
+		assertTrue(streamReader.hasNext());
+		streamReader.next();
+		streamReader.next();
+		String s = streamReader.getLocalName();
+		assertEquals("root", s);
+		s = streamReader.getElementText();
+		assertNotEquals("Foo Bar", s);
+		streamReader.close();
+	}
+
+
 	@Test
 	public void readStreamSource() throws Exception {
-		String body = "<root>Hello World</root>";
-		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(BODY.getBytes("UTF-8"));
 		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
 		StreamSource result = (StreamSource) converter.read(StreamSource.class, inputMessage);
 		String s = FileCopyUtils.copyToString(new InputStreamReader(result.getInputStream()));
-		assertXMLEqual("Invalid result", body, s);
+		assertXMLEqual("Invalid result", BODY, s);
 	}
 
 	@Test
 	public void readSource() throws Exception {
-		String body = "<root>Hello World</root>";
-		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(BODY.getBytes("UTF-8"));
 		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
 		converter.read(Source.class, inputMessage);
 	}
diff --git a/spring-web/src/test/resources/org/springframework/http/converter/xml/external.txt b/spring-web/src/test/resources/org/springframework/http/converter/xml/external.txt
new file mode 100644
index 000000000000..76c7ac2d0ce6
--- /dev/null
+++ b/spring-web/src/test/resources/org/springframework/http/converter/xml/external.txt
@@ -0,0 +1 @@
+Foo Bar",
"url": "https://github.com/spring-projects/spring-framework/commit/7387cb990e35b0f1b573faf29d4f9ae183d7a5e.patch"
}
] | null |
GHSA-pw95-88fg-3j6f
|
Langroid Allows XXE Injection via XMLToolMessage
| null |
[
{
"commit_message": "[PATCH] fix: harden table_chat_agent (eval), xml_tool_message against sec vulnerabilities langroid/agent/special/table_chat_agent.py | 6 +- langroid/agent/xml_tool_message.py | 12 +- pyproject.toml | 2 +- uv.lock | 121 ++++++++++++++------- 4 files changed, 99 insertions(+), 42 deletions(-)",
"patch_text_b64": "From 36e7e7db4dd1636de225c2c66c84052b1e9ac3c3 Mon Sep 17 00:00:00 2001
From: Prasad Chalasani <pchalasani@gmail.com>
Date: Fri, 2 May 2025 21:22:36 -0400
Subject: [PATCH] fix: harden table_chat_agent (eval), xml_tool_message against
 sec vulnerabilities

---
 langroid/agent/special/table_chat_agent.py |   6 +-
 langroid/agent/xml_tool_message.py         |  12 +-
 pyproject.toml                             |   2 +-
 uv.lock                                    | 121 ++++++++++++++-------
 4 files changed, 99 insertions(+), 42 deletions(-)

diff --git a/langroid/agent/special/table_chat_agent.py b/langroid/agent/special/table_chat_agent.py
index 5f3ebf60b..f102e3624 100644
--- a/langroid/agent/special/table_chat_agent.py
+++ b/langroid/agent/special/table_chat_agent.py
@@ -211,9 +211,11 @@ def pandas_eval(self, msg: PandasEvalTool) -> str:
         # Temporarily redirect standard output to our string-based I/O stream
         sys.stdout = code_out
 
-        # Evaluate the last line and get the result
+        # Evaluate the last line and get the result;
+        # SECURITY: eval only with empty globals and {"df": df} in locals to
+        # prevent arbitrary Python code execution.
         try:
-            eval_result = pd.eval(exprn, local_dict=local_vars)
+            eval_result = eval(exprn, {}, local_vars)
         except Exception as e:
             eval_result = f"ERROR: {type(e)}: {e}"
 
diff --git a/langroid/agent/xml_tool_message.py b/langroid/agent/xml_tool_message.py
index a93da0847..dcc7b2807 100644
--- a/langroid/agent/xml_tool_message.py
+++ b/langroid/agent/xml_tool_message.py
@@ -49,7 +49,17 @@ def extract_field_values(cls, formatted_string: str) -> Optional[Dict[str, Any]]
         Raises:
             etree.XMLSyntaxError: If the input string is not valid XML.
         """
-        parser = etree.XMLParser(strip_cdata=False)
+        # SECURITY: Initialize XMLParser with flags to prevent 
+        # XML External Entity (XXE), billion laughs, and external DTD attacks by 
+        # disabling entity resolution, DTD loading, and network access;
+        # `strip_cdata=False` is needed to preserve
+        # content within CDATA sections (e.g., for code).        
+        parser = etree.XMLParser(
+            strip_cdata=False,
+            resolve_entities=False,
+            load_dtd=False,
+            no_network=True,
+        )
         root = etree.fromstring(formatted_string.encode("utf-8"), parser=parser)
 
         def parse_element(element: etree._Element) -> Any:
diff --git a/pyproject.toml b/pyproject.toml
index baf33d5c6..e81f06383 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,7 +30,7 @@ dependencies = [
     "halo<1.0.0,>=0.0.31",
     "jinja2<4.0.0,>=3.1.2",
     "json-repair<1.0.0,>=0.29.9",
-    "lxml<5.0.0,>=4.9.3",
+    "lxml<6.0.0,>=5.4.0",
     "markdownify>=0.13.1",
     "nest-asyncio<2.0.0,>=1.6.0",
     "nltk<4.0.0,>=3.8.2",
diff --git a/uv.lock b/uv.lock
index 1fd502457..cab565010 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2664,7 +2664,7 @@ name = "justext"
 version = "3.0.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "lxml" },
+    { name = "lxml", extra = ["html-clean"] },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b1/59/93ce612fce25c274efc88ec4d65963ce80fce96b9048e9fc1e430d893a9e/justext-3.0.1.tar.gz", hash = "sha256:b6ed2fb6c5d21618e2e34b2295c4edfc0bcece3bd549ed5c8ef5a8d20f0b3451", size = 828398 }
 wheels = [
@@ -3121,7 +3121,7 @@ requires-dist = [
     { name = "lancedb", marker = "extra == 'vecdbs'", specifier = ">=0.8.2,<0.9.0" },
     { name = "litellm", marker = "extra == 'all'", specifier = ">=1.30.1,<2.0.0" },
     { name = "litellm", marker = "extra == 'litellm'", specifier = ">=1.30.1,<2.0.0" },
-    { name = "lxml", specifier = ">=4.9.3,<5.0.0" },
+    { name = "lxml", specifier = ">=5.4.0,<6.0.0" },
     { name = "markdownify", specifier = ">=0.13.1" },
     { name = "marker-pdf", marker = "extra == 'all'" },
     { name = "marker-pdf", marker = "extra == 'doc-chat'" },
@@ -3362,39 +3362,84 @@ wheels = [
 
 [[package]]
 name = "lxml"
-version = "4.9.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/84/14/c2070b5e37c650198de8328467dd3d1681e80986f81ba0fea04fc4ec9883/lxml-4.9.4.tar.gz", hash = "sha256:b1541e50b78e15fa06a2670157a1962ef06591d4c998b998047fff5e3236880e", size = 3576664 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/50/e4/e37f7f61ceaf0b29e7c5bf78fb1927818a52c986546459d33ccd742f2b8e/lxml-4.9.4-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:056a17eaaf3da87a05523472ae84246f87ac2f29a53306466c22e60282e54ff8", size = 4772989 },
-    { url = "https://files.pythonhosted.org/packages/71/35/a8c656eac628ba9148852fdb17ae4b0ac217619aef6d25a15137ab4939f7/lxml-4.9.4-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:aaa5c173a26960fe67daa69aa93d6d6a1cd714a6eb13802d4e4bd1d24a530644", size = 7098896 },
-    { url = "https://files.pythonhosted.org/packages/a1/e8/665ea1d18f20a7c02d5561ea8500ded3148f3e9d8194efa2545e56fab059/lxml-4.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:647459b23594f370c1c01768edaa0ba0959afc39caeeb793b43158bb9bb6a663", size = 6698798 },
-    { url = "https://files.pythonhosted.org/packages/18/02/5e28cbbfff53d4e227114f507cb03d02973f0ba0e5ea3e11aea66fcfe471/lxml-4.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:bdd9abccd0927673cffe601d2c6cdad1c9321bf3437a2f507d6b037ef91ea307", size = 7028701 },
-    { url = "https://files.pythonhosted.org/packages/dd/3f/9bbd85d5baeae82b13f8e6b022f9bf34ffb5074f4f56d100854a5d66910d/lxml-4.9.4-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:00e91573183ad273e242db5585b52670eddf92bacad095ce25c1e682da14ed91", size = 7910358 },
-    { url = "https://files.pythonhosted.org/packages/c5/ab/39f7110584a0f8357cef9f3c92c98320d25efc6d51506b770cf9a5f1da6c/lxml-4.9.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:a602ed9bd2c7d85bd58592c28e101bd9ff9c718fbde06545a70945ffd5d11868", size = 7479236 },
-    { url = "https://files.pythonhosted.org/packages/9d/fd/16731c76b45117c9b9e0bc0ee3b6ffbf70d4d737549ce5fdc876e9e23064/lxml-4.9.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:de362ac8bc962408ad8fae28f3967ce1a262b5d63ab8cefb42662566737f1dc7", size = 7678948 },
-    { url = "https://files.pythonhosted.org/packages/04/93/0ef2a422606430217617c22d81459c99dba48cab114df7a5d460061a99eb/lxml-4.9.4-cp310-cp310-win32.whl", hash = "sha256:33714fcf5af4ff7e70a49731a7cc8fd9ce910b9ac194f66eaa18c3cc0a4c02be", size = 3463791 },
-    { url = "https://files.pythonhosted.org/packages/30/2a/58deecb3418027bfecdffe470c53b44adafaf8a3b4f59e2d41d061ff315e/lxml-4.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:d3caa09e613ece43ac292fbed513a4bce170681a447d25ffcbc1b647d45a39c5", size = 3784139 },
-    { url = "https://files.pythonhosted.org/packages/97/af/c008644e292aaf12f823c6a1a74bda427ab6a59e292f31ffe8614d752765/lxml-4.9.4-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:359a8b09d712df27849e0bcb62c6a3404e780b274b0b7e4c39a88826d1926c28", size = 8629333 },
-    { url = "https://files.pythonhosted.org/packages/85/a4/e0bc143506866e6f153210241bbb6fda445ae611aacdd7d4875cc8a1dae3/lxml-4.9.4-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:43498ea734ccdfb92e1886dfedaebeb81178a241d39a79d5351ba2b671bff2b2", size = 7166850 },
-    { url = "https://files.pythonhosted.org/packages/3b/6f/186bd26f9cb644970d120514467c50a5acfd9eb43437f64e5525951a8c93/lxml-4.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:4855161013dfb2b762e02b3f4d4a21cc7c6aec13c69e3bffbf5022b3e708dd97", size = 6761974 },
-    { url = "https://files.pythonhosted.org/packages/49/b9/7f9a881e7f46e95207c596732d2067f30fc49b7518637381630c39bb48d4/lxml-4.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:c71b5b860c5215fdbaa56f715bc218e45a98477f816b46cfde4a84d25b13274e", size = 7088938 },
-    { url = "https://files.pythonhosted.org/packages/85/95/60d86f2737f6f68554d2f1023fb8312c011a0960cf8aad0581e4a72cc11f/lxml-4.9.4-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9a2b5915c333e4364367140443b59f09feae42184459b913f0f41b9fed55794a", size = 7635991 },
-    { url = "https://files.pythonhosted.org/packages/be/2b/c240b9d4b1daf80573adbca0b6e3e3d69bb3838bebd9cb4c7d51ed315189/lxml-4.9.4-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:d82411dbf4d3127b6cde7da0f9373e37ad3a43e89ef374965465928f01c2b979", size = 7897968 },
-    { url = "https://files.pythonhosted.org/packages/98/0a/cf0fa269ebc015adb50119be2f02a327ce9e36e6cdb6a0f8dd1869198ee3/lxml-4.9.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:273473d34462ae6e97c0f4e517bd1bf9588aa67a1d47d93f760a1282640e24ac", size = 7500340 },
-    { url = "https://files.pythonhosted.org/packages/5e/54/7acd7c63796bffb89443729d95aaa6b8d81a79aa942f8fdd105f5a51bf13/lxml-4.9.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:389d2b2e543b27962990ab529ac6720c3dded588cc6d0f6557eec153305a3622", size = 7699448 },
-    { url = "https://files.pythonhosted.org/packages/57/74/b1b96f5bb47fae62b9a49a0df5f394f507f89cb55c4d534258924f4c0dc5/lxml-4.9.4-cp311-cp311-win32.whl", hash = "sha256:8aecb5a7f6f7f8fe9cac0bcadd39efaca8bbf8d1bf242e9f175cbe4c925116c3", size = 3455682 },
-    { url = "https://files.pythonhosted.org/packages/00/c3/0e6e18ac7fbf9687440c7d54fb2f39055d61ade32545ab305e7e3186be73/lxml-4.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:c7721a3ef41591341388bb2265395ce522aba52f969d33dacd822da8f018aff8", size = 3770258 },
-    { url = "https://files.pythonhosted.org/packages/5c/ac/0abe4b25cae50247c5130539d0f45a201dbfe0ba69d3dd844411f90c9930/lxml-4.9.4-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:dbcb2dc07308453db428a95a4d03259bd8caea97d7f0776842299f2d00c72fc8", size = 8624172 },
-    { url = "https://files.pythonhosted.org/packages/33/e6/47c4675f0c58398c924915379eee8458bf7954644a7907ad8fbc1c42a380/lxml-4.9.4-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:01bf1df1db327e748dcb152d17389cf6d0a8c5d533ef9bab781e9d5037619229", size = 7674086 },
-    { url = "https://files.pythonhosted.org/packages/be/9e/5d88b189e91fae65140dc29904946297b3d9cfdf5449d4bc6e657a3ffc2d/lxml-4.9.4-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e8f9f93a23634cfafbad6e46ad7d09e0f4a25a2400e4a64b1b7b7c0fbaa06d9d", size = 8026189 },
-    { url = "https://files.pythonhosted.org/packages/ea/08/ab6c2a803a5d5dce1fbbb32f5c133bbd0ebfe69476ab1eb5ffa3490b0b51/lxml-4.9.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3f3f00a9061605725df1816f5713d10cd94636347ed651abdbc75828df302b20", size = 7516933 },
-    { url = "https://files.pythonhosted.org/packages/43/52/b0d387577620af767c73b8b20f28986e5aad70b44053ee296f8a472a12b1/lxml-4.9.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:953dd5481bd6252bd480d6ec431f61d7d87fdcbbb71b0d2bdcfc6ae00bb6fb10", size = 7815609 },
-    { url = "https://files.pythonhosted.org/packages/be/13/18230c0d567ed282a3d7b61395323e2ef8fc9ad64096fdd3d1b384fa3e3c/lxml-4.9.4-cp312-cp312-win32.whl", hash = "sha256:266f655d1baff9c47b52f529b5f6bec33f66042f65f7c56adde3fcf2ed62ae8b", size = 3460500 },
-    { url = "https://files.pythonhosted.org/packages/5f/df/6d15cc415e04724ba4c141051cf43709e09bbcdd9868a6c2e7a7073ef498/lxml-4.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:f1faee2a831fe249e1bae9cbc68d3cd8a30f7e37851deee4d7962b17c410dd56", size = 3773977 },
-    { url = "https://files.pythonhosted.org/packages/f6/54/e7cc9b0019209fc553d5cb4cb460df25513754666665d5cd0f0ec19685ed/lxml-4.9.4-pp310-pypy310_pp73-macosx_11_0_x86_64.whl", hash = "sha256:f6c35b2f87c004270fa2e703b872fcc984d714d430b305145c39d53074e1ffe0", size = 4032797 },
-    { url = "https://files.pythonhosted.org/packages/60/8a/fc26540cc544a989277bdedeb098604ea7da998ebfd7bd0e94a3a936a817/lxml-4.9.4-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:606d445feeb0856c2b424405236a01c71af7c97e5fe42fbc778634faef2b47e4", size = 6337726 },
-    { url = "https://files.pythonhosted.org/packages/32/6e/8da1c75c1e3f4a92255ed48cc5ab9163c0d942dbfcea500409c670db173e/lxml-4.9.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a1bdcbebd4e13446a14de4dd1825f1e778e099f17f79718b4aeaf2403624b0f7", size = 3395151 },
+version = "5.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/3d/14e82fc7c8fb1b7761f7e748fd47e2ec8276d137b6acfe5a4bb73853e08f/lxml-5.4.0.tar.gz", hash = "sha256:d12832e1dbea4be280b22fd0ea7c9b87f0d8fc51ba06e92dc62d52f804f78ebd", size = 3679479 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f5/1f/a3b6b74a451ceb84b471caa75c934d2430a4d84395d38ef201d539f38cd1/lxml-5.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e7bc6df34d42322c5289e37e9971d6ed114e3776b45fa879f734bded9d1fea9c", size = 8076838 },
+    { url = "https://files.pythonhosted.org/packages/36/af/a567a55b3e47135b4d1f05a1118c24529104c003f95851374b3748139dc1/lxml-5.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6854f8bd8a1536f8a1d9a3655e6354faa6406621cf857dc27b681b69860645c7", size = 4381827 },
+    { url = "https://files.pythonhosted.org/packages/50/ba/4ee47d24c675932b3eb5b6de77d0f623c2db6dc466e7a1f199792c5e3e3a/lxml-5.4.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:696ea9e87442467819ac22394ca36cb3d01848dad1be6fac3fb612d3bd5a12cf", size = 5204098 },
+    { url = "https://files.pythonhosted.org/packages/f2/0f/b4db6dfebfefe3abafe360f42a3d471881687fd449a0b86b70f1f2683438/lxml-5.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ef80aeac414f33c24b3815ecd560cee272786c3adfa5f31316d8b349bfade28", size = 4930261 },
+    { url = "https://files.pythonhosted.org/packages/0b/1f/0bb1bae1ce056910f8db81c6aba80fec0e46c98d77c0f59298c70cd362a3/lxml-5.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b9c2754cef6963f3408ab381ea55f47dabc6f78f4b8ebb0f0b25cf1ac1f7609", size = 5529621 },
+    { url = "https://files.pythonhosted.org/packages/21/f5/e7b66a533fc4a1e7fa63dd22a1ab2ec4d10319b909211181e1ab3e539295/lxml-5.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7a62cc23d754bb449d63ff35334acc9f5c02e6dae830d78dab4dd12b78a524f4", size = 4983231 },
+    { url = "https://files.pythonhosted.org/packages/11/39/a38244b669c2d95a6a101a84d3c85ba921fea827e9e5483e93168bf1ccb2/lxml-5.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f82125bc7203c5ae8633a7d5d20bcfdff0ba33e436e4ab0abc026a53a8960b7", size = 5084279 },
+    { url = "https://files.pythonhosted.org/packages/db/64/48cac242347a09a07740d6cee7b7fd4663d5c1abd65f2e3c60420e231b27/lxml-5.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:b67319b4aef1a6c56576ff544b67a2a6fbd7eaee485b241cabf53115e8908b8f", size = 4927405 },
+    { url = "https://files.pythonhosted.org/packages/98/89/97442835fbb01d80b72374f9594fe44f01817d203fa056e9906128a5d896/lxml-5.4.0-cp310-cp310-manylinux_2_28_ppc64le.whl", hash = "sha256:a8ef956fce64c8551221f395ba21d0724fed6b9b6242ca4f2f7beb4ce2f41997", size = 5550169 },
+    { url = "https://files.pythonhosted.org/packages/f1/97/164ca398ee654eb21f29c6b582685c6c6b9d62d5213abc9b8380278e9c0a/lxml-5.4.0-cp310-cp310-manylinux_2_28_s390x.whl", hash = "sha256:0a01ce7d8479dce84fc03324e3b0c9c90b1ece9a9bb6a1b6c9025e7e4520e78c", size = 5062691 },
+    { url = "https://files.pythonhosted.org/packages/d0/bc/712b96823d7feb53482d2e4f59c090fb18ec7b0d0b476f353b3085893cda/lxml-5.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:91505d3ddebf268bb1588eb0f63821f738d20e1e7f05d3c647a5ca900288760b", size = 5133503 },
+    { url = "https://files.pythonhosted.org/packages/d4/55/a62a39e8f9da2a8b6002603475e3c57c870cd9c95fd4b94d4d9ac9036055/lxml-5.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a3bcdde35d82ff385f4ede021df801b5c4a5bcdfb61ea87caabcebfc4945dc1b", size = 4999346 },
+    { url = "https://files.pythonhosted.org/packages/ea/47/a393728ae001b92bb1a9e095e570bf71ec7f7fbae7688a4792222e56e5b9/lxml-5.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:aea7c06667b987787c7d1f5e1dfcd70419b711cdb47d6b4bb4ad4b76777a0563", size = 5627139 },
+    { url = "https://files.pythonhosted.org/packages/5e/5f/9dcaaad037c3e642a7ea64b479aa082968de46dd67a8293c541742b6c9db/lxml-5.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a7fb111eef4d05909b82152721a59c1b14d0f365e2be4c742a473c5d7372f4f5", size = 5465609 },
+    { url = "https://files.pythonhosted.org/packages/a7/0a/ebcae89edf27e61c45023005171d0ba95cb414ee41c045ae4caf1b8487fd/lxml-5.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:43d549b876ce64aa18b2328faff70f5877f8c6dede415f80a2f799d31644d776", size = 5192285 },
+    { url = "https://files.pythonhosted.org/packages/42/ad/cc8140ca99add7d85c92db8b2354638ed6d5cc0e917b21d36039cb15a238/lxml-5.4.0-cp310-cp310-win32.whl", hash = "sha256:75133890e40d229d6c5837b0312abbe5bac1c342452cf0e12523477cd3aa21e7", size = 3477507 },
+    { url = "https://files.pythonhosted.org/packages/e9/39/597ce090da1097d2aabd2f9ef42187a6c9c8546d67c419ce61b88b336c85/lxml-5.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:de5b4e1088523e2b6f730d0509a9a813355b7f5659d70eb4f319c76beea2e250", size = 3805104 },
+    { url = "https://files.pythonhosted.org/packages/81/2d/67693cc8a605a12e5975380d7ff83020dcc759351b5a066e1cced04f797b/lxml-5.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:98a3912194c079ef37e716ed228ae0dcb960992100461b704aea4e93af6b0bb9", size = 8083240 },
+    { url = "https://files.pythonhosted.org/packages/73/53/b5a05ab300a808b72e848efd152fe9c022c0181b0a70b8bca1199f1bed26/lxml-5.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0ea0252b51d296a75f6118ed0d8696888e7403408ad42345d7dfd0d1e93309a7", size = 4387685 },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/1a3879c5f512bdcd32995c301886fe082b2edd83c87d41b6d42d89b4ea4d/lxml-5.4.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b92b69441d1bd39f4940f9eadfa417a25862242ca2c396b406f9272ef09cdcaa", size = 4991164 },
+    { url = "https://files.pythonhosted.org/packages/f9/94/bbc66e42559f9d04857071e3b3d0c9abd88579367fd2588a4042f641f57e/lxml-5.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20e16c08254b9b6466526bc1828d9370ee6c0d60a4b64836bc3ac2917d1e16df", size = 4746206 },
+    { url = "https://files.pythonhosted.org/packages/66/95/34b0679bee435da2d7cae895731700e519a8dfcab499c21662ebe671603e/lxml-5.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7605c1c32c3d6e8c990dd28a0970a3cbbf1429d5b92279e37fda05fb0c92190e", size = 5342144 },
+    { url = "https://files.pythonhosted.org/packages/e0/5d/abfcc6ab2fa0be72b2ba938abdae1f7cad4c632f8d552683ea295d55adfb/lxml-5.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ecf4c4b83f1ab3d5a7ace10bafcb6f11df6156857a3c418244cef41ca9fa3e44", size = 4825124 },
+    { url = "https://files.pythonhosted.org/packages/5a/78/6bd33186c8863b36e084f294fc0a5e5eefe77af95f0663ef33809cc1c8aa/lxml-5.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0cef4feae82709eed352cd7e97ae062ef6ae9c7b5dbe3663f104cd2c0e8d94ba", size = 4876520 },
+    { url = "https://files.pythonhosted.org/packages/3b/74/4d7ad4839bd0fc64e3d12da74fc9a193febb0fae0ba6ebd5149d4c23176a/lxml-5.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:df53330a3bff250f10472ce96a9af28628ff1f4efc51ccba351a8820bca2a8ba", size = 4765016 },
+    { url = "https://files.pythonhosted.org/packages/24/0d/0a98ed1f2471911dadfc541003ac6dd6879fc87b15e1143743ca20f3e973/lxml-5.4.0-cp311-cp311-manylinux_2_28_ppc64le.whl", hash = "sha256:aefe1a7cb852fa61150fcb21a8c8fcea7b58c4cb11fbe59c97a0a4b31cae3c8c", size = 5362884 },
+    { url = "https://files.pythonhosted.org/packages/48/de/d4f7e4c39740a6610f0f6959052b547478107967362e8424e1163ec37ae8/lxml-5.4.0-cp311-cp311-manylinux_2_28_s390x.whl", hash = "sha256:ef5a7178fcc73b7d8c07229e89f8eb45b2908a9238eb90dcfc46571ccf0383b8", size = 4902690 },
+    { url = "https://files.pythonhosted.org/packages/07/8c/61763abd242af84f355ca4ef1ee096d3c1b7514819564cce70fd18c22e9a/lxml-5.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:d2ed1b3cb9ff1c10e6e8b00941bb2e5bb568b307bfc6b17dffbbe8be5eecba86", size = 4944418 },
+    { url = "https://files.pythonhosted.org/packages/f9/c5/6d7e3b63e7e282619193961a570c0a4c8a57fe820f07ca3fe2f6bd86608a/lxml-5.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:72ac9762a9f8ce74c9eed4a4e74306f2f18613a6b71fa065495a67ac227b3056", size = 4827092 },
+    { url = "https://files.pythonhosted.org/packages/71/4a/e60a306df54680b103348545706a98a7514a42c8b4fbfdcaa608567bb065/lxml-5.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f5cb182f6396706dc6cc1896dd02b1c889d644c081b0cdec38747573db88a7d7", size = 5418231 },
+    { url = "https://files.pythonhosted.org/packages/27/f2/9754aacd6016c930875854f08ac4b192a47fe19565f776a64004aa167521/lxml-5.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:3a3178b4873df8ef9457a4875703488eb1622632a9cee6d76464b60e90adbfcd", size = 5261798 },
+    { url = "https://files.pythonhosted.org/packages/38/a2/0c49ec6941428b1bd4f280650d7b11a0f91ace9db7de32eb7aa23bcb39ff/lxml-5.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e094ec83694b59d263802ed03a8384594fcce477ce484b0cbcd0008a211ca751", size = 4988195 },
+    { url = "https://files.pythonhosted.org/packages/7a/75/87a3963a08eafc46a86c1131c6e28a4de103ba30b5ae903114177352a3d7/lxml-5.4.0-cp311-cp311-win32.whl", hash = "sha256:4329422de653cdb2b72afa39b0aa04252fca9071550044904b2e7036d9d97fe4", size = 3474243 },
+    { url = "https://files.pythonhosted.org/packages/fa/f9/1f0964c4f6c2be861c50db380c554fb8befbea98c6404744ce243a3c87ef/lxml-5.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:fd3be6481ef54b8cfd0e1e953323b7aa9d9789b94842d0e5b142ef4bb7999539", size = 3815197 },
+    { url = "https://files.pythonhosted.org/packages/f8/4c/d101ace719ca6a4ec043eb516fcfcb1b396a9fccc4fcd9ef593df34ba0d5/lxml-5.4.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b5aff6f3e818e6bdbbb38e5967520f174b18f539c2b9de867b1e7fde6f8d95a4", size = 8127392 },
+    { url = "https://files.pythonhosted.org/packages/11/84/beddae0cec4dd9ddf46abf156f0af451c13019a0fa25d7445b655ba5ccb7/lxml-5.4.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942a5d73f739ad7c452bf739a62a0f83e2578afd6b8e5406308731f4ce78b16d", size = 4415103 },
+    { url = "https://files.pythonhosted.org/packages/d0/25/d0d93a4e763f0462cccd2b8a665bf1e4343dd788c76dcfefa289d46a38a9/lxml-5.4.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:460508a4b07364d6abf53acaa0a90b6d370fafde5693ef37602566613a9b0779", size = 5024224 },
+    { url = "https://files.pythonhosted.org/packages/31/ce/1df18fb8f7946e7f3388af378b1f34fcf253b94b9feedb2cec5969da8012/lxml-5.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:529024ab3a505fed78fe3cc5ddc079464e709f6c892733e3f5842007cec8ac6e", size = 4769913 },
+    { url = "https://files.pythonhosted.org/packages/4e/62/f4a6c60ae7c40d43657f552f3045df05118636be1165b906d3423790447f/lxml-5.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ca56ebc2c474e8f3d5761debfd9283b8b18c76c4fc0967b74aeafba1f5647f9", size = 5290441 },
+    { url = "https://files.pythonhosted.org/packages/9e/aa/04f00009e1e3a77838c7fc948f161b5d2d5de1136b2b81c712a263829ea4/lxml-5.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a81e1196f0a5b4167a8dafe3a66aa67c4addac1b22dc47947abd5d5c7a3f24b5", size = 4820165 },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/e0b2f61fa2404bf0f1fdf1898377e5bd1b74cc9b2cf2c6ba8509b8f27990/lxml-5.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00b8686694423ddae324cf614e1b9659c2edb754de617703c3d29ff568448df5", size = 4932580 },
+    { url = "https://files.pythonhosted.org/packages/24/a2/8263f351b4ffe0ed3e32ea7b7830f845c795349034f912f490180d88a877/lxml-5.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:c5681160758d3f6ac5b4fea370495c48aac0989d6a0f01bb9a72ad8ef5ab75c4", size = 4759493 },
+    { url = "https://files.pythonhosted.org/packages/05/00/41db052f279995c0e35c79d0f0fc9f8122d5b5e9630139c592a0b58c71b4/lxml-5.4.0-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:2dc191e60425ad70e75a68c9fd90ab284df64d9cd410ba8d2b641c0c45bc006e", size = 5324679 },
+    { url = "https://files.pythonhosted.org/packages/1d/be/ee99e6314cdef4587617d3b3b745f9356d9b7dd12a9663c5f3b5734b64ba/lxml-5.4.0-cp312-cp312-manylinux_2_28_s390x.whl", hash = "sha256:67f779374c6b9753ae0a0195a892a1c234ce8416e4448fe1e9f34746482070a7", size = 4890691 },
+    { url = "https://files.pythonhosted.org/packages/ad/36/239820114bf1d71f38f12208b9c58dec033cbcf80101cde006b9bde5cffd/lxml-5.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:79d5bfa9c1b455336f52343130b2067164040604e41f6dc4d8313867ed540079", size = 4955075 },
+    { url = "https://files.pythonhosted.org/packages/d4/e1/1b795cc0b174efc9e13dbd078a9ff79a58728a033142bc6d70a1ee8fc34d/lxml-5.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3d3c30ba1c9b48c68489dc1829a6eede9873f52edca1dda900066542528d6b20", size = 4838680 },
+    { url = "https://files.pythonhosted.org/packages/72/48/3c198455ca108cec5ae3662ae8acd7fd99476812fd712bb17f1b39a0b589/lxml-5.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1af80c6316ae68aded77e91cd9d80648f7dd40406cef73df841aa3c36f6907c8", size = 5391253 },
+    { url = "https://files.pythonhosted.org/packages/d6/10/5bf51858971c51ec96cfc13e800a9951f3fd501686f4c18d7d84fe2d6352/lxml-5.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4d885698f5019abe0de3d352caf9466d5de2baded00a06ef3f1216c1a58ae78f", size = 5261651 },
+    { url = "https://files.pythonhosted.org/packages/2b/11/06710dd809205377da380546f91d2ac94bad9ff735a72b64ec029f706c85/lxml-5.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea53d51859b6c64e7c51d522c03cc2c48b9b5d6172126854cc7f01aa11f52bc", size = 5024315 },
+    { url = "https://files.pythonhosted.org/packages/f5/b0/15b6217834b5e3a59ebf7f53125e08e318030e8cc0d7310355e6edac98ef/lxml-5.4.0-cp312-cp312-win32.whl", hash = "sha256:d90b729fd2732df28130c064aac9bb8aff14ba20baa4aee7bd0795ff1187545f", size = 3486149 },
+    { url = "https://files.pythonhosted.org/packages/91/1e/05ddcb57ad2f3069101611bd5f5084157d90861a2ef460bf42f45cced944/lxml-5.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1dc4ca99e89c335a7ed47d38964abcb36c5910790f9bd106f2a8fa2ee0b909d2", size = 3817095 },
+    { url = "https://files.pythonhosted.org/packages/c6/b0/e4d1cbb8c078bc4ae44de9c6a79fec4e2b4151b1b4d50af71d799e76b177/lxml-5.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1b717b00a71b901b4667226bba282dd462c42ccf618ade12f9ba3674e1fabc55", size = 3892319 },
+    { url = "https://files.pythonhosted.org/packages/5b/aa/e2bdefba40d815059bcb60b371a36fbfcce970a935370e1b367ba1cc8f74/lxml-5.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27a9ded0f0b52098ff89dd4c418325b987feed2ea5cc86e8860b0f844285d740", size = 4211614 },
+    { url = "https://files.pythonhosted.org/packages/3c/5f/91ff89d1e092e7cfdd8453a939436ac116db0a665e7f4be0cd8e65c7dc5a/lxml-5.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b7ce10634113651d6f383aa712a194179dcd496bd8c41e191cec2099fa09de5", size = 4306273 },
+    { url = "https://files.pythonhosted.org/packages/be/7c/8c3f15df2ca534589717bfd19d1e3482167801caedfa4d90a575facf68a6/lxml-5.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:53370c26500d22b45182f98847243efb518d268374a9570409d2e2276232fd37", size = 4208552 },
+    { url = "https://files.pythonhosted.org/packages/7d/d8/9567afb1665f64d73fc54eb904e418d1138d7f011ed00647121b4dd60b38/lxml-5.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c6364038c519dffdbe07e3cf42e6a7f8b90c275d4d1617a69bb59734c1a2d571", size = 4331091 },
+    { url = "https://files.pythonhosted.org/packages/f1/ab/fdbbd91d8d82bf1a723ba88ec3e3d76c022b53c391b0c13cad441cdb8f9e/lxml-5.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b12cb6527599808ada9eb2cd6e0e7d3d8f13fe7bbb01c6311255a15ded4c7ab4", size = 3487862 },
+]
+
+[package.optional-dependencies]
+html-clean = [
+    { name = "lxml-html-clean" },
+]
+
+[[package]]
+name = "lxml-html-clean"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lxml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/79/b6/466e71db127950fb8d172026a8f0a9f0dc6f64c8e78e2ca79f252e5790b8/lxml_html_clean-0.4.2.tar.gz", hash = "sha256:91291e7b5db95430abf461bc53440964d58e06cc468950f9e47db64976cebcb3", size = 21622 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4e/0b/942cb7278d6caad79343ad2ddd636ed204a47909b969d19114a3097f5aa3/lxml_html_clean-0.4.2-py3-none-any.whl", hash = "sha256:74ccfba277adcfea87a1e9294f47dd86b05d65b4da7c5b07966e3d5f3be8a505", size = 14184 },
 ]
 
 [[package]]
@@ -8141,7 +8186,7 @@ wheels = [
 
 [[package]]
 name = "trafilatura"
-version = "1.9.0"
+version = "1.12.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -8152,9 +8197,9 @@ dependencies = [
     { name = "lxml" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/27/1c/cc05eff2810c4cb3eb8df072a853900adf95b5d4b19f3a3221ddb86922e0/trafilatura-1.9.0.tar.gz", hash = "sha256:e6833d29ab8a13ed853937d7c91e6868bc62efbe10214ac2b106436dd23d1412", size = 3865087 }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/cd/77e4403b61d5da59063bb65ee894cf951c6f1137658499947adc040102f5/trafilatura-1.12.2.tar.gz", hash = "sha256:4c9cb1434f7e13ef0b16cb44ee1d44e84523ec7268940b9559c374e7effc9a96", size = 2987179 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1a/ec/95b4d4b79efc1953313f2c5192d51b4207aaa1acf4350abd6889092bcd74/trafilatura-1.9.0-py3-none-any.whl", hash = "sha256:8ea09de226c4eae25685f65b2cf56de47260d5c858ed3a8a0bc9c3ddd0841344", size = 1025921 },
+    { url = "https://files.pythonhosted.org/packages/79/14/d69c627444a7e93bee0425cd05e11a30dfb7a1b471e990ad0aafbb234307/trafilatura-1.12.2-py3-none-any.whl", hash = "sha256:6df5b666f625c9579a50d7cc715005f450fa75606696aceab73eeda0a76dbe96", size = 132246 },
 ]
 
 [[package]]",
"url": "https://github.com/langroid/langroid/commit/36e7e7db4dd1636de225c2c66c84052b1e9ac3c3.patch"
}
] | null |
GHSA-cp5v-2hmc-3vjx
|
WSO2 is vulnerable to Open Redirect through multi-option URL in its authentication endpoint
| null |
[
{
"commit_message": "[PATCH] Validate multiOptionURI parameter .../pom.xml | 6 ++ .../util/AuthenticationEndpointUtil.java | 76 +++++++++++++++++++ 2 files changed, 82 insertions(+)",
"patch_text_b64": "From 7de8d513c29f839a90f3d4b37d754b33ff193d86 Mon Sep 17 00:00:00 2001
From: Sachin-Mamoru <sachinm@wso2.com>
Date: Tue, 12 Mar 2024 21:48:32 +0530
Subject: [PATCH] Validate multiOptionURI parameter

---
 .../pom.xml                                   |  6 ++
 .../util/AuthenticationEndpointUtil.java      | 76 +++++++++++++++++++
 2 files changed, 82 insertions(+)

diff --git a/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/pom.xml b/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/pom.xml
index 9620c20df7e3..46dd3ca43cda 100644
--- a/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/pom.xml
+++ b/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/pom.xml
@@ -62,6 +62,11 @@
             <artifactId>org.wso2.carbon.identity.core</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.wso2.carbon.identity.framework</groupId>
+            <artifactId>org.wso2.carbon.identity.application.authentication.framework</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>org.wso2.carbon</groupId>
             <artifactId>org.wso2.carbon.utils</artifactId>
@@ -200,6 +205,7 @@
                             org.wso2.carbon.identity.user.registration.stub.*;version="${carbon.identity.package.import.version.range}",
                             org.apache.axis2.*;version="${axis2.osgi.version.range}",
                             org.wso2.carbon.identity.core.util;resolution:=optional;version="${carbon.identity.package.import.version.range}",
+                            org.wso2.carbon.identity.application.authentication.framework.config;version="${carbon.identity.package.import.version.range}",
                             org.wso2.carbon.identity.core.*; version="${carbon.identity.package.import.version.range}",
                             org.wso2.carbon.identity.base;resolution:=optional;version="${carbon.identity.package.import.version.range}",
                             org.wso2.carbon.user.core.*; version="${carbon.kernel.package.import.version.range}",
diff --git a/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/src/main/java/org/wso2/carbon/identity/application/authentication/endpoint/util/AuthenticationEndpointUtil.java b/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/src/main/java/org/wso2/carbon/identity/application/authentication/endpoint/util/AuthenticationEndpointUtil.java
index 2c1ea4622448..fa9fbed8c256 100644
--- a/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/src/main/java/org/wso2/carbon/identity/application/authentication/endpoint/util/AuthenticationEndpointUtil.java
+++ b/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/src/main/java/org/wso2/carbon/identity/application/authentication/endpoint/util/AuthenticationEndpointUtil.java
@@ -35,6 +35,7 @@
 import org.owasp.encoder.Encode;
 import org.wso2.carbon.context.PrivilegedCarbonContext;
 import org.wso2.carbon.identity.application.authentication.endpoint.util.bean.UserDTO;
+import org.wso2.carbon.identity.application.authentication.framework.config.ConfigurationFacade;
 import org.wso2.carbon.identity.core.ServiceURLBuilder;
 import org.wso2.carbon.identity.core.URLBuilderException;
 import org.wso2.carbon.identity.core.util.IdentityTenantUtil;
@@ -254,6 +255,25 @@ public static String getErrorCodeToi18nMapping(String errorCode, String subError
      */
     public static boolean isValidURL(String urlString) {
 
+        return validateURL(urlString);
+    }
+
+    /**
+     * This method is to validate a multiOptionURI. This will check whether the URL is a proper relative URL and
+     * if it is an absolute URL will validate the host of the URL.
+     * @param urlString URL String.
+     * @return true if valid URL, false otherwise.
+     */
+    public static boolean isValidMultiOptionURI(String urlString) {
+
+        if (validateURL(urlString)) {
+            return validateCallbackURL(urlString);
+        }
+        return false;
+    }
+
+    private static boolean validateURL(String urlString) {
+
         if (StringUtils.isBlank(urlString)) {
             String errorMsg = "Invalid URL.";
             if (log.isDebugEnabled()) {
@@ -281,6 +301,62 @@ public static boolean isValidURL(String urlString) {
         return true;
     }
 
+    private static boolean validateCallbackURL(String callbackURL) {
+
+        String authenticationEndpointURL = ConfigurationFacade.getInstance().getAuthenticationEndpointURL();
+        try {
+            if (isURLRelative(callbackURL)) {
+                /*
+                  If the multiOptionURI is a relative URL, then the URL should start with an alphanumeric character
+                  or a slash followed by an alphanumeric character.
+                 */
+                if (callbackURL.matches("^/?[a-zA-Z0-9].*")) {
+                    return true;
+                } else {
+                    log.error("No valid URL found for the multiOptionURI. URL: " + callbackURL + " is not allowed.");
+                    return false;
+                }
+            } else {
+                String multiOptionURIHostAndPort = getHostAndPort(callbackURL);
+                /*
+                  If the multiOptionURI is an absolute URL, then the host of the multiOptionURI should be
+                  either host of the server or host of the externalized authenticationEndpointURL.
+                 */
+                if (multiOptionURIHostAndPort.equals(getHostAndPort(buildAbsoluteURL("/"))) ||
+                        (!isURLRelative(authenticationEndpointURL) && multiOptionURIHostAndPort
+                                .equals(getHostAndPort(authenticationEndpointURL)))) {
+                    return true;
+                } else {
+                    log.error("No valid host found for the multiOptionURI. URL: " + multiOptionURIHostAndPort +
+                            " is not allowed.");
+                    return false;
+                }
+            }
+        } catch (MalformedURLException | URISyntaxException | URLBuilderException e) {
+            if (log.isDebugEnabled()) {
+                log.debug(e.getMessage(), e);
+            }
+            return false;
+        }
+    }
+
+    /**
+     * Extracts the host and port from a given URL string.
+     * If the URL does not specify a port, only the host is returned.
+     *
+     * @param urlString The URL from which to extract the host and port.
+     * @return A string containing the host and, if specified, the port.
+     * @throws MalformedURLException If the given string does not represent a valid URL.
+     */
+    private static String getHostAndPort(String urlString) throws MalformedURLException {
+
+        URL url = new URL(urlString);
+        String host = url.getHost();
+        int port = url.getPort(); // Returns -1 if the port is not explicitly specified in the URL.
+
+        return port == -1 ? host : host + ":" + port;
+    }
+
     private static boolean isURLRelative(String uriString) throws URISyntaxException {
 
         return !new URI(uriString).isAbsolute();",
"url": "https://github.com/wso2/carbon-identity-framework/commit/29ea34ada98649c4ae71aa92f1cbe87ce82164b9.patch"
},
{
"commit_message": "[PATCH] Validate multiOptionURI parameter .../pom.xml | 6 ++ .../util/AuthenticationEndpointUtil.java | 76 +++++++++++++++++++ 2 files changed, 82 insertions(+)",
"patch_text_b64": "From f18d70fa561595eca1f66e70ce67cd265923d1dc Mon Sep 17 00:00:00 2001
From: Sachin-Mamoru <sachinm@wso2.com>
Date: Tue, 12 Mar 2024 21:48:32 +0530
Subject: [PATCH] Validate multiOptionURI parameter

---
 .../pom.xml                                   |  6 ++
 .../util/AuthenticationEndpointUtil.java      | 76 +++++++++++++++++++
 2 files changed, 82 insertions(+)

diff --git a/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/pom.xml b/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/pom.xml
index 64538ac7190d..208449525bce 100644
--- a/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/pom.xml
+++ b/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/pom.xml
@@ -62,6 +62,11 @@
             <artifactId>org.wso2.carbon.identity.core</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.wso2.carbon.identity.framework</groupId>
+            <artifactId>org.wso2.carbon.identity.application.authentication.framework</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>org.wso2.carbon</groupId>
             <artifactId>org.wso2.carbon.utils</artifactId>
@@ -196,6 +201,7 @@
                             org.wso2.carbon.identity.user.registration.stub.*;version="${carbon.identity.package.import.version.range}",
                             org.apache.axis2.*;version="${axis2.osgi.version.range}",
                             org.wso2.carbon.identity.core.util;resolution:=optional;version="${carbon.identity.package.import.version.range}",
+                            org.wso2.carbon.identity.application.authentication.framework.config;version="${carbon.identity.package.import.version.range}",
                             org.wso2.carbon.identity.core.*; version="${carbon.identity.package.import.version.range}",
                             org.wso2.carbon.identity.base;resolution:=optional;version="${carbon.identity.package.import.version.range}",
                             org.wso2.carbon.user.core.*; version="${carbon.kernel.package.import.version.range}",
diff --git a/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/src/main/java/org/wso2/carbon/identity/application/authentication/endpoint/util/AuthenticationEndpointUtil.java b/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/src/main/java/org/wso2/carbon/identity/application/authentication/endpoint/util/AuthenticationEndpointUtil.java
index 62a24a264e1b..241eda2a4141 100644
--- a/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/src/main/java/org/wso2/carbon/identity/application/authentication/endpoint/util/AuthenticationEndpointUtil.java
+++ b/components/authentication-framework/org.wso2.carbon.identity.application.authentication.endpoint.util/src/main/java/org/wso2/carbon/identity/application/authentication/endpoint/util/AuthenticationEndpointUtil.java
@@ -35,6 +35,7 @@
 import org.owasp.encoder.Encode;
 import org.wso2.carbon.context.PrivilegedCarbonContext;
 import org.wso2.carbon.identity.application.authentication.endpoint.util.bean.UserDTO;
+import org.wso2.carbon.identity.application.authentication.framework.config.ConfigurationFacade;
 import org.wso2.carbon.identity.core.ServiceURLBuilder;
 import org.wso2.carbon.identity.core.URLBuilderException;
 import org.wso2.carbon.identity.core.util.IdentityTenantUtil;
@@ -340,6 +341,25 @@ public static String getErrorCodeToi18nMapping(String errorCode, String subError
      */
     public static boolean isValidURL(String urlString) {
 
+        return validateURL(urlString);
+    }
+
+    /**
+     * This method is to validate a multiOptionURI. This will check whether the URL is a proper relative URL and
+     * if it is an absolute URL will validate the host of the URL.
+     * @param urlString URL String.
+     * @return true if valid URL, false otherwise.
+     */
+    public static boolean isValidMultiOptionURI(String urlString) {
+
+        if (validateURL(urlString)) {
+            return validateCallbackURL(urlString);
+        }
+        return false;
+    }
+
+    private static boolean validateURL(String urlString) {
+
         if (StringUtils.isBlank(urlString)) {
             String errorMsg = "Invalid URL.";
             if (log.isDebugEnabled()) {
@@ -367,6 +387,62 @@ public static boolean isValidURL(String urlString) {
         return true;
     }
 
+    private static boolean validateCallbackURL(String callbackURL) {
+
+        String authenticationEndpointURL = ConfigurationFacade.getInstance().getAuthenticationEndpointURL();
+        try {
+            if (isURLRelative(callbackURL)) {
+                /*
+                  If the multiOptionURI is a relative URL, then the URL should start with an alphanumeric character
+                  or a slash followed by an alphanumeric character.
+                 */
+                if (callbackURL.matches("^/?[a-zA-Z0-9].*")) {
+                    return true;
+                } else {
+                    log.error("No valid URL found for the multiOptionURI. URL: " + callbackURL + " is not allowed.");
+                    return false;
+                }
+            } else {
+                String multiOptionURIHostAndPort = getHostAndPort(callbackURL);
+                /*
+                  If the multiOptionURI is an absolute URL, then the host of the multiOptionURI should be
+                  either host of the server or host of the externalized authenticationEndpointURL.
+                 */
+                if (multiOptionURIHostAndPort.equals(getHostAndPort(buildAbsoluteURL("/"))) ||
+                        (!isURLRelative(authenticationEndpointURL) && multiOptionURIHostAndPort
+                                .equals(getHostAndPort(authenticationEndpointURL)))) {
+                    return true;
+                } else {
+                    log.error("No valid host found for the multiOptionURI. URL: " + multiOptionURIHostAndPort +
+                            " is not allowed.");
+                    return false;
+                }
+            }
+        } catch (MalformedURLException | URISyntaxException | URLBuilderException e) {
+            if (log.isDebugEnabled()) {
+                log.debug(e.getMessage(), e);
+            }
+            return false;
+        }
+    }
+
+    /**
+     * Extracts the host and port from a given URL string.
+     * If the URL does not specify a port, only the host is returned.
+     *
+     * @param urlString The URL from which to extract the host and port.
+     * @return A string containing the host and, if specified, the port.
+     * @throws MalformedURLException If the given string does not represent a valid URL.
+     */
+    private static String getHostAndPort(String urlString) throws MalformedURLException {
+
+        URL url = new URL(urlString);
+        String host = url.getHost();
+        int port = url.getPort(); // Returns -1 if the port is not explicitly specified in the URL.
+
+        return port == -1 ? host : host + ":" + port;
+    }
+
     private static boolean isURLRelative(String uriString) throws URISyntaxException {
 
         return !new URI(uriString).isAbsolute();",
"url": "https://github.com/wso2/carbon-identity-framework/commit/7033924b6d53ff843529743b259f6c48f4e9c177.patch"
}
] | null |
CVE-2025-66545
|
Nextcloud Groupfolders users with read-only permissions for team folder can restore deleted files from trash bin
|
Nextcloud Groupfolders provides admin-configured folders shared by everyone in a group or team. Prior to 14.0.11, 15.3.12, 16.0.15, 17.0.14, 18.1.8, 19.1.8, and 20.1.2, a user with read-only permission can restore a file from the trash bin. This vulnerability is fixed in 14.0.11, 15.3.12, 16.0.15, 17.0.14, 18.1.8, 19.1.8, and 20.1.2.
|
[
{
"commit_message": "[PATCH] fix(trash): Restore from correct path Signed-off-by: provokateurin <[email protected]> lib/Trash/TrashBackend.php | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSAyMTU3NzdkOTRjODg2MjI4YTk3YjAzZjMyYTJhNTZlNWZmYTM0NTgzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBwcm92b2thdGV1cmluIDxrYXRlQHByb3Zva2F0ZXVyaW4uZGU+CkRhdGU6IFR1ZSwgMTQgT2N0IDIwMjUgMDg6MzI6NDIgKzAyMDAKU3ViamVjdDogW1BBVENIXSBmaXgodHJhc2gpOiBSZXN0b3JlIGZyb20gY29ycmVjdCBwYXRoCgpTaWduZWQtb2ZmLWJ5OiBwcm92b2thdGV1cmluIDxrYXRlQHByb3Zva2F0ZXVyaW4uZGU+Ci0tLQogbGliL1RyYXNoL1RyYXNoQmFja2VuZC5waHAgfCAyICstCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9saWIvVHJhc2gvVHJhc2hCYWNrZW5kLnBocCBiL2xpYi9UcmFzaC9UcmFzaEJhY2tlbmQucGhwCmluZGV4IGMwZTkxMmE3OS4uOGNjZGEyNmE3IDEwMDY0NAotLS0gYS9saWIvVHJhc2gvVHJhc2hCYWNrZW5kLnBocAorKysgYi9saWIvVHJhc2gvVHJhc2hCYWNrZW5kLnBocApAQCAtMTE4LDcgKzExOCw3IEBAIHB1YmxpYyBmdW5jdGlvbiByZXN0b3JlSXRlbShJVHJhc2hJdGVtICRpdGVtKTogdm9pZCB7CiAJCQl0aHJvdyBuZXcgTm90Rm91bmRFeGNlcHRpb24oKTsKIAkJfQogCi0JCWlmICghJHRoaXMtPnVzZXJIYXNBY2Nlc3NUb1BhdGgoJGl0ZW0tPmdldFVzZXIoKSwgJGl0ZW0tPmdldFBhdGgoKSwgQ29uc3RhbnRzOjpQRVJNSVNTSU9OX1VQREFURSkpIHsKKwkJaWYgKCEkdGhpcy0+dXNlckhhc0FjY2Vzc1RvUGF0aCgkaXRlbS0+Z2V0VXNlcigpLCAkdGhpcy0+Z2V0VW5KYWlsZWRQYXRoKCRub2RlKSwgQ29uc3RhbnRzOjpQRVJNSVNTSU9OX1VQREFURSkpIHsKIAkJCXRocm93IG5ldyBOb3RQZXJtaXR0ZWRFeGNlcHRpb24oKTsKIAkJfQ==",
"url": "https://github.com/nextcloud/groupfolders/commit/bbe87ebed8da23e9df4db637a76fbc8d36439d58.patch"
}
] |
CWE-707: Improper Neutralization
|
GHSA-85rq-hp8x-ghjq
|
Cross-Site Request Forgery in Jenkins Mailer Plugin
| null |
[
{
"commit_message": "[PATCH] [SECURITY-2163] src/main/java/hudson/tasks/Mailer.java | 4 +- .../hudson/tasks/Mailer/global.jelly | 2 +- src/test/java/hudson/tasks/MailerTest.java | 37 ++++++++++++++++++- 3 files changed, 39 insertions(+), 4 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/jenkinsci/mailer-plugin/commit/5e6051fae61a43564e22aa89cb24ed8a42a26052.patch"
}
] | null |
GHSA-3qhf-m339-9g5v
|
MCP Python SDK vulnerability in the FastMCP Server causes validation error, leading to DoS
| null |
[
{
"commit_message": "[PATCH] Fix uncaught exception in MCP server (#822) src/mcp/shared/session.py | 59 ++++++--- tests/issues/test_malformed_input.py | 172 +++++++++++++++++++++++++++ 2 files changed, 212 insertions(+), 19 deletions(-) create mode 100644 tests/issues/test_malformed_input.py",
"patch_text_b64": "From 29c69e6a47d0104d0afcea6ac35e7ab02fde809a Mon Sep 17 00:00:00 2001
From: David Dworken <david@daviddworken.com>
Date: Mon, 9 Jun 2025 17:03:15 -0700
Subject: [PATCH] Fix uncaught exception in MCP server (#822)

---
 src/mcp/shared/session.py            |  59 ++++++---
 tests/issues/test_malformed_input.py | 172 +++++++++++++++++++++++++++
 2 files changed, 212 insertions(+), 19 deletions(-)
 create mode 100644 tests/issues/test_malformed_input.py

diff --git a/src/mcp/shared/session.py b/src/mcp/shared/session.py
index 4b13709c67..c0345d6ab2 100644
--- a/src/mcp/shared/session.py
+++ b/src/mcp/shared/session.py
@@ -15,6 +15,7 @@
 from mcp.shared.message import MessageMetadata, ServerMessageMetadata, SessionMessage
 from mcp.types import (
     CONNECTION_CLOSED,
+    INVALID_PARAMS,
     CancelledNotification,
     ClientNotification,
     ClientRequest,
@@ -354,27 +355,47 @@ async def _receive_loop(self) -> None:
                 if isinstance(message, Exception):
                     await self._handle_incoming(message)
                 elif isinstance(message.message.root, JSONRPCRequest):
-                    validated_request = self._receive_request_type.model_validate(
-                        message.message.root.model_dump(
-                            by_alias=True, mode="json", exclude_none=True
+                    try:
+                        validated_request = self._receive_request_type.model_validate(
+                            message.message.root.model_dump(
+                                by_alias=True, mode="json", exclude_none=True
+                            )
                         )
-                    )
-                    responder = RequestResponder(
-                        request_id=message.message.root.id,
-                        request_meta=validated_request.root.params.meta
-                        if validated_request.root.params
-                        else None,
-                        request=validated_request,
-                        session=self,
-                        on_complete=lambda r: self._in_flight.pop(r.request_id, None),
-                        message_metadata=message.metadata,
-                    )
-
-                    self._in_flight[responder.request_id] = responder
-                    await self._received_request(responder)
+                        responder = RequestResponder(
+                            request_id=message.message.root.id,
+                            request_meta=validated_request.root.params.meta
+                            if validated_request.root.params
+                            else None,
+                            request=validated_request,
+                            session=self,
+                            on_complete=lambda r: self._in_flight.pop(
+                                r.request_id, None),
+                            message_metadata=message.metadata,
+                        )
+                        self._in_flight[responder.request_id] = responder
+                        await self._received_request(responder)
 
-                    if not responder._completed:  # type: ignore[reportPrivateUsage]
-                        await self._handle_incoming(responder)
+                        if not responder._completed:  # type: ignore[reportPrivateUsage]
+                            await self._handle_incoming(responder)
+                    except Exception as e:
+                        # For request validation errors, send a proper JSON-RPC error
+                        # response instead of crashing the server
+                        logging.warning(f"Failed to validate request: {e}")
+                        logging.debug(
+                            f"Message that failed validation: {message.message.root}"
+                        )
+                        error_response = JSONRPCError(
+                            jsonrpc="2.0",
+                            id=message.message.root.id,
+                            error=ErrorData(
+                                code=INVALID_PARAMS,
+                                message="Invalid request parameters",
+                                data="",
+                            ),
+                        )
+                        session_message = SessionMessage(
+                            message=JSONRPCMessage(error_response))
+                        await self._write_stream.send(session_message)
 
                 elif isinstance(message.message.root, JSONRPCNotification):
                     try:
diff --git a/tests/issues/test_malformed_input.py b/tests/issues/test_malformed_input.py
new file mode 100644
index 0000000000..e4fda9e136
--- /dev/null
+++ b/tests/issues/test_malformed_input.py
@@ -0,0 +1,172 @@
+# Claude Debug  
+"""Test for HackerOne vulnerability report #3156202 - malformed input DOS."""
+
+import anyio
+import pytest
+
+from mcp.server.models import InitializationOptions
+from mcp.server.session import ServerSession
+from mcp.shared.message import SessionMessage
+from mcp.types import (
+    INVALID_PARAMS,
+    JSONRPCError,
+    JSONRPCMessage,
+    JSONRPCRequest,
+    ServerCapabilities,
+)
+
+
+@pytest.mark.anyio
+async def test_malformed_initialize_request_does_not_crash_server():
+    """
+    Test that malformed initialize requests return proper error responses
+    instead of crashing the server (HackerOne #3156202).
+    """
+    # Create in-memory streams for testing
+    read_send_stream, read_receive_stream = anyio.create_memory_object_stream[
+        SessionMessage | Exception
+    ](10)
+    write_send_stream, write_receive_stream = anyio.create_memory_object_stream[
+        SessionMessage
+    ](10)
+
+    try:
+        # Create a malformed initialize request (missing required params field)
+        malformed_request = JSONRPCRequest(
+            jsonrpc="2.0",
+            id="f20fe86132ed4cd197f89a7134de5685",
+            method="initialize",
+            # params=None  # Missing required params field
+        )
+        
+        # Wrap in session message
+        request_message = SessionMessage(message=JSONRPCMessage(malformed_request))
+
+        # Start a server session
+        async with ServerSession(
+            read_stream=read_receive_stream,
+            write_stream=write_send_stream,
+            init_options=InitializationOptions(
+                server_name="test_server",
+                server_version="1.0.0",
+                capabilities=ServerCapabilities(),
+            ),
+        ):
+            # Send the malformed request
+            await read_send_stream.send(request_message)
+            
+            # Give the session time to process the request
+            await anyio.sleep(0.1)
+            
+            # Check that we received an error response instead of a crash
+            try:
+                response_message = write_receive_stream.receive_nowait()
+                response = response_message.message.root
+                
+                # Verify it's a proper JSON-RPC error response
+                assert isinstance(response, JSONRPCError)
+                assert response.jsonrpc == "2.0"
+                assert response.id == "f20fe86132ed4cd197f89a7134de5685"
+                assert response.error.code == INVALID_PARAMS
+                assert "Invalid request parameters" in response.error.message
+                
+                # Verify the session is still alive and can handle more requests
+                # Send another malformed request to confirm server stability
+                another_malformed_request = JSONRPCRequest(
+                    jsonrpc="2.0",
+                    id="test_id_2",
+                    method="tools/call",
+                    # params=None  # Missing required params
+                )
+                another_request_message = SessionMessage(
+                    message=JSONRPCMessage(another_malformed_request)
+                )
+                
+                await read_send_stream.send(another_request_message)
+                await anyio.sleep(0.1)
+                
+                # Should get another error response, not a crash
+                second_response_message = write_receive_stream.receive_nowait()
+                second_response = second_response_message.message.root
+                
+                assert isinstance(second_response, JSONRPCError)
+                assert second_response.id == "test_id_2"
+                assert second_response.error.code == INVALID_PARAMS
+                
+            except anyio.WouldBlock:
+                pytest.fail("No response received - server likely crashed")
+    finally:
+        # Close all streams to ensure proper cleanup
+        await read_send_stream.aclose()
+        await write_send_stream.aclose()
+        await read_receive_stream.aclose()
+        await write_receive_stream.aclose()
+
+
+@pytest.mark.anyio
+async def test_multiple_concurrent_malformed_requests():
+    """
+    Test that multiple concurrent malformed requests don't crash the server.
+    """
+    # Create in-memory streams for testing
+    read_send_stream, read_receive_stream = anyio.create_memory_object_stream[
+        SessionMessage | Exception
+    ](100)
+    write_send_stream, write_receive_stream = anyio.create_memory_object_stream[
+        SessionMessage
+    ](100)
+
+    try:
+        # Start a server session
+        async with ServerSession(
+            read_stream=read_receive_stream,
+            write_stream=write_send_stream,
+            init_options=InitializationOptions(
+                server_name="test_server",
+                server_version="1.0.0",
+                capabilities=ServerCapabilities(),
+            ),
+        ):
+            # Send multiple malformed requests concurrently
+            malformed_requests = []
+            for i in range(10):
+                malformed_request = JSONRPCRequest(
+                    jsonrpc="2.0",
+                    id=f"malformed_{i}",
+                    method="initialize",
+                    # params=None  # Missing required params
+                )
+                request_message = SessionMessage(
+                    message=JSONRPCMessage(malformed_request)
+                )
+                malformed_requests.append(request_message)
+            
+            # Send all requests
+            for request in malformed_requests:
+                await read_send_stream.send(request)
+            
+            # Give time to process
+            await anyio.sleep(0.2)
+            
+            # Verify we get error responses for all requests
+            error_responses = []
+            try:
+                while True:
+                    response_message = write_receive_stream.receive_nowait()
+                    error_responses.append(response_message.message.root)
+            except anyio.WouldBlock:
+                pass  # No more messages
+            
+            # Should have received 10 error responses
+            assert len(error_responses) == 10
+            
+            for i, response in enumerate(error_responses):
+                assert isinstance(response, JSONRPCError)
+                assert response.id == f"malformed_{i}"
+                assert response.error.code == INVALID_PARAMS
+    finally:
+        # Close all streams to ensure proper cleanup
+        await read_send_stream.aclose()
+        await write_send_stream.aclose()
+        await read_receive_stream.aclose()
+        await write_receive_stream.aclose()
\ No newline at end of file",
"url": "https://github.com/modelcontextprotocol/python-sdk/commit/29c69e6a47d0104d0afcea6ac35e7ab02fde809a.patch"
}
] | null |
CVE-2023-37265
|
Incorrect identification of source IP addresses in CasaOS
|
CasaOS is an open-source Personal Cloud system. Due to a lack of IP address verification an unauthenticated attackers can execute arbitrary commands as `root` on CasaOS instances. The problem was addressed by improving the detection of client IP addresses in `391dd7f`. 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] Merge pull request from GHSA-vjh7-5r6x-xh6g * fix:Incorrect identification of source IP addresses * feat: support reverse proxy * stash * stash * fix: the bug * fix: the bug * fix: the bug * fix: the bug * delete unused comment * refacotr the proccess * add comment to notice user to config correct proxy setting * fix:some problems * refactor the ip * Update gateway_route.go route/gateway_route.go | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/IceWhaleTech/CasaOS-Gateway/commit/391dd7f0f239020c46bf057cfa25f82031fc15f7.patch"
}
] |
CWE-306: Missing Authentication for Critical Function
|
CVE-2019-20913
|
An issue was discovered in GNU LibreDWG through 0.9.3. Crafted input will lead to a heap-based buffer over-read in dwg_encode_entity in common_entity_data.spec.
|
[
{
"commit_message": "[PATCH] add DEBUGGING_CLASS_CPP and use it for TABLECONTENT. This is more stable than CLASS_DXF in cases when TABLE is mixed up with TABLECONTENT. See e.g. GH #178, where it fixes the heap_overflow2 case. src/classes.inc | 26 +++++++++++++++++--------- src/dec_macros.h | 4 ++-- 2 files changed, 19 insertions(+), 11 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/LibreDWG/libredwg/commit/3f503dd294efc63a59608d8a16058c41d44ba13a.patch"
}
] |
n/a
|
|
GHSA-w4fh-p39j-749c
| null |
[
{
"commit_message": "[PATCH] fix: hide user data from comments module server/src/entities/comment.entity.ts | 2 +- server/src/services/comment.service.ts | 44 +++++++++++++++----------- 2 files changed, 27 insertions(+), 19 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/tooljet/tooljet/commit/45e0d3302d92df7d7f2d609c31cea71165600b79.patch"
}
] | null |
|
GHSA-c7pp-g2v2-2766
|
DOM-based XSS in gmail-js
| null |
[
{
"commit_message": "[PATCH] Replace new Function() with JSON.parse() src/gmail.js | 23 ++++++++--------------- 1 file changed, 8 insertions(+), 15 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/KartikTalwar/gmail.js/commit/a83436f499f9c01b04280af945a5a81137b6baf1.patch"
}
] | null |
CVE-2025-52435
|
Apache Mynewt NimBLE: Invalid error handling in pause encryption procedure in NimBLE controller
|
J2EE Misconfiguration: Data Transmission Without Encryption vulnerability in Apache NimBLE.
Improper handling of Pause Encryption procedure on Link Layer results in a previously encrypted connection being left in un-encrypted state allowing an eavesdropper to observe the remainder of the exchange.
This issue affects Apache NimBLE: through <= 1.8.0.
Users are recommended to upgrade to version 1.9.0, which fixes the issue.
|
[
{
"commit_message": "[PATCH] nimble/ll: Restrict allowed LL Control PDUs received This restricts allowed Control PDUs that can be received in specific encryption state. .../include/controller/ble_ll_ctrl.h | 3 +- nimble/controller/src/ble_ll_conn.c | 2 +- nimble/controller/src/ble_ll_ctrl.c | 46 ++++++++++++++++++- 3 files changed, 47 insertions(+), 4 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/mynewt-nimble/commit/164f1c23c18a290908df76ed83fe848bfe4a4903.patch"
},
{
"commit_message": "[PATCH] nimble/ll: Disconnect the link on LTK negative reply As per Core 6.1 | Vol 6, Part B | 5.1.3.1 Encryption Start proc If this procedure is being performed after a Pause Encryption procedure, and the Peripheral's Host does not provide a Long Term Key, the Peripheral shall perform the ACL Termination procedure with the error code PIN or Key Missing (0x06). .../controller/include/controller/ble_ll_conn.h | 1 + nimble/controller/src/ble_ll_conn.c | 16 +++++++++++++--- nimble/controller/src/ble_ll_conn_hci.c | 16 +++++++++++++--- nimble/controller/src/ble_ll_ctrl.c | 4 ++++ 4 files changed, 31 insertions(+), 6 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/apache/mynewt-nimble/commit/ec3d75e909fa6dcadf1836fefc4432794a673d18.patch"
}
] |
CWE-5 J2EE Misconfiguration: Data Transmission Without Encryption
|
GHSA-f554-x222-wgf7
|
Command Injection in Xstream
| null |
[
{
"commit_message": "[PATCH] Merge security framework from HEAD into branch. git-svn-id: http://svn.codehaus.org/xstream/branches/v-1.4.x@2219 9830eeb5-ddf4-0310-9ef7-f4b9a3e3227e xstream-distribution/src/content/changes.html | 6 + xstream-distribution/src/content/faq.html | 5 +- .../src/content/security.html | 207 ++++++++++++++++++ xstream-distribution/src/content/website.xml | 1 + .../HibernateProxyTypePermission.java | 37 ++++ .../com/thoughtworks/xstream/XStream.java | 148 ++++++++++++- .../xstream/mapper/CachingMapper.java | 9 +- .../xstream/mapper/SecurityMapper.java | 77 +++++++ .../xstream/security/AnyTypePermission.java | 32 +++ .../xstream/security/ArrayTypePermission.java | 32 +++ .../security/CGLIBProxyTypePermission.java | 35 +++ .../security/ExplicitTypePermission.java | 37 ++++ .../security/ForbiddenClassException.java | 27 +++ .../xstream/security/NoPermission.java | 39 ++++ .../xstream/security/NoTypePermission.java | 36 +++ .../xstream/security/NullPermission.java | 26 +++ .../security/PrimitiveTypePermission.java | 34 +++ .../xstream/security/ProxyTypePermission.java | 35 +++ .../security/RegExpTypePermission.java | 48 ++++ .../xstream/security/TypePermission.java | 25 +++ .../security/WildcardTypePermission.java | 84 +++++++ .../xstream/mapper/SecurityMapperTest.java | 207 ++++++++++++++++++ 22 files changed, 1181 insertions(+), 6 deletions(-) create mode 100644 xstream-distribution/src/content/security.html create mode 100644 xstream-hibernate/src/java/com/thoughtworks/xstream/hibernate/security/HibernateProxyTypePermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/mapper/SecurityMapper.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/AnyTypePermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/ArrayTypePermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/CGLIBProxyTypePermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/ExplicitTypePermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/ForbiddenClassException.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/NoPermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/NoTypePermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/NullPermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/PrimitiveTypePermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/ProxyTypePermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/RegExpTypePermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/TypePermission.java create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/WildcardTypePermission.java create mode 100644 xstream/src/test/com/thoughtworks/xstream/mapper/SecurityMapperTest.java",
"patch_text_b64": "From 6344867dce6767af7d0fe34fb393271a6456672d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Schaible?= <joerg.schaible@gmx.de>
Date: Wed, 22 Jan 2014 18:29:40 +0000
Subject: [PATCH] Merge security framework from HEAD into branch.

git-svn-id: http://svn.codehaus.org/xstream/branches/v-1.4.x@2219 9830eeb5-ddf4-0310-9ef7-f4b9a3e3227e
---
 xstream-distribution/src/content/changes.html |   6 +
 xstream-distribution/src/content/faq.html     |   5 +-
 .../src/content/security.html                 | 207 ++++++++++++++++++
 xstream-distribution/src/content/website.xml  |   1 +
 .../HibernateProxyTypePermission.java         |  37 ++++
 .../com/thoughtworks/xstream/XStream.java     | 148 ++++++++++++-
 .../xstream/mapper/CachingMapper.java         |   9 +-
 .../xstream/mapper/SecurityMapper.java        |  77 +++++++
 .../xstream/security/AnyTypePermission.java   |  32 +++
 .../xstream/security/ArrayTypePermission.java |  32 +++
 .../security/CGLIBProxyTypePermission.java    |  35 +++
 .../security/ExplicitTypePermission.java      |  37 ++++
 .../security/ForbiddenClassException.java     |  27 +++
 .../xstream/security/NoPermission.java        |  39 ++++
 .../xstream/security/NoTypePermission.java    |  36 +++
 .../xstream/security/NullPermission.java      |  26 +++
 .../security/PrimitiveTypePermission.java     |  34 +++
 .../xstream/security/ProxyTypePermission.java |  35 +++
 .../security/RegExpTypePermission.java        |  48 ++++
 .../xstream/security/TypePermission.java      |  25 +++
 .../security/WildcardTypePermission.java      |  84 +++++++
 .../xstream/mapper/SecurityMapperTest.java    | 207 ++++++++++++++++++
 22 files changed, 1181 insertions(+), 6 deletions(-)
 create mode 100644 xstream-distribution/src/content/security.html
 create mode 100644 xstream-hibernate/src/java/com/thoughtworks/xstream/hibernate/security/HibernateProxyTypePermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/mapper/SecurityMapper.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/AnyTypePermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/ArrayTypePermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/CGLIBProxyTypePermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/ExplicitTypePermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/ForbiddenClassException.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/NoPermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/NoTypePermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/NullPermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/PrimitiveTypePermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/ProxyTypePermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/RegExpTypePermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/TypePermission.java
 create mode 100644 xstream/src/java/com/thoughtworks/xstream/security/WildcardTypePermission.java
 create mode 100644 xstream/src/test/com/thoughtworks/xstream/mapper/SecurityMapperTest.java

diff --git a/xstream-distribution/src/content/changes.html b/xstream-distribution/src/content/changes.html
index 4147f92f5..bb64a293b 100644
--- a/xstream-distribution/src/content/changes.html
+++ b/xstream-distribution/src/content/changes.html
@@ -35,6 +35,7 @@ <h1 id="upcoming">Upcoming</h1>
     <h2>Major changes</h2>
     
     <ul>
+   		<li>Add security framework to limit handled types while unmarshalling.</li>
    		<li>java.bean.EventHandler no longer handled automatically because of severe security vulnerability.</li>
     	<li>JIRA:XSTR-751: New SunLimitedUnsafeReflectionProvider that uses undocumented features only to allocate new
     	instances as required on Dalvik.</li>
@@ -54,6 +55,11 @@ <h2>Minor changes</h2>
     <h2>API changes</h2>
 
     <ul>
+    	<li>Added package c.t.x.security with interface TypePermission, all its implementations and
+    	ForbiddenClassException.</li>
+    	<li>Added c.t.x.mapper.SecurityMapper handling the new type permissions.</li>
+    	<li>Added methods addPermission, denyPermission, allowTypesXXX and denyTypesXXX to c.t.x.XStream to setup
+    	security at unmarshalling time.</li>
     	<li>Added c.t.x.converters.reflection.SunLimitedUnsafeReflectionProvider.</li>
     	<li>Deprecated c.t.x.converters.reflection.Sun14ReflectionProvider in favor of new
     	c.t.x.converters.reflection.SunUnsafeReflectionProvider.</li>
diff --git a/xstream-distribution/src/content/faq.html b/xstream-distribution/src/content/faq.html
index d3f462f55..7aade4ed0 100644
--- a/xstream-distribution/src/content/faq.html
+++ b/xstream-distribution/src/content/faq.html
@@ -56,8 +56,9 @@ <h2 id="Compatibility_enhanced_mode_jvm">Which JVMs allow XStream to operate in
     undocumented internal Java runtime classes. This enhanced mode is known to be working on the Oracle/Sun, Apple, HP,
     IBM and Blackdown 1.4 JVMs and onwards, for IcedTea 6 and onwards, for Hitachi, SAP and Diablo from 1.5 and
     onwards, for BEA JRockit starting with R25.1.0. Generally it works for all modern Java runtimes based on OpenJDK.
-    Android basically supports the enhanced mode, but its security model limits the types that can be handled. Note,
-    that an active SecurityManager might prevent the usage of the enhanced mode also.</p>
+    Android basically supports the enhanced mode as well as the Google ApplicationEngine, but the latter's security
+    model limits the types that can be handled. Note, that an active SecurityManager might prevent the usage of the
+    enhanced mode also.</p>
 
     <!-- ...................................................... -->
     <h2 id="Compatibility_enhanced_mode_advantage">What are the advantages of using enhanced mode over pure Java mode?</h2>
diff --git a/xstream-distribution/src/content/security.html b/xstream-distribution/src/content/security.html
new file mode 100644
index 000000000..8fc6118f7
--- /dev/null
+++ b/xstream-distribution/src/content/security.html
@@ -0,0 +1,207 @@
+<html>
+<!--
+ Copyright (C) 2014 XStream committers.
+ All rights reserved.
+ 
+ The software in this package is published under the terms of the BSD
+ style license a copy of which has been included with this distribution in
+ the LICENSE.txt file.
+ 
+ Created on 09. January 2014 by Joerg Schaible
+ -->
+  <head>
+    <title>Security</title>
+  </head>
+
+  <body>
+    <h1 id="intro">Introduction</h1>
+    
+    <p>XStream is designed as a library, that is easy to use. It takes its main task very serious to convert from Java
+     objects to XML and back.  As result it is possible that you create an instance of XStream with the default
+     constructor, call a method to turn an object into XML and call another one to turn the XML back into an equal Java
+     object.  There are not a lot limits for those objects, XStream can handle nearly all.</p>
+     
+     <p>This flexibility comes at a price.  XStream is using aggressive code internally like undocumented Java
+     features and reflection to be able to handle all kind of unknown types.  The XML output contains by default any
+     information required to rebuild all these types.  Regarding security we have now two different aspects:</p>
+     
+     <ol>
+     <li>a Java runtime can have security constraints (typically by an active SecurityManager) that prevents partly the
+     execution of such aggressive code</li>
+     <li>the input data (XML) can be manipulated to inject objects into the unmarshalled object graph that where not
+     present at marshalling time and that might be used to execute code or even shell commands (CVE-2013-7285).</li>
+     </ol>
+
+     <p>Always remember that manipulation of input data might happen on different levels, e.g. manipulation the value
+     of objects (e.g. exchanging a price value) or breaking the format causing the XML parser to fail.  The latter
+     raises at least an error condition while the former must be catched with validity checks in case of sensitive
+     data.  Even worse is an unrecognized injection resulting in a modified application execution with the worst case
+     of arbitrary command execution.</p>
+     
+    <h2 id="external">External Security</h2>
+
+	<p>An active SecurityManager can prevent actions required by XStream components or converters.  Same applies for
+	an environment like Google Application Engine.  XStream tries to some extend to check the functionality of a
+	converter before it claims to handle a type.</p>
+	
+	<p>Therefore it is possible that XStream behaves different in such an environment, because a converter suddenly no
+	longer handles a special type or any type at all.  It is essential that an application that will have to run in such an environment is
+	tested at an early stage to prevent nasty surprises.</p>
+      
+    <h2 id="implicit">Implicit Security</h2>
+	
+	<p>As already explained it is possible to inject other object instances if someone has the possibility to
+	manipulate the data stream used to deserialize the Java objects (typically XML, but XStream supports other formats
+	like JSON).  A known vulnerability can be created with the help of the Java runtime library using the Java Bean
+	<a href="http://docs.oracle.com/javase/7/docs/api/java/beans/EventHandler.html">EventHandler</a>.  As an instance
+	for the <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/InvocationHandler.html">InvocationHandler</a>
+	of a dynamic proxy it can be used to install a redirect for an arbitrary call to the original object to the method
+	of a completely different instance of an embedded object of the EventHandler itself.</p>
+	
+	<p>This scenario can be used perfectly to replace/inject a dynamic proxy with such an EventHandler at any location
+	in the XML	where its parent expects an object of such an interface's type or a simple object instance (any list
+	element will suffice).  The usage of a ProcessBuilder as embedded element and the redirection of any call to the
+	ProcessBuilder's <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/ProcessBuilder.html#start()">start()</a>
+	method allows even the call of shell commands.  All you have to know is the XML representation of such a
+	combination.</p>
+	
+	<p>Starting with XStream 1.4.7 an instance of the EventHandler is no longer handled by default.  You have to
+	register explicitly a ReflectionConverter for the EventHandler type, if your application has the requirement to
+	persist such an object.  However, you have to take special care about the location of the persisted data and how
+	you can ensure its integrity.</p>
+	
+	<p class=highlight>Note, that this vulnerability is not even a special problem of XStream.  The XML acts here like
+	a script and the scenario above can be created with any script that is executed within a Java runtime (e.g. using
+	its JavaScript interpreter) if someone is able to manipulate it externally.</p>     
+    
+    <h2 id="explicit">Explicit Security</h2>
+    
+    <p>While XStream implicitly avoids the vulnerability scenario with the EventHandler, there might be other
+    combinations with types from well-known and often used Java libraries like ASM, CGLIB, Groovy, or even in the Java
+    runtime that are currently simply unknown.</p>
+    
+    <p>Starting with XStream 1.4.7 it is possible to define <a href="#framework">permissions</a> for types to check the
+    type of an object that should be unmarshalled.  Those permissions can be used to allow or deny types explicitly.
+    With these permissions it is at least possible to inject types into an object graph that do not belong anywhere
+    into it.  Any application that deserializes data from an external source should at least use this possibility to
+    limit the danger of arbitrary command execution.</p>
+	
+	<p class=highlight>Apart from value manipulations, this implementation still allows the injection of allowed
+	objects at wrong locations. e.g. inserting an integer into a list of strings.</p>
+	
+	<p>Apart from the XStream security framework, it has always been possible to overwrite the setupConverter method of
+	XStream to register only the required converters.</p>
+    
+    <h2 id="validation">XML Validation</h2>
+
+    <p>XML itself supports input validation using a schema and a validating parser.  With XStream you can use e.g. a
+    StAX parser for validation, but it will take some effort to ensure that the XML read and written by XStream matches
+    the schema in first place.  Typically you will have to write some custom converters, but it can be worth the effort
+    depending on the use case.</p>
+
+    <h1 id="framework">Security Framework</h1>
+
+	<p>As explained, it might be possible, that other combinations are found with the Java runtime itself or other
+	often used Java libraries that allow a similar vulnerability like the known case using the Java Beans EventHandler.
+	To prevent such a possibility at all, XStream contains since version 1.4.7 a security framework, where you can
+	define, which types	are allowed to be unmarshalled with XStream.</p>
+	
+	<p>Core interface is <a href="javadoc/com/thoughtworks/xstream/security/TypePermission.html">TypePermission</a>.
+	The <a href="javadoc/com/thoughtworks/xstream/mapper/SecurityMapper.html">SecurityMapper</a> will evaluate a list
+	of registered instances for every type that will be required while unmarshalling input data. The interface has one
+	simple method:<p><div class="Source Java"><pre>boolean allow(Class&lt;?&gt;);</pre></div>
+	
+	<p>The <a href="javadoc/com/thoughtworks/xstream/XStream.html">XStream</a> facade provides following methods to
+	register such type permissions within the SecurityMapper:<p><div class="Source Java">
+<pre>XStream.addPermission(TypePermission);
+XStream.allowTypes(String...);
+XStream.allowTypesByRegExp(String...);
+XStream.allowTypesByRegExp(Pattern...);
+XStream.allowTypesByWildcard(String...);
+XStream.denyPermission(TypePermission);
+XStream.denyTypes(String...);
+XStream.denyTypesByRegExp(String...);
+XStream.denyTypesByRegExp(Pattern...);
+XStream.denyTypesByWildcard(String...);</pre></div>
+
+	<p>The sequence of registration is essential. The latest registered permission will be evaluated first.</p>
+	
+	<p>Every TypePermission has three options to implement the allow method and make decisions on the provided type:<p>
+	<ul>
+	<li>if the method returns <i>true</i>, the type is simply accepted and no other permission is evaluated anymore</li>
+	<li>if the method returns <i>false</i>, the implementation cannot judge over the type and the SecurityMapper will
+	continue with the next permission instance in its registration list</li>
+	<li>the method throws a <a href="javadoc/com/thoughtworks/xstream/security/ForbiddenClassException.html">ForbiddenClassException</a>
+	to stop the unmarshalling process</li>
+	</ul>
+	
+	<p>XStream provides some TypePermission implementations to allow any or no type at all, to allow primitive types
+	and their counterpart, null, array types, implementations match the name of the type by regular or wildcard
+	expression and one to invert a permission.</p>
+	
+	<table class="examplesTable" summary="Overview over all Converters delivered with XStream">
+	<!-- .................................................................................................. -->
+	<tr>
+	    <th>Permission</th>
+	    <th>Description</th>
+	    <th>Example</th>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/security/AnyTypePermission.html">AnyTypePermission</a></td>
+	    <td>Allow any type.  You may use the ANY instance directly. A registration of this permission will wipe any
+	    prior one.</td>
+	    <td>&nbsp;</td>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/security/ArrayTypePermission.html">ArrayTypePermission</a></td>
+	    <td>Allow any array type.</td>
+	    <td>&nbsp;</td>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/security/CGLIBProxyTypePermission.html">CGLIBProxyTypePermission</a></td>
+	    <td>Allow any CGLIB proxy type.</td>
+	    <td>&nbsp;</td>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/security/ExplicitTypePermission.html">ExplicitTypePermission</a></td>
+	    <td>Allow types explicitly by name.</td>
+	    <td>&nbsp;</td>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/hibernate/security/HibernateProxyTypePermission.html">HibernateProxyTypePermission</a></td>
+	    <td>Allow any Hibernate proxy type. Implementation is located in XStream's Hibernate extension.</td>
+	    <td>&nbsp;</td>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/security/NoPermission.html">NoPermission</a></td>
+	    <td>Invert any other permission.  Instances of this type are used by XStream in the deny methods.</td>
+	    <td class="example">&nbsp;</td>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/security/NullPermission.html">NullPermission</a></td>
+	    <td>Allow null as type.</td>
+	    <td>&nbsp;</td>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/security/PrimitiveTypePermission.html">PrimitiveTypePermission</a></td>
+	    <td>Allow any primitive type and its boxed counterpart.</td>
+	    <td>&nbsp;</td>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/security/ProxyTypePermission.html">ProxyTypePermission</a></td>
+	    <td>Allow any Java proxy type.</td>
+	    <td>&nbsp;</td>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/security/RegExpTypePermission.html">RegExpTypePermission</a></td>
+	    <td>Allow any type that matches with its name a regular expression.</td>
+	    <td class="example">.*\\.core\\..*<br/>[^$]+</td>
+	</tr>
+	<tr>
+	    <td><a href="javadoc/com/thoughtworks/xstream/security/WildcardTypePermission.html">WildcardTypePermission</a></td>
+	    <td>Allow any type that matches with its name a wildcard expression.</td>
+	    <td class="example">java.lang.*<br/>java.util.**</td>
+	</tr>
+    </table>
+  </body>
+ </html>
diff --git a/xstream-distribution/src/content/website.xml b/xstream-distribution/src/content/website.xml
index 1532af5e2..34cd216aa 100644
--- a/xstream-distribution/src/content/website.xml
+++ b/xstream-distribution/src/content/website.xml
@@ -32,6 +32,7 @@
         <name>Using XStream</name>
         <page>architecture.html</page>
         <page>converters.html</page>
+        <page>security.html</page>
         <page>faq.html</page>
         <page>list-user.html</page>
         <page>issues.html</page>
diff --git a/xstream-hibernate/src/java/com/thoughtworks/xstream/hibernate/security/HibernateProxyTypePermission.java b/xstream-hibernate/src/java/com/thoughtworks/xstream/hibernate/security/HibernateProxyTypePermission.java
new file mode 100644
index 000000000..f7771acb7
--- /dev/null
+++ b/xstream-hibernate/src/java/com/thoughtworks/xstream/hibernate/security/HibernateProxyTypePermission.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 19. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.hibernate.security;
+
+import org.hibernate.proxy.HibernateProxy;
+
+import com.thoughtworks.xstream.security.TypePermission;
+
+
+/**
+ * Permission for any array type.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class HibernateProxyTypePermission implements TypePermission {
+    /**
+     * @since upcoming
+     */
+    public static final TypePermission PROXIES = new HibernateProxyTypePermission();
+
+    public boolean allows(final Class type) {
+        return type != null && HibernateProxy.class.isAssignableFrom(type);
+    }
+
+    public int hashCode() {
+        return 31;
+    }
+
+    public boolean equals(final Object obj) {
+        return obj != null && obj.getClass() == HibernateProxyTypePermission.class;
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/XStream.java b/xstream/src/java/com/thoughtworks/xstream/XStream.java
index 459f7eeb9..e4fea5059 100644
--- a/xstream/src/java/com/thoughtworks/xstream/XStream.java
+++ b/xstream/src/java/com/thoughtworks/xstream/XStream.java
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2003, 2004, 2005, 2006 Joe Walnes.
- * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 XStream Committers.
+ * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014 XStream Committers.
  * All rights reserved.
  *
  * The software in this package is published under the terms of the BSD
@@ -137,8 +137,16 @@
 import com.thoughtworks.xstream.mapper.MapperWrapper;
 import com.thoughtworks.xstream.mapper.OuterClassMapper;
 import com.thoughtworks.xstream.mapper.PackageAliasingMapper;
+import com.thoughtworks.xstream.mapper.SecurityMapper;
 import com.thoughtworks.xstream.mapper.SystemAttributeAliasingMapper;
 import com.thoughtworks.xstream.mapper.XStream11XmlFriendlyMapper;
+import com.thoughtworks.xstream.security.AnyTypePermission;
+import com.thoughtworks.xstream.security.ExplicitTypePermission;
+import com.thoughtworks.xstream.security.NoPermission;
+import com.thoughtworks.xstream.security.NoTypePermission;
+import com.thoughtworks.xstream.security.RegExpTypePermission;
+import com.thoughtworks.xstream.security.TypePermission;
+import com.thoughtworks.xstream.security.WildcardTypePermission;
 
 
 /**
@@ -274,7 +282,7 @@
  * The XStream instance is thread-safe. That is, once the XStream instance has been created and
  * configured, it may be shared across multiple threads allowing objects to be
  * serialized/deserialized concurrently. <em>Note, that this only applies if annotations are not 
- * auto-detected on -the-fly.</em>
+ * auto-detected on-the-fly.</em>
  * </p>
  * <h3>Implicit collections</h3>
  * 
@@ -310,6 +318,7 @@ public class XStream {
     private ImmutableTypesMapper immutableTypesMapper;
     private ImplicitCollectionMapper implicitCollectionMapper;
     private LocalConversionMapper localConversionMapper;
+    private SecurityMapper securityMapper;
     private AnnotationConfiguration annotationConfiguration;
 
     public static final int NO_REFERENCES = 1001;
@@ -558,6 +567,7 @@ public XStream(
         this.mapper = mapper == null ? buildMapper() : mapper;
 
         setupMappers();
+        setupSecurity();
         setupAliases();
         setupDefaultImplementations();
         setupConverters();
@@ -588,6 +598,7 @@ private Mapper buildMapper() {
         }
         mapper = new LocalConversionMapper(mapper);
         mapper = new ImmutableTypesMapper(mapper);
+        mapper = new SecurityMapper(mapper);
         if (JVM.is15()) {
             mapper = buildMapperDynamically(ANNOTATION_MAPPER_TYPE, new Class[]{
                 Mapper.class, ConverterRegistry.class, ConverterLookup.class,
@@ -641,9 +652,19 @@ private void setupMappers() {
             .lookupMapperOfType(ImmutableTypesMapper.class);
         localConversionMapper = (LocalConversionMapper)this.mapper
             .lookupMapperOfType(LocalConversionMapper.class);
+        securityMapper = (SecurityMapper)this.mapper
+            .lookupMapperOfType(SecurityMapper.class);
         annotationConfiguration = (AnnotationConfiguration)this.mapper
             .lookupMapperOfType(AnnotationConfiguration.class);
     }
+    
+    protected void setupSecurity() {
+        if (securityMapper == null) {
+            return;
+        }
+        
+        addPermission(AnyTypePermission.ANY);
+    }
 
     protected void setupAliases() {
         if (classAliasingMapper == null) {
@@ -1974,6 +1995,129 @@ public void autodetectAnnotations(boolean mode) {
             annotationConfiguration.autodetectAnnotations(mode);
         }
     }
+    
+    /**
+     * Add a new security permission.
+     * 
+     * <p>
+     * Permissions are evaluated in the added sequence. An instance of {@link NoTypePermission} or
+     * {@link AnyTypePermission} will implicitly wipe any existing permission.
+     * </p>
+     * 
+     * @param permission the permission to add
+     * @since upcoming
+     */
+    public void addPermission(TypePermission permission) {
+        if (securityMapper != null) {
+            securityMapper.addPermission(permission);
+        }
+    }
+    
+    /**
+     * Add security permission for explicit types by name.
+     * 
+     * @param names the type names to allow
+     * @since upcoming
+     */
+    public void allowTypes(String... names) {
+        addPermission(new ExplicitTypePermission(names));
+    }
+    
+    /**
+     * Add security permission for types matching one of the specified regular expressions.
+     * 
+     * @param regexps the regular expressions to allow type names
+     * @since upcoming
+     */
+    public void allowTypesByRegExp(String... regexps) {
+        addPermission(new RegExpTypePermission(regexps));
+    }
+    
+    /**
+     * Add security permission for types matching one of the specified regular expressions.
+     * 
+     * @param regexps the regular expressions to allow type names
+     * @since upcoming
+     */
+    public void allowTypesByRegExp(Pattern... regexps) {
+        addPermission(new RegExpTypePermission(regexps));
+    }
+    
+    /**
+     * Add security permission for types matching one of the specified wildcard patterns.
+     * <p>
+     * Supported are patterns with path expressions using dot as separator:
+     * </p>
+     * <ul>
+     * <li>?: one non-control character except separator, e.g. for 'java.net.Inet?Address'</li>
+     * <li>*: arbitrary number of non-control characters except separator, e.g. for types in a package like 'java.lang.*'</li>
+     * <li>**: arbitrary number of non-control characters including separator, e.g. for types in a package and subpackages like 'java.lang.**'</li>
+     * </ul>
+     * 
+     * @param patterns the patterns to allow type names
+     * @since upcoming
+     */
+    public void allowTypesByWildcard(String... patterns) {
+        addPermission(new WildcardTypePermission(patterns));
+    }
+    
+    /**
+     * Add security permission denying another one.
+     * 
+     * @param permission the permission to deny
+     * @since upcoming
+     */
+    public void denyPermission(TypePermission permission) {
+        addPermission(new NoPermission(permission));
+    }
+    
+    /**
+     * Add security permission forbidding explicit types by name.
+     * 
+     * @param names the type names to forbid
+     * @since upcoming
+     */
+    public void denyTypes(String... names) {
+        denyPermission(new ExplicitTypePermission(names));
+    }
+    
+    /**
+     * Add security permission forbidding types matching one of the specified regular expressions.
+     * 
+     * @param regexps the regular expressions to forbid type names
+     * @since upcoming
+     */
+    public void denyTypesByRegExp(String... regexps) {
+        denyPermission(new RegExpTypePermission(regexps));
+    }
+    
+    /**
+     * Add security permission forbidding types matching one of the specified regular expressions.
+     * 
+     * @param regexps the regular expressions to forbid type names
+     * @since upcoming
+     */
+    public void denyTypesByRegExp(Pattern... regexps) {
+        denyPermission(new RegExpTypePermission(regexps));
+    }
+    
+    /**
+     * Add security permission forbidding types matching one of the specified wildcard patterns.
+     * <p>
+     * Supported are patterns with path expressions using dot as separator:
+     * </p>
+     * <ul>
+     * <li>?: one non-control character except separator, e.g. for 'java.net.Inet?Address'</li>
+     * <li>*: arbitrary number of non-control characters except separator, e.g. for types in a package like 'java.lang.*'</li>
+     * <li>**: arbitrary number of non-control characters including separator, e.g. for types in a package and subpackages like 'java.lang.**'</li>
+     * </ul>
+     * 
+     * @param patterns the patterns to forbid names
+     * @since upcoming
+     */
+    public void denyTypesByWildcard(String... patterns) {
+        denyPermission(new WildcardTypePermission(patterns));
+    }
 
     /**
      * @deprecated As of 1.3, use {@link com.thoughtworks.xstream.InitializationException}
diff --git a/xstream/src/java/com/thoughtworks/xstream/mapper/CachingMapper.java b/xstream/src/java/com/thoughtworks/xstream/mapper/CachingMapper.java
index f4ea4cbb5..c6dbee014 100644
--- a/xstream/src/java/com/thoughtworks/xstream/mapper/CachingMapper.java
+++ b/xstream/src/java/com/thoughtworks/xstream/mapper/CachingMapper.java
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2005 Joe Walnes.
- * Copyright (C) 2006, 2007, 2008, 2009, 2011, 2013 XStream Committers.
+ * Copyright (C) 2006, 2007, 2008, 2009, 2011, 2013, 2014 XStream Committers.
  * All rights reserved.
  *
  * The software in this package is published under the terms of the BSD
@@ -15,7 +15,9 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import com.thoughtworks.xstream.XStreamException;
 import com.thoughtworks.xstream.core.Caching;
+import com.thoughtworks.xstream.security.ForbiddenClassException;
 
 /**
  * Mapper that caches which names map to which classes. Prevents repetitive searching and class loading.
@@ -38,13 +40,16 @@ public Class realClass(String elementName) {
             if (cached instanceof Class) {
                 return (Class)cached;
             }
-            throw (CannotResolveClassException)cached;
+            throw (XStreamException)cached;
         }
 
         try {
             Class result = super.realClass(elementName);
             realClassCache.put(elementName, result);
             return result;
+        } catch (ForbiddenClassException e) {
+            realClassCache.put(elementName, e);
+            throw e;
         } catch (CannotResolveClassException e) {
             realClassCache.put(elementName, e);
             throw e;
diff --git a/xstream/src/java/com/thoughtworks/xstream/mapper/SecurityMapper.java b/xstream/src/java/com/thoughtworks/xstream/mapper/SecurityMapper.java
new file mode 100644
index 000000000..9171e396f
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/mapper/SecurityMapper.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 08. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.mapper;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import com.thoughtworks.xstream.security.AnyTypePermission;
+import com.thoughtworks.xstream.security.ForbiddenClassException;
+import com.thoughtworks.xstream.security.NoTypePermission;
+import com.thoughtworks.xstream.security.TypePermission;
+
+
+/**
+ * A Mapper implementation injecting a security layer based on permission rules for any type required in the
+ * unmarshalling process.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class SecurityMapper extends MapperWrapper {
+
+    private final List<TypePermission> permissions;
+
+    /**
+     * Construct a SecurityMapper.
+     * 
+     * @param wrapped the mapper chain
+     * @since upcoming
+     */
+    public SecurityMapper(final Mapper wrapped) {
+        this(wrapped, (TypePermission[])null);
+    }
+
+    /**
+     * Construct a SecurityMapper.
+     * 
+     * @param wrapped the mapper chain
+     * @param permissions the predefined permissions
+     * @since upcoming
+     */
+    public SecurityMapper(final Mapper wrapped, final TypePermission... permissions) {
+        super(wrapped);
+        this.permissions = permissions == null //
+            ? new ArrayList<TypePermission>()
+            : new ArrayList<TypePermission>(Arrays.asList(permissions));
+    }
+
+    /**
+     * Add a new permission.
+     * <p>
+     * Permissions are evaluated in the added sequence. An instance of {@link NoTypePermission} or
+     * {@link AnyTypePermission} will implicitly wipe any existing permission.
+     * </p>
+     * 
+     * @param permission the permission to add.
+     * @since upcoming
+     */
+    public void addPermission(final TypePermission permission) {
+        if (permission.equals(NoTypePermission.NONE) || permission.equals(AnyTypePermission.ANY))
+            permissions.clear();
+        permissions.add(permission);
+    }
+
+    public Class realClass(final String elementName) {
+        final Class type = super.realClass(elementName);
+        for (final TypePermission permission : permissions)
+            if (permission.allows(type))
+                return type;
+        throw new ForbiddenClassException(type);
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/AnyTypePermission.java b/xstream/src/java/com/thoughtworks/xstream/security/AnyTypePermission.java
new file mode 100644
index 000000000..21b36409b
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/AnyTypePermission.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 08. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+/**
+ * Permission for any type and <code>null</code>.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class AnyTypePermission implements TypePermission {
+    /**
+     * @since upcoming
+     */
+    public static final TypePermission ANY = new AnyTypePermission();
+
+    public boolean allows(Class type) {
+        return true;
+    }
+
+    public int hashCode() {
+        return 3;
+    }
+
+    public boolean equals(Object obj) {
+        return obj != null && obj.getClass() == AnyTypePermission.class;
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/ArrayTypePermission.java b/xstream/src/java/com/thoughtworks/xstream/security/ArrayTypePermission.java
new file mode 100644
index 000000000..34cc6288a
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/ArrayTypePermission.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 09. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+/**
+ * Permission for any array type.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class ArrayTypePermission implements TypePermission {
+    /**
+     * @since upcoming
+     */
+    public static final TypePermission ARRAYS = new ArrayTypePermission();
+
+    public boolean allows(Class type) {
+        return type != null && type.isArray();
+    }
+
+    public int hashCode() {
+        return 13;
+    }
+
+    public boolean equals(Object obj) {
+        return obj != null && obj.getClass() == ArrayTypePermission.class;
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/CGLIBProxyTypePermission.java b/xstream/src/java/com/thoughtworks/xstream/security/CGLIBProxyTypePermission.java
new file mode 100644
index 000000000..3e521b972
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/CGLIBProxyTypePermission.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 19. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+import net.sf.cglib.proxy.Proxy;
+
+
+/**
+ * Permission for any array type.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class CGLIBProxyTypePermission implements TypePermission {
+    /**
+     * @since upcoming
+     */
+    public static final TypePermission PROXIES = new CGLIBProxyTypePermission();
+
+    public boolean allows(final Class type) {
+        return type != null && Proxy.isProxyClass(type);
+    }
+
+    public int hashCode() {
+        return 19;
+    }
+
+    public boolean equals(final Object obj) {
+        return obj != null && obj.getClass() == CGLIBProxyTypePermission.class;
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/ExplicitTypePermission.java b/xstream/src/java/com/thoughtworks/xstream/security/ExplicitTypePermission.java
new file mode 100644
index 000000000..1d8e4473c
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/ExplicitTypePermission.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 09. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Explicit permission for a type with a name matching one in the provided list.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class ExplicitTypePermission implements TypePermission {
+
+    final Set<String> names;
+    
+    /**
+     * @since upcoming
+     */
+    public ExplicitTypePermission(String...names) {
+        this.names = names == null ? Collections.<String>emptySet() : new HashSet<String>(Arrays.asList(names));
+    }
+
+    public boolean allows(Class type) {
+        if (type == null)
+            return false;
+        return names.contains(type.getName());
+    }
+
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/ForbiddenClassException.java b/xstream/src/java/com/thoughtworks/xstream/security/ForbiddenClassException.java
new file mode 100644
index 000000000..041e47a63
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/ForbiddenClassException.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 08. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+import com.thoughtworks.xstream.XStreamException;
+
+/**
+ * Exception thrown for a forbidden class.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class ForbiddenClassException extends XStreamException {
+
+    /**
+     * Construct a ForbiddenClassException.
+     * @param type the forbidden class
+     * @since upcoming
+     */
+    public ForbiddenClassException(Class<?> type) {
+        super(type == null ? "null" : type.getName());
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/NoPermission.java b/xstream/src/java/com/thoughtworks/xstream/security/NoPermission.java
new file mode 100644
index 000000000..cf6ccb319
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/NoPermission.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 09. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+/**
+ * Wrapper to negate another type permission.
+ * <p>
+ * If the wrapped {@link TypePermission} allows the type, this instance will throw a {@link ForbiddenClassException}
+ * instead. An instance of this permission cannot be used to allow a type.
+ * </p>
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class NoPermission implements TypePermission {
+
+    private final TypePermission permission;
+
+    /**
+     * Construct a NoPermission.
+     * 
+     * @param permission the permission to negate or <code>null</code> to forbid any type
+     * @since upcoming
+     */
+    public NoPermission(final TypePermission permission) {
+        this.permission = permission;
+    }
+
+    public boolean allows(final Class type) {
+        if (permission == null || permission.allows(type)) {
+            throw new ForbiddenClassException(type);
+        }
+        return false;
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/NoTypePermission.java b/xstream/src/java/com/thoughtworks/xstream/security/NoTypePermission.java
new file mode 100644
index 000000000..89e08c28b
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/NoTypePermission.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 08. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+/**
+ * No permission for any type.
+ * <p>
+ * Can be used to skip any existing default permission.
+ * </p>
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class NoTypePermission implements TypePermission {
+
+    /**
+     * @since upcoming
+     */
+    public static final TypePermission NONE = new NoTypePermission();
+
+    public boolean allows(Class type) {
+        throw new ForbiddenClassException(type);
+    }
+
+    public int hashCode() {
+        return 1;
+    }
+
+    public boolean equals(Object obj) {
+        return obj != null && obj.getClass() == NoTypePermission.class;
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/NullPermission.java b/xstream/src/java/com/thoughtworks/xstream/security/NullPermission.java
new file mode 100644
index 000000000..c9dc86dec
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/NullPermission.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 09. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+import com.thoughtworks.xstream.mapper.Mapper;
+
+/**
+ * Permission for <code>null</code> or XStream's null replacement type.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class NullPermission implements TypePermission {
+    /**
+     * @since upcoming
+     */
+    public static final TypePermission NULL = new NullPermission();
+
+    public boolean allows(Class type) {
+        return type == null || type == Mapper.Null.class;
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/PrimitiveTypePermission.java b/xstream/src/java/com/thoughtworks/xstream/security/PrimitiveTypePermission.java
new file mode 100644
index 000000000..4bdac2605
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/PrimitiveTypePermission.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 09. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+import com.thoughtworks.xstream.core.util.Primitives;
+
+/**
+ * Permission for any primitive type and its boxed counterpart.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class PrimitiveTypePermission implements TypePermission {
+    /**
+     * @since upcoming
+     */
+    public static final TypePermission PRIMITIVES = new PrimitiveTypePermission();
+
+    public boolean allows(Class type) {
+        return type != null && type.isPrimitive() || Primitives.isBoxed(type);
+    }
+
+    public int hashCode() {
+        return 7;
+    }
+
+    public boolean equals(Object obj) {
+        return obj != null && obj.getClass() == PrimitiveTypePermission.class;
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/ProxyTypePermission.java b/xstream/src/java/com/thoughtworks/xstream/security/ProxyTypePermission.java
new file mode 100644
index 000000000..82c6501ff
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/ProxyTypePermission.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 19. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+import java.lang.reflect.Proxy;
+
+
+/**
+ * Permission for any array type.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class ProxyTypePermission implements TypePermission {
+    /**
+     * @since upcoming
+     */
+    public static final TypePermission PROXIES = new ProxyTypePermission();
+
+    public boolean allows(final Class type) {
+        return type != null && Proxy.isProxyClass(type);
+    }
+
+    public int hashCode() {
+        return 17;
+    }
+
+    public boolean equals(final Object obj) {
+        return obj != null && obj.getClass() == ProxyTypePermission.class;
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/RegExpTypePermission.java b/xstream/src/java/com/thoughtworks/xstream/security/RegExpTypePermission.java
new file mode 100644
index 000000000..151ccdb21
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/RegExpTypePermission.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 09. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+import java.util.regex.Pattern;
+
+
+/**
+ * Permission for any type with a name matching one of the provided regular expressions.
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class RegExpTypePermission implements TypePermission {
+
+    private final Pattern[] patterns;
+
+    public RegExpTypePermission(final String... patterns) {
+        this(getPatterns(patterns));
+    }
+
+    public RegExpTypePermission(final Pattern... patterns) {
+        this.patterns = patterns == null ? new Pattern[0] : patterns;
+    }
+
+    public boolean allows(final Class type) {
+        if (type != null) {
+            final String name = type.getName();
+            for (final Pattern pattern : patterns)
+                if (pattern.matcher(name).matches())
+                    return true;
+        }
+        return false;
+    }
+
+    private static Pattern[] getPatterns(final String... patterns) {
+        if (patterns == null)
+            return null;
+        final Pattern[] array = new Pattern[patterns.length];
+        for (int i = 0; i < array.length; ++i)
+            array[i] = Pattern.compile(patterns[i]);
+        return array;
+    }
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/TypePermission.java b/xstream/src/java/com/thoughtworks/xstream/security/TypePermission.java
new file mode 100644
index 000000000..c38c8856b
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/TypePermission.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 08. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+/**
+ * Definition of a type permission. 
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public interface TypePermission {
+    /**
+     * Check permission for a provided type.
+     * 
+     * @param type the type to check
+     * @return <code>true</code> if provided type is allowed, <code>false</code> if permission does not handle the type
+     * @throws ForbiddenClassException if provided type is explicitly forbidden
+     * @since upcoming
+     */
+    boolean allows(Class type);
+}
diff --git a/xstream/src/java/com/thoughtworks/xstream/security/WildcardTypePermission.java b/xstream/src/java/com/thoughtworks/xstream/security/WildcardTypePermission.java
new file mode 100644
index 000000000..ffa93de3a
--- /dev/null
+++ b/xstream/src/java/com/thoughtworks/xstream/security/WildcardTypePermission.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 09. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.security;
+
+/**
+ * Permission for any type with a name matching one of the provided wildcard expressions.
+ * 
+ * <p>
+ * Supported are patterns with path expressions using dot as separator:
+ * </p>
+ * <ul>
+ * <li>?: one non-control character except separator, e.g. for 'java.net.Inet?Address'</li>
+ * <li>*: arbitrary number of non-control characters except separator, e.g. for types in a package like 'java.lang.*'</li>
+ * <li>**: arbitrary number of non-control characters including separator, e.g. for types in a package and subpackages like 'java.lang.**'</li>
+ * </ul>
+ * <p>
+ * The complete range of UTF-8 characters is supported except control characters.
+ * </p>
+ * 
+ * @author J&ouml;rg Schaible
+ * @since upcoming
+ */
+public class WildcardTypePermission extends RegExpTypePermission {
+
+    /**
+     * @since upcoming
+     */
+    public WildcardTypePermission(final String... patterns) {
+        super(getRegExpPatterns(patterns));
+    }
+
+    private static String[] getRegExpPatterns(final String... wildcards) {
+        if (wildcards == null)
+            return null;
+        final String[] regexps = new String[wildcards.length];
+        for (int i = 0; i < wildcards.length; ++i) {
+            final String wildcardExpression = wildcards[i];
+            final StringBuilder result = new StringBuilder(wildcardExpression.length() * 2);
+            result.append("(?u)");
+            final int length = wildcardExpression.length();
+            for (int j = 0; j < length; j++) {
+                final char ch = wildcardExpression.charAt(j);
+                switch (ch) {
+                case '\\':
+                case '.':
+                case '+':
+                case '|':
+                case '[':
+                case ']':
+                case '(':
+                case ')':
+                case '^':
+                case '$':
+                    result.append('\\').append(ch);
+                    break;
+
+                case '?':
+                    result.append('.');
+                    break;
+
+                case '*':
+                    // see "General Category Property" in http://www.unicode.org/reports/tr18/
+                    if (j + 1 < length && wildcardExpression.charAt(j + 1) == '*') {
+                        result.append("[\\P{C}]*");
+                        j++;
+                    } else {
+                        result.append("[\\P{C}&&[^").append('.').append("]]*");
+                    }
+                    break;
+
+                default:
+                    result.append(ch);
+                    break;
+                }
+            }
+            regexps[i] = result.toString();
+        }
+        return regexps;
+    }
+}
diff --git a/xstream/src/test/com/thoughtworks/xstream/mapper/SecurityMapperTest.java b/xstream/src/test/com/thoughtworks/xstream/mapper/SecurityMapperTest.java
new file mode 100644
index 000000000..ebde756ed
--- /dev/null
+++ b/xstream/src/test/com/thoughtworks/xstream/mapper/SecurityMapperTest.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2014 XStream Committers.
+ * All rights reserved.
+ *
+ * Created on 09. January 2014 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.mapper;
+
+import java.net.URL;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.thoughtworks.xstream.core.JVM;
+import com.thoughtworks.xstream.core.util.QuickWriter;
+import com.thoughtworks.xstream.security.AnyTypePermission;
+import com.thoughtworks.xstream.security.ArrayTypePermission;
+import com.thoughtworks.xstream.security.ExplicitTypePermission;
+import com.thoughtworks.xstream.security.ForbiddenClassException;
+import com.thoughtworks.xstream.security.NoTypePermission;
+import com.thoughtworks.xstream.security.NullPermission;
+import com.thoughtworks.xstream.security.PrimitiveTypePermission;
+import com.thoughtworks.xstream.security.RegExpTypePermission;
+import com.thoughtworks.xstream.security.TypePermission;
+import com.thoughtworks.xstream.security.WildcardTypePermission;
+
+import junit.framework.TestCase;
+
+
+/**
+ * Tests the {@link SecurityMapper} and the {@link TypePermission} implementations.
+ * 
+ * @author J&ouml;rg Schaible
+ */
+public class SecurityMapperTest extends TestCase {
+
+    private SecurityMapper mapper;
+    private Map<String, Class<?>> classMap;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        classMap = new HashMap<String, Class<?>>();
+        mapper = new SecurityMapper(new MapperWrapper(null) {
+            @Override
+            public Class realClass(final String elementName) {
+                return classMap.get(elementName);
+            }
+        });
+    }
+
+    private void register(final Class<?>... types) {
+        for (final Class<?> type : types) {
+            classMap.put(type.getName(), type);
+        }
+    }
+
+    public void testAnyType() {
+        register(String.class, URL.class, List.class);
+        mapper.addPermission(NoTypePermission.NONE);
+        mapper.addPermission(AnyTypePermission.ANY);
+        assertSame(String.class, mapper.realClass(String.class.getName()));
+        assertSame(List.class, mapper.realClass(List.class.getName()));
+        assertNull(mapper.realClass(null));
+    }
+
+    public void testNoType() {
+        register(String.class, URL.class, List.class);
+        mapper.addPermission(NoTypePermission.NONE);
+        try {
+            mapper.realClass(String.class.getName());
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals(String.class.getName(), e.getMessage());
+        }
+        try {
+            mapper.realClass(null);
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals("null", e.getMessage());
+        }
+    }
+
+    public void testNullType() {
+        register(String.class, Mapper.Null.class);
+        mapper.addPermission(NullPermission.NULL);
+        assertSame(Mapper.Null.class, mapper.realClass(Mapper.Null.class.getName()));
+        assertNull(mapper.realClass(null));
+        try {
+            mapper.realClass(String.class.getName());
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals(String.class.getName(), e.getMessage());
+        }
+    }
+
+    public void testPrimitiveTypes() {
+        register(String.class, int.class, Integer.class, char[].class, Character[].class);
+        mapper.addPermission(PrimitiveTypePermission.PRIMITIVES);
+        assertSame(int.class, mapper.realClass(int.class.getName()));
+        assertSame(Integer.class, mapper.realClass(Integer.class.getName()));
+        try {
+            mapper.realClass(String.class.getName());
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals(String.class.getName(), e.getMessage());
+        }
+        try {
+            mapper.realClass(null);
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals("null", e.getMessage());
+        }
+        try {
+            mapper.realClass(char[].class.getName());
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals(char[].class.getName(), e.getMessage());
+        }
+    }
+
+    public void testArrayTypes() {
+        register(String.class, int.class, Integer.class, char[].class, Character[].class);
+        mapper.addPermission(ArrayTypePermission.ARRAYS);
+        assertSame(char[].class, mapper.realClass(char[].class.getName()));
+        assertSame(Character[].class, mapper.realClass(Character[].class.getName()));
+        try {
+            mapper.realClass(String.class.getName());
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals(String.class.getName(), e.getMessage());
+        }
+        try {
+            mapper.realClass(null);
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals("null", e.getMessage());
+        }
+        try {
+            mapper.realClass(int.class.getName());
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals(int.class.getName(), e.getMessage());
+        }
+    }
+
+    public void testExplicitTypes() {
+        register(String.class, List.class);
+        mapper.addPermission(new ExplicitTypePermission(String.class.getName(), List.class.getName()));
+        assertSame(String.class, mapper.realClass(String.class.getName()));
+        assertSame(List.class, mapper.realClass(List.class.getName()));
+        try {
+            mapper.realClass(null);
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals("null", e.getMessage());
+        }
+    }
+
+    public void testNamesWithRegExps() {
+        class Foo$_0 {}
+        final Class<?> anonymous = new Object() {}.getClass();
+        register(String.class, JVM.class, QuickWriter.class, Foo$_0.class, anonymous, DefaultClassMapperTest.class);
+        mapper.addPermission(new RegExpTypePermission(".*Test", ".*\\.core\\..*", ".*SecurityMapperTest\\$.+"));
+        assertSame(DefaultClassMapperTest.class, mapper.realClass(DefaultClassMapperTest.class.getName()));
+        assertSame(JVM.class, mapper.realClass(JVM.class.getName()));
+        assertSame(QuickWriter.class, mapper.realClass(QuickWriter.class.getName()));
+        assertSame(Foo$_0.class, mapper.realClass(Foo$_0.class.getName()));
+        assertSame(anonymous, mapper.realClass(anonymous.getName()));
+        try {
+            mapper.realClass(String.class.getName());
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals(String.class.getName(), e.getMessage());
+        }
+    }
+
+    public void testNamesWithWildcardPatterns() {
+        class Foo$_0 {}
+        class Foo$_1 {}
+        final Class<?> anonymous = new Object() {}.getClass();
+        register(String.class, JVM.class, QuickWriter.class, Foo$_0.class, Foo$_1.class, anonymous);
+        mapper.addPermission(new WildcardTypePermission("**.*_0", "**.core.*", "**.SecurityMapperTest$?"));
+        assertSame(JVM.class, mapper.realClass(JVM.class.getName()));
+        assertSame(Foo$_0.class, mapper.realClass(Foo$_0.class.getName()));
+        assertSame(anonymous, mapper.realClass(anonymous.getName()));
+        try {
+            mapper.realClass(String.class.getName());
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals(String.class.getName(), e.getMessage());
+        }
+        try {
+            mapper.realClass(QuickWriter.class.getName());
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals(QuickWriter.class.getName(), e.getMessage());
+        }
+        try {
+            mapper.realClass(Foo$_1.class.getName());
+            fail("Thrown " + ForbiddenClassException.class.getName() + " expected");
+        } catch (final ForbiddenClassException e) {
+            assertEquals(Foo$_1.class.getName(), e.getMessage());
+        }
+    }
+}",
"url": "https://github.com/x-stream/xstream/commit/6344867dce6767af7d0fe34fb393271a6456672d.patch"
}
] | null |
GHSA-8hgj-6pgq-37q3
| null |
[
{
"commit_message": "[PATCH] https://bugs.launchpad.net/ubuntu/+source/imagemagick/+bug/1490362 coders/tga.c | 2 ++ 1 file changed, 2 insertions(+)",
"patch_text_b64": "RnJvbSA0ZjY4ZTk2NjE1MTg0NjNmY2E1MjNjOTcyNmJiNWQ5NDBhMmFhNmQ4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBDcmlzdHkgPHVyYmFuLXdhcnJpb3JAaW1hZ2VtYWdpY2sub3JnPgpEYXRlOiBNb24sIDMxIEF1ZyAyMDE1IDE2OjE5OjQwIC0wNDAwClN1YmplY3Q6IFtQQVRDSF0gCiBodHRwczovL2J1Z3MubGF1bmNocGFkLm5ldC91YnVudHUvK3NvdXJjZS9pbWFnZW1hZ2ljay8rYnVnLzE0OTAzNjIKCi0tLQogY29kZXJzL3RnYS5jIHwgMiArKwogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2NvZGVycy90Z2EuYyBiL2NvZGVycy90Z2EuYwppbmRleCBjMmQ3NjA0MjVkYy4uNzgxOTMzZGZiZDAgMTAwNjQ0Ci0tLSBhL2NvZGVycy90Z2EuYworKysgYi9jb2RlcnMvdGdhLmMKQEAgLTMxNSw2ICszMTUsOCBAQCBzdGF0aWMgSW1hZ2UgKlJlYWRUR0FJbWFnZShjb25zdCBJbWFnZUluZm8gKmltYWdlX2luZm8sCiAgICAgICAvKgogICAgICAgICBSZWFkIFRHQSByYXN0ZXIgY29sb3JtYXAuCiAgICAgICAqLworICAgICAgaWYgKGltYWdlLT5jb2xvcnMgPCB0Z2FfaW5mby5jb2xvcm1hcF9pbmRleCkKKyAgICAgICAgaW1hZ2UtPmNvbG9ycz10Z2FfaW5mby5jb2xvcm1hcF9pbmRleDsKICAgICAgIGlmIChBY3F1aXJlSW1hZ2VDb2xvcm1hcChpbWFnZSxpbWFnZS0+Y29sb3JzLGV4Y2VwdGlvbikgPT0gTWFnaWNrRmFsc2UpCiAgICAgICAgIFRocm93UmVhZGVyRXhjZXB0aW9uKFJlc291cmNlTGltaXRFcnJvciwiTWVtb3J5QWxsb2NhdGlvbkZhaWxlZCIpOwogICAgICAgZm9yIChpPTA7IGkgPCAoc3NpemVfdCkgdGdhX2luZm8uY29sb3JtYXBfaW5kZXg7IGkrKyk=",
"url": "https://github.com/ImageMagick/ImageMagick/commit/4f68e9661518463fca523c9726bb5d940a2aa6d8.patch"
}
] | null |
|
CVE-2024-35190
|
Asterisk' res_pjsip_endpoint_identifier_ip: wrongly matches ALL unauthorized SIP requests
|
Asterisk is an open source private branch exchange and telephony toolkit. After upgrade to 18.23.0, ALL unauthorized SIP requests are identified as PJSIP Endpoint of local asterisk server. This vulnerability is fixed in 18.23.1, 20.8.1, and 21.3.1.
|
[
{
"commit_message": "[PATCH] Revert \"res_pjsip_endpoint_identifier_ip: Add endpoint identifier transport address.\" This reverts PR #602 Resolves: #GHSA-qqxj-v78h-hrf9 configs/samples/pjsip.conf.sample | 53 +-------- ...c7ea_revert_d5122576cca8_add_transport_.py | 22 ++++ include/asterisk/res_pjsip.h | 2 - res/res_pjsip/pjsip_config.xml | 8 -- res/res_pjsip/pjsip_configuration.c | 5 - res/res_pjsip_endpoint_identifier_ip.c | 103 ++---------------- 6 files changed, 37 insertions(+), 156 deletions(-) create mode 100644 contrib/ast-db-manage/config/versions/bd9c5159c7ea_revert_d5122576cca8_add_transport_.py",
"patch_text_b64": "From 85241bd22936cc15760fd1f65d16c98be7aeaf6d Mon Sep 17 00:00:00 2001
From: George Joseph <gjoseph@sangoma.com>
Date: Fri, 17 May 2024 08:04:40 -0600
Subject: [PATCH] Revert "res_pjsip_endpoint_identifier_ip: Add endpoint
 identifier transport address."

This reverts PR #602

Resolves: #GHSA-qqxj-v78h-hrf9
---
 configs/samples/pjsip.conf.sample             |  53 +--------
 ...c7ea_revert_d5122576cca8_add_transport_.py |  22 ++++
 include/asterisk/res_pjsip.h                  |   2 -
 res/res_pjsip/pjsip_config.xml                |   8 --
 res/res_pjsip/pjsip_configuration.c           |   5 -
 res/res_pjsip_endpoint_identifier_ip.c        | 103 ++----------------
 6 files changed, 37 insertions(+), 156 deletions(-)
 create mode 100644 contrib/ast-db-manage/config/versions/bd9c5159c7ea_revert_d5122576cca8_add_transport_.py

diff --git a/configs/samples/pjsip.conf.sample b/configs/samples/pjsip.conf.sample
index d52c7afb4e3..6b8936b2d4c 100644
--- a/configs/samples/pjsip.conf.sample
+++ b/configs/samples/pjsip.conf.sample
@@ -197,47 +197,6 @@
 ;tcp_keepalive_interval_time=10  ; The time in seconds between individual keepalive probes
 ;tcp_keepalive_probe_count=5     ; The maximum number of keepalive probes TCP should send before dropping the connection
 
-;===============ENDPOINT IDENTIFIER TRANSPORT EXAMPLE==========================
-;
-; When Asterisk has multiple bound IP addresses, and endpoints don't use any
-; other means of identification (e.g.: username), the transports' bind addresses
-; can be used to identify them. Can be useful in case you're connecting to the
-; same ITSP multiple times on different IPs / NICs.
-;
-;[transport-eth0]
-;type=transport
-;protocol=tcp
-;bind=192.168.1.1:5060
-;
-;[transport-eth1]
-;type=transport
-;protocol=udp
-;bind=192.168.2.1:5060
-;
-;
-;[myprovider-a]
-;type=endpoint
-;transport=transport-eth0
-;identify_by=transport
-;
-;[myprovider-b]
-;type=endpoint
-;transport=transport-eth1
-;identify_by=transport
-;
-;
-;[identify-a]
-;type=identify
-;endpoint=myprovider-a
-;match=192.168.1.1:5060	; This is the bind address of [transport-eth0]
-;;transport=tcp		; Optionally, this is the transport protocol of [transport-eth0]
-;
-;[identify-b]
-;type=identify
-;endpoint=myprovider-b
-;match=192.168.2.1:5060	; This is the bind address of [transport-eth1]
-;;transport=udp		; Optionally, This is the transport protocol of [transport-eth1]
-
 ;===============OUTBOUND REGISTRATION WITH OUTBOUND AUTHENTICATION============
 ;
 ; This is a simple registration that works with some SIP trunking providers.
@@ -725,10 +684,9 @@
                         ; identified.
                         ; "username": Identify by the From or To username and domain
                         ; "auth_username": Identify by the Authorization username and realm
-                        ; "ip": Identify by the source (remote) IP address
+                        ; "ip": Identify by the source IP address
                         ; "header": Identify by a configured SIP header value.
                         ; "request_uri": Identify by the configured SIP request URI.
-                        ; "transport": Identify by the bound (local) IP address
                         ; In the username and auth_username cases, if an exact match
                         ; on both username and domain/realm fails, the match is
                         ; retried with just the username.
@@ -1313,10 +1271,9 @@
             ; (default: "no")
 ;endpoint_identifier_order=ip,username,anonymous
             ; The order by which endpoint identifiers are given priority.
-            ; Currently, "ip", "header", "request_uri", "transport", "username",
-            ; "auth_username" and "anonymous"  are valid identifiers as registered by
-            ; the res_pjsip_endpoint_identifier_* modules.
-            ; Some modules like res_pjsip_endpoint_identifier_user register
+            ; Currently, "ip", "header", "username", "auth_username" and "anonymous"
+            ; are valid identifiers as registered by the res_pjsip_endpoint_identifier_*
+            ; modules.  Some modules like res_pjsip_endpoint_identifier_user register
             ; more than one identifier.  Use the CLI command "pjsip show identifiers"
             ; to see the identifiers currently available.
             ; (default: ip,username,anonymous)
@@ -1504,8 +1461,6 @@
 ;match= ; Comma separated list of IP addresses, networks, or hostnames to match
         ; against (default: "")
 ;match_header= ; SIP header with specified value to match against (default: "")
-;match_request_uri= ; SIP request URI to match against (default: "")
-;transport= ; Match ageinst the transport protocol (tcp or udp) (default: "")
 ;type=  ; Must be of type identify (default: "")
 
 
diff --git a/contrib/ast-db-manage/config/versions/bd9c5159c7ea_revert_d5122576cca8_add_transport_.py b/contrib/ast-db-manage/config/versions/bd9c5159c7ea_revert_d5122576cca8_add_transport_.py
new file mode 100644
index 00000000000..5b3c1c2b3a3
--- /dev/null
+++ b/contrib/ast-db-manage/config/versions/bd9c5159c7ea_revert_d5122576cca8_add_transport_.py
@@ -0,0 +1,22 @@
+"""Revert d5122576cca8 add transport attribute to identify
+
+Revision ID: bd9c5159c7ea
+Revises: 6c475a93f48a
+Create Date: 2024-05-17 08:30:58.299083
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = 'bd9c5159c7ea'
+down_revision = '6c475a93f48a'
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+    op.drop_column('ps_endpoint_id_ips', 'transport')
+
+
+def downgrade():
+    op.add_column('ps_endpoint_id_ips', sa.Column('transport', sa.String(128)))
diff --git a/include/asterisk/res_pjsip.h b/include/asterisk/res_pjsip.h
index 984a38c673a..d0e1e592235 100644
--- a/include/asterisk/res_pjsip.h
+++ b/include/asterisk/res_pjsip.h
@@ -617,8 +617,6 @@ enum ast_sip_endpoint_identifier_type {
 	AST_SIP_ENDPOINT_IDENTIFY_BY_HEADER = (1 << 3),
 	/*! Identify based on request uri */
 	AST_SIP_ENDPOINT_IDENTIFY_BY_REQUEST_URI = (1 << 4),
-	/*! Identify based on bound (local) IP address */
-	AST_SIP_ENDPOINT_IDENTIFY_BY_TRANSPORT = (1 << 5),
 };
 AST_VECTOR(ast_sip_identify_by_vector, enum ast_sip_endpoint_identifier_type);
 
diff --git a/res/res_pjsip/pjsip_config.xml b/res/res_pjsip/pjsip_config.xml
index 094123fff56..753037b5559 100644
--- a/res/res_pjsip/pjsip_config.xml
+++ b/res/res_pjsip/pjsip_config.xml
@@ -565,14 +565,6 @@
 								but simply allowed by this configuration option.
 								</para>
 							</enum>
-							<enum name="transport">
-								<para>Matches the endpoint based on the destination IP
-								address.
-								</para>
-								<para>This method of identification is not configured here
-								but simply allowed by this configuration option.
-								</para>
-							</enum>
 						</enumlist>
 					</description>
 				</configOption>
diff --git a/res/res_pjsip/pjsip_configuration.c b/res/res_pjsip/pjsip_configuration.c
index 268607a9888..58a50c484a2 100644
--- a/res/res_pjsip/pjsip_configuration.c
+++ b/res/res_pjsip/pjsip_configuration.c
@@ -426,9 +426,6 @@ static const char *sip_endpoint_identifier_type2str(enum ast_sip_endpoint_identi
 	case AST_SIP_ENDPOINT_IDENTIFY_BY_REQUEST_URI:
 		str = "request_uri";
 		break;
-	case AST_SIP_ENDPOINT_IDENTIFY_BY_TRANSPORT:
-		str = "transport";
-		break;
 	}
 	return str;
 }
@@ -456,8 +453,6 @@ static int sip_endpoint_identifier_str2type(const char *str)
 		method = AST_SIP_ENDPOINT_IDENTIFY_BY_HEADER;
 	} else if (!strcasecmp(str, "request_uri")) {
 		method = AST_SIP_ENDPOINT_IDENTIFY_BY_REQUEST_URI;
-	} else if (!strcasecmp(str, "transport")) {
-		method = AST_SIP_ENDPOINT_IDENTIFY_BY_TRANSPORT;
 	} else {
 		method = -1;
 	}
diff --git a/res/res_pjsip_endpoint_identifier_ip.c b/res/res_pjsip_endpoint_identifier_ip.c
index 69e0c760649..da5c363f3aa 100644
--- a/res/res_pjsip_endpoint_identifier_ip.c
+++ b/res/res_pjsip_endpoint_identifier_ip.c
@@ -124,16 +124,6 @@
 						</para></note>
 					</description>
 				</configOption>
-				<configOption name="transport">
-					<synopsis>Match against a transport type.</synopsis>
-					<description>
-						<para>When using the ip or transport identifier, this option
-						can be used to match the transport type <literal>(udp or tcp)
-						</literal> as well.</para>
-						<para>When omitted, or left empty, which is the default, it
-						won't match against the transport type.</para>
-					</description>
-				</configOption>
 				<configOption name="type">
 					<synopsis>Must be of type 'identify'.</synopsis>
 				</configOption>
@@ -161,8 +151,6 @@ struct ip_identify_match {
 		AST_STRING_FIELD(match_header_name);
 		/*! SIP header value of the match_header string */
 		AST_STRING_FIELD(match_header_value);
-		/*! The name of the transport type */
-		AST_STRING_FIELD(transport);
 	);
 	/*! Compiled match_header regular expression when is_header_regex is non-zero */
 	regex_t regex_header_buf;
@@ -180,12 +168,6 @@ struct ip_identify_match {
 	unsigned int is_request_uri_regex:1;
 };
 
-/*! \brief Structure for a socket address with transport */
-struct ast_sockaddr_with_tp {
-	struct ast_sockaddr addr;
-	char tp[128];
-};
-
 /*! \brief Destructor function for a matching object */
 static void ip_identify_destroy(void *obj)
 {
@@ -321,29 +303,18 @@ static int request_identify_match_check(void *obj, void *arg, int flags)
 static int ip_identify_match_check(void *obj, void *arg, int flags)
 {
 	struct ip_identify_match *identify = obj;
-	struct ast_sockaddr_with_tp *addr_with_tp = arg;
-	struct ast_sockaddr address = addr_with_tp->addr;
+	struct ast_sockaddr *addr = arg;
 	int sense;
 
-	sense = ast_apply_ha(identify->matches, &address);
+	sense = ast_apply_ha(identify->matches, addr);
 	if (sense != AST_SENSE_ALLOW) {
-		ast_debug(3, "Address %s matches identify '%s'\n",
-				ast_sockaddr_stringify(&address),
-				ast_sorcery_object_get_id(identify));
-		if (ast_strlen_zero(identify->transport) || !strcasecmp(identify->transport, addr_with_tp->tp)) {
-			ast_debug(3, "Transport %s matches identify '%s'\n",
-				addr_with_tp->tp,
-				ast_sorcery_object_get_id(identify));
-			return CMP_MATCH;
-		} else {
-			ast_debug(3, "Transport %s match not matched identify '%s'\n",
-				addr_with_tp->tp,
+		ast_debug(3, "Source address %s matches identify '%s'\n",
+				ast_sockaddr_stringify(addr),
 				ast_sorcery_object_get_id(identify));
-			return 0;
-		}
+		return CMP_MATCH;
 	} else {
-		ast_debug(3, "Address %s does not match identify '%s'\n",
-				ast_sockaddr_stringify(&address),
+		ast_debug(3, "Source address %s does not match identify '%s'\n",
+				ast_sockaddr_stringify(addr),
 				ast_sorcery_object_get_id(identify));
 		return 0;
 	}
@@ -384,54 +355,18 @@ static struct ast_sip_endpoint *common_identify(ao2_callback_fn *identify_match_
 
 static struct ast_sip_endpoint *ip_identify(pjsip_rx_data *rdata)
 {
-	struct ast_sockaddr_with_tp addr_with_tp = { { { 0, } }, };
-	pj_ansi_strxcpy(addr_with_tp.tp, rdata->tp_info.transport->type_name, sizeof(addr_with_tp.tp));
-
-	ast_sockaddr_parse(&addr_with_tp.addr, rdata->pkt_info.src_name, PARSE_PORT_FORBID);
-	ast_sockaddr_set_port(&addr_with_tp.addr, rdata->pkt_info.src_port);
-
-	return common_identify(ip_identify_match_check, &addr_with_tp);
-}
-
-static struct ast_sip_endpoint *transport_identify(pjsip_rx_data *rdata)
-{
-	char buffer[PJ_INET6_ADDRSTRLEN];
-	pj_status_t status;
-	struct ast_sockaddr_with_tp addr_with_tp = { { { 0, } }, };
-	union pj_sockaddr sock = rdata->tp_info.transport->local_addr;
-
-	pj_ansi_strxcpy(addr_with_tp.tp, rdata->tp_info.transport->type_name, sizeof(addr_with_tp.tp));
-
-	if (sock.addr.sa_family == PJ_AF_INET6) {
-		status = pj_inet_ntop(PJ_AF_INET6, &(sock.ipv6.sin6_addr), buffer, PJ_INET6_ADDRSTRLEN);
-		if (status == PJ_SUCCESS && !strcmp(buffer, "::")) {
-			ast_log(LOG_WARNING, "Matching against '::' may be unpredictable.\n");
-		}
-	} else {
-		status = pj_inet_ntop(PJ_AF_INET, &(sock.ipv4.sin_addr), buffer, PJ_INET_ADDRSTRLEN);
-		if (status == PJ_SUCCESS && !strcmp(buffer, "0.0.0.0")) {
-			ast_log(LOG_WARNING, "Matching against '0.0.0.0' may be unpredictable.\n");
-		}
-	}
+	struct ast_sockaddr addr = { { 0, } };
 
-	if (status == PJ_SUCCESS) {
-		ast_sockaddr_parse(&addr_with_tp.addr, buffer, PARSE_PORT_FORBID);
-		ast_sockaddr_set_port(&addr_with_tp.addr, rdata->tp_info.transport->local_name.port);
+	ast_sockaddr_parse(&addr, rdata->pkt_info.src_name, PARSE_PORT_FORBID);
+	ast_sockaddr_set_port(&addr, rdata->pkt_info.src_port);
 
-		return common_identify(ip_identify_match_check, &addr_with_tp);
-	} else {
-		return NULL;
-	}
+	return common_identify(ip_identify_match_check, &addr);
 }
 
 static struct ast_sip_endpoint_identifier ip_identifier = {
 	.identify_endpoint = ip_identify,
 };
 
-static struct ast_sip_endpoint_identifier transport_identifier = {
-	.identify_endpoint = transport_identify,
-};
-
 static struct ast_sip_endpoint *header_identify(pjsip_rx_data *rdata)
 {
 	return common_identify(header_identify_match_check, rdata);
@@ -595,12 +530,6 @@ static int ip_identify_apply(const struct ast_sorcery *sorcery, void *obj)
 		return -1;
 	}
 
-	if (!ast_strlen_zero(identify->transport)) {
-		if (ast_string_field_set(identify, transport, identify->transport)) {
-			return -1;
-		}
-	}
-
 	if (!ast_strlen_zero(identify->match_header)) {
 		char *c_header;
 		char *c_value;
@@ -950,13 +879,6 @@ static int cli_print_body(void *obj, void *arg, int flags)
 				addr, ast_sockaddr_cidr_bits(&match->netmask));
 		}
 
-		if (!ast_strlen_zero(ident->transport)) {
-			ast_str_append(&context->output_buffer, 0, "%*s: %s\n",
-				indent,
-				"Transport",
-				ident->transport);
-		}
-
 		if (!ast_strlen_zero(ident->match_header)) {
 			ast_str_append(&context->output_buffer, 0, "%*s: %s\n",
 				indent,
@@ -1032,13 +954,11 @@ static int load_module(void)
 	ast_sorcery_object_field_register(ast_sip_get_sorcery(), "identify", "match_header", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ip_identify_match, match_header));
 	ast_sorcery_object_field_register(ast_sip_get_sorcery(), "identify", "match_request_uri", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ip_identify_match, match_request_uri));
 	ast_sorcery_object_field_register(ast_sip_get_sorcery(), "identify", "srv_lookups", "yes", OPT_BOOL_T, 1, FLDSET(struct ip_identify_match, srv_lookups));
-	ast_sorcery_object_field_register(ast_sip_get_sorcery(), "identify", "transport", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ip_identify_match, transport));
 	ast_sorcery_load_object(ast_sip_get_sorcery(), "identify");
 
 	ast_sip_register_endpoint_identifier_with_name(&ip_identifier, "ip");
 	ast_sip_register_endpoint_identifier_with_name(&header_identifier, "header");
 	ast_sip_register_endpoint_identifier_with_name(&request_identifier, "request_uri");
-	ast_sip_register_endpoint_identifier_with_name(&transport_identifier, "transport");
 	ast_sip_register_endpoint_formatter(&endpoint_identify_formatter);
 
 	cli_formatter = ao2_alloc(sizeof(struct ast_sip_cli_formatter_entry), NULL);
@@ -1075,7 +995,6 @@ static int unload_module(void)
 	ast_sip_unregister_endpoint_identifier(&header_identifier);
 	ast_sip_unregister_endpoint_identifier(&request_identifier);
 	ast_sip_unregister_endpoint_identifier(&ip_identifier);
-	ast_sip_unregister_endpoint_identifier(&transport_identifier);
 
 	return 0;
 }",
"url": "https://github.com/asterisk/asterisk/commit/85241bd22936cc15760fd1f65d16c98be7aeaf6d.patch"
}
] |
CWE-303: Incorrect Implementation of Authentication Algorithm
|
PYSEC-2021-244
| null |
[
{
"commit_message": "[PATCH] Fix OOB issue with `tf.raw_ops.SparseSparseMinimum`. PiperOrigin-RevId: 371005787 Change-Id: Ib686ccc077836e8b980b8b5a03936d36a8ecaf71 tensorflow/core/kernels/sparse_sparse_binary_op_shared.cc | 5 +++++ 1 file changed, 5 insertions(+)",
"patch_text_b64": "RnJvbSBiYTY4MjJiZDdiNzMyNGJhMjAxYTI4YjJmMjc4YzI5YTk4ZWRiZWYyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IFBhdGFua2FyIDxhbWl0cGF0YW5rYXJAZ29vZ2xlLmNvbT4KRGF0ZTogV2VkLCAyOCBBcHIgMjAyMSAxNjowNjo1NCAtMDcwMApTdWJqZWN0OiBbUEFUQ0hdIEZpeCBPT0IgaXNzdWUgd2l0aCBgdGYucmF3X29wcy5TcGFyc2VTcGFyc2VNaW5pbXVtYC4KClBpcGVyT3JpZ2luLVJldklkOiAzNzEwMDU3ODcKQ2hhbmdlLUlkOiBJYjY4NmNjYzA3NzgzNmU4Yjk4MGI4YjVhMDM5MzZkMzZhOGVjYWY3MQotLS0KIHRlbnNvcmZsb3cvY29yZS9rZXJuZWxzL3NwYXJzZV9zcGFyc2VfYmluYXJ5X29wX3NoYXJlZC5jYyB8IDUgKysrKysKIDEgZmlsZSBjaGFuZ2VkLCA1IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS90ZW5zb3JmbG93L2NvcmUva2VybmVscy9zcGFyc2Vfc3BhcnNlX2JpbmFyeV9vcF9zaGFyZWQuY2MgYi90ZW5zb3JmbG93L2NvcmUva2VybmVscy9zcGFyc2Vfc3BhcnNlX2JpbmFyeV9vcF9zaGFyZWQuY2MKaW5kZXggNDNkYzlhZTcwY2Q2MjcuLjlmZTQyZTA1ZDg3OWVlIDEwMDY0NAotLS0gYS90ZW5zb3JmbG93L2NvcmUva2VybmVscy9zcGFyc2Vfc3BhcnNlX2JpbmFyeV9vcF9zaGFyZWQuY2MKKysrIGIvdGVuc29yZmxvdy9jb3JlL2tlcm5lbHMvc3BhcnNlX3NwYXJzZV9iaW5hcnlfb3Bfc2hhcmVkLmNjCkBAIC0xODAsNiArMTgwLDExIEBAIGNsYXNzIFNwYXJzZVNwYXJzZUJpbmFyeU9wU2hhcmVkIDogcHVibGljIE9wS2VybmVsIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICIgZm9yIGRpbWVuc2lvbiAiLCBpKSk7CiAgICAgfQogCisgICAgT1BfUkVRVUlSRVMoCisgICAgICAgIGN0eCwgYV9pbmRpY2VzX3QtPmRpbV9zaXplKDEpID09IGJfaW5kaWNlc190LT5kaW1fc2l6ZSgxKSwKKyAgICAgICAgZXJyb3JzOjpJbnZhbGlkQXJndW1lbnQoCisgICAgICAgICAgICAiSW5kaWNlcycgZGltZW5zaW9ucyBkbyBub3QgbWF0Y2g6IGdvdCAiLCBhX2luZGljZXNfdC0+ZGltX3NpemUoMSksCisgICAgICAgICAgICAiIGFuZCAiLCBiX2luZGljZXNfdC0+ZGltX3NpemUoMSksICIgZm9yIHRoZSBzZWNvbmQgZGltZW5zaW9uLiIpKTsKICAgICBjb25zdCBpbnQgbnVtX2RpbXMgPSBhX2luZGljZXNfdC0+ZGltX3NpemUoMSk7CiAgICAgY29uc3QgYXV0byBhX2luZGljZXNfbWF0ID0gYV9pbmRpY2VzX3QtPm1hdHJpeDxpbnQ2ND4oKTsKICAgICBjb25zdCBhdXRvIGJfaW5kaWNlc19tYXQgPSBiX2luZGljZXNfdC0+bWF0cml4PGludDY0PigpOw==",
"url": "https://github.com/tensorflow/tensorflow/commit/ba6822bd7b7324ba201a28b2f278c29a98edbef2.patch"
},
{
"commit_message": "[PATCH] Validate that a and b are proper sparse tensors PiperOrigin-RevId: 373274848 Change-Id: I3a665ac3a29dee9fb69bdf408a939330cb93ea75 .../kernels/sparse_sparse_binary_op_shared.cc | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/tensorflow/tensorflow/commit/f6fde895ef9c77d848061c0517f19d0ec2682f3a.patch"
}
] | null |
|
CVE-2022-24761
|
HTTP Request Smuggling in waitress
|
Waitress is a Web Server Gateway Interface server for Python 2 and 3. When using Waitress versions 2.1.0 and prior behind a proxy that does not properly validate the incoming HTTP request matches the RFC7230 standard, Waitress and the frontend proxy may disagree on where one request starts and where it ends. This would allow requests to be smuggled via the front-end proxy to waitress and later behavior. There are two classes of vulnerability that may lead to request smuggling that are addressed by this advisory: The use of Python's `int()` to parse strings into integers, leading to `+10` to be parsed as `10`, or `0x01` to be parsed as `1`, where as the standard specifies that the string should contain only digits or hex digits; and Waitress does not support chunk extensions, however it was discarding them without validating that they did not contain illegal characters. This vulnerability has been patched in Waitress 2.1.1. A workaround is available. When deploying a proxy in front of waitress, turning on any and all functionality to make sure that the request matches the RFC7230 standard. Certain proxy servers may not have this functionality though and users are encouraged to upgrade to the latest version of waitress instead.
|
[
{
"commit_message": "[PATCH 1/7] Add new regular expressions for Chunked Encoding This also moves some regular expressions for QUOTED_PAIR/QUOTED_STRING into this module from utilities so that they may be reused. src/waitress/rfc7230.py | 27 ++++++++++++++++++++++++++- src/waitress/utilities.py | 28 +++------------------------- 2 files changed, 29 insertions(+), 26 deletions(-)",
"patch_text_b64": "From e75b0d9afbea8a933f8f5f11d279e661cbfd676b Mon Sep 17 00:00:00 2001
From: Bert JW Regeer <bertjw@regeer.org>
Date: Sat, 12 Mar 2022 18:30:30 -0700
Subject: [PATCH 1/7] Add new regular expressions for Chunked Encoding

This also moves some regular expressions for QUOTED_PAIR/QUOTED_STRING
into this module from utilities so that they may be reused.
---
 src/waitress/rfc7230.py   | 27 ++++++++++++++++++++++++++-
 src/waitress/utilities.py | 28 +++-------------------------
 2 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/src/waitress/rfc7230.py b/src/waitress/rfc7230.py
index 9b25fbd9..26e64260 100644
--- a/src/waitress/rfc7230.py
+++ b/src/waitress/rfc7230.py
@@ -5,6 +5,9 @@
 
 import re
 
+HEXDIG = "[0-9a-fA-F]"
+DIGIT = "[0-9]"
+
 WS = "[ \t]"
 OWS = WS + "{0,}?"
 RWS = WS + "{1,}?"
@@ -25,6 +28,12 @@
 #                  ; visible (printing) characters
 VCHAR = r"\x21-\x7e"
 
+# The '\\' between \x5b and \x5d is needed to escape \x5d (']')
+QDTEXT = "[\t \x21\x23-\x5b\\\x5d-\x7e" + OBS_TEXT + "]"
+
+QUOTED_PAIR = r"\\" + "([\t " + VCHAR + OBS_TEXT + "])"
+QUOTED_STRING = '"(?:(?:' + QDTEXT + ")|(?:" + QUOTED_PAIR + '))*"'
+
 # header-field   = field-name ":" OWS field-value OWS
 # field-name     = token
 # field-value    = *( field-content / obs-fold )
@@ -43,8 +52,24 @@
 # Which allows the field value here to just see if there is even a value in the first place
 FIELD_VALUE = "(?:" + FIELD_CONTENT + ")?"
 
-HEADER_FIELD = re.compile(
+# chunk-ext      = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
+# chunk-ext-name = token
+# chunk-ext-val  = token / quoted-string
+
+CHUNK_EXT_NAME = TOKEN
+CHUNK_EXT_VAL = "(?:" + TOKEN + ")|(?:" + QUOTED_STRING + ")"
+CHUNK_EXT = (
+    "(?:;(?P<extension>" + CHUNK_EXT_NAME + ")(?:=(?P<value>" + CHUNK_EXT_VAL + "))?)*"
+)
+
+# Pre-compiled regular expressions for use elsewhere
+ONLY_HEXDIG_RE = re.compile(("^" + HEXDIG + "+$").encode("latin-1"))
+ONLY_DIGIT_RE = re.compile(("^" + DIGIT + "+$").encode("latin-1"))
+HEADER_FIELD_RE = re.compile(
     (
         "^(?P<name>" + TOKEN + "):" + OWS + "(?P<value>" + FIELD_VALUE + ")" + OWS + "$"
     ).encode("latin-1")
 )
+QUOTED_PAIR_RE = re.compile(QUOTED_PAIR)
+QUOTED_STRING_RE = re.compile(QUOTED_STRING)
+CHUNK_EXT_RE = re.compile(("^" + CHUNK_EXT + "$").encode("latin-1"))
diff --git a/src/waitress/utilities.py b/src/waitress/utilities.py
index 3caaa336..6ae47420 100644
--- a/src/waitress/utilities.py
+++ b/src/waitress/utilities.py
@@ -22,7 +22,7 @@
 import stat
 import time
 
-from .rfc7230 import OBS_TEXT, VCHAR
+from .rfc7230 import QUOTED_PAIR_RE, QUOTED_STRING_RE
 
 logger = logging.getLogger("waitress")
 queue_logger = logging.getLogger("waitress.queue")
@@ -216,32 +216,10 @@ def parse_http_date(d):
     return retval
 
 
-# RFC 5234 Appendix B.1 "Core Rules":
-# VCHAR         =  %x21-7E
-#                  ; visible (printing) characters
-vchar_re = VCHAR
-
-# RFC 7230 Section 3.2.6 "Field Value Components":
-# quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
-# qdtext        = HTAB / SP /%x21 / %x23-5B / %x5D-7E / obs-text
-# obs-text      = %x80-FF
-# quoted-pair   = "\" ( HTAB / SP / VCHAR / obs-text )
-obs_text_re = OBS_TEXT
-
-# The '\\' between \x5b and \x5d is needed to escape \x5d (']')
-qdtext_re = "[\t \x21\x23-\x5b\\\x5d-\x7e" + obs_text_re + "]"
-
-quoted_pair_re = r"\\" + "([\t " + vchar_re + obs_text_re + "])"
-quoted_string_re = '"(?:(?:' + qdtext_re + ")|(?:" + quoted_pair_re + '))*"'
-
-quoted_string = re.compile(quoted_string_re)
-quoted_pair = re.compile(quoted_pair_re)
-
-
 def undquote(value):
     if value.startswith('"') and value.endswith('"'):
         # So it claims to be DQUOTE'ed, let's validate that
-        matches = quoted_string.match(value)
+        matches = QUOTED_STRING_RE.match(value)
 
         if matches and matches.end() == len(value):
             # Remove the DQUOTE's from the value
@@ -249,7 +227,7 @@ def undquote(value):
 
             # Remove all backslashes that are followed by a valid vchar or
             # obs-text
-            value = quoted_pair.sub(r"\1", value)
+            value = QUOTED_PAIR_RE.sub(r"\1", value)
 
             return value
     elif not value.startswith('"') and not value.endswith('"'):

From 1f6059f4c4a3a0b256b4027eda64fb9fc311b0a6 Mon Sep 17 00:00:00 2001
From: Bert JW Regeer <bertjw@regeer.org>
Date: Sat, 12 Mar 2022 18:32:24 -0700
Subject: [PATCH 2/7] Be more strict in parsing Content-Length

Validate that we are only parsing digits and nothing else. RFC7230 is
explicit in that the Content-Length can only exist of 1*DIGIT and may
not include any additional sign information.

The Python int() function parses `+10` as `10` which means we were more
lenient than the standard intended.
---
 src/waitress/parser.py | 12 ++++++------
 tests/test_parser.py   | 20 ++++++++++++++++++++
 2 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/src/waitress/parser.py b/src/waitress/parser.py
index a6e4d982..ff16a402 100644
--- a/src/waitress/parser.py
+++ b/src/waitress/parser.py
@@ -23,6 +23,7 @@
 
 from waitress.buffers import OverflowableBuffer
 from waitress.receiver import ChunkedReceiver, FixedStreamReceiver
+from waitress.rfc7230 import HEADER_FIELD_RE, ONLY_DIGIT_RE
 from waitress.utilities import (
     BadRequest,
     RequestEntityTooLarge,
@@ -31,8 +32,6 @@
     find_double_newline,
 )
 
-from .rfc7230 import HEADER_FIELD
-
 
 def unquote_bytes_to_wsgi(bytestring):
     return unquote_to_bytes(bytestring).decode("latin-1")
@@ -221,7 +220,7 @@ def parse_header(self, header_plus):
         headers = self.headers
 
         for line in lines:
-            header = HEADER_FIELD.match(line)
+            header = HEADER_FIELD_RE.match(line)
 
             if not header:
                 raise ParsingError("Invalid header")
@@ -317,11 +316,12 @@ def parse_header(self, header_plus):
                 self.connection_close = True
 
         if not self.chunked:
-            try:
-                cl = int(headers.get("CONTENT_LENGTH", 0))
-            except ValueError:
+            cl = headers.get("CONTENT_LENGTH", "0")
+
+            if not ONLY_DIGIT_RE.match(cl.encode("latin-1")):
                 raise ParsingError("Content-Length is invalid")
 
+            cl = int(cl)
             self.content_length = cl
 
             if cl > 0:
diff --git a/tests/test_parser.py b/tests/test_parser.py
index aacef26d..868c1225 100644
--- a/tests/test_parser.py
+++ b/tests/test_parser.py
@@ -193,6 +193,26 @@ def test_parse_header_bad_content_length(self):
         else:  # pragma: nocover
             self.assertTrue(False)
 
+    def test_parse_header_bad_content_length_plus(self):
+        data = b"GET /foobar HTTP/8.4\r\ncontent-length: +10\r\n"
+
+        try:
+            self.parser.parse_header(data)
+        except ParsingError as e:
+            self.assertIn("Content-Length is invalid", e.args[0])
+        else:  # pragma: nocover
+            self.assertTrue(False)
+
+    def test_parse_header_bad_content_length_minus(self):
+        data = b"GET /foobar HTTP/8.4\r\ncontent-length: -10\r\n"
+
+        try:
+            self.parser.parse_header(data)
+        except ParsingError as e:
+            self.assertIn("Content-Length is invalid", e.args[0])
+        else:  # pragma: nocover
+            self.assertTrue(False)
+
     def test_parse_header_multiple_content_length(self):
         data = b"GET /foobar HTTP/8.4\r\ncontent-length: 10\r\ncontent-length: 20\r\n"
 

From 884bed167d09c3d5fdf0730e2ca2564eefdd4534 Mon Sep 17 00:00:00 2001
From: Bert JW Regeer <bertjw@regeer.org>
Date: Sat, 12 Mar 2022 18:35:01 -0700
Subject: [PATCH 3/7] Update tests to remove invalid chunked encoding
 chunk-size

RFC7230 states the following:

     chunk          = chunk-size [ chunk-ext ] CRLF
                      chunk-data CRLF
     chunk-size     = 1*HEXDIG

Where chunk-ext is:

     chunk-ext      = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )

Only if there is a chunk-ext should there be a `;` after the 1*HEXDIG.
And a chunk-ext that is empty is invalid.
---
 tests/test_functional.py | 6 +++---
 tests/test_parser.py     | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/test_functional.py b/tests/test_functional.py
index f74a2527..d1366caf 100644
--- a/tests/test_functional.py
+++ b/tests/test_functional.py
@@ -322,7 +322,7 @@ def test_chunking_request_without_content(self):
             self.assertFalse("transfer-encoding" in headers)
 
     def test_chunking_request_with_content(self):
-        control_line = b"20;\r\n"  # 20 hex = 32 dec
+        control_line = b"20\r\n"  # 20 hex = 32 dec
         s = b"This string has 32 characters.\r\n"
         expected = s * 12
         header = b"GET / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n"
@@ -341,7 +341,7 @@ def test_chunking_request_with_content(self):
             self.assertFalse("transfer-encoding" in headers)
 
     def test_broken_chunked_encoding(self):
-        control_line = b"20;\r\n"  # 20 hex = 32 dec
+        control_line = b"20\r\n"  # 20 hex = 32 dec
         s = b"This string has 32 characters.\r\n"
         to_send = b"GET / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n"
         to_send += control_line + s + b"\r\n"
@@ -365,7 +365,7 @@ def test_broken_chunked_encoding(self):
             self.assertRaises(ConnectionClosed, read_http, fp)
 
     def test_broken_chunked_encoding_missing_chunk_end(self):
-        control_line = b"20;\r\n"  # 20 hex = 32 dec
+        control_line = b"20\r\n"  # 20 hex = 32 dec
         s = b"This string has 32 characters.\r\n"
         to_send = b"GET / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n"
         to_send += control_line + s
diff --git a/tests/test_parser.py b/tests/test_parser.py
index 868c1225..4461bdea 100644
--- a/tests/test_parser.py
+++ b/tests/test_parser.py
@@ -155,7 +155,7 @@ def test_received_chunked_completed_sets_content_length(self):
             b"Transfer-Encoding: chunked\r\n"
             b"X-Foo: 1\r\n"
             b"\r\n"
-            b"1d;\r\n"
+            b"1d\r\n"
             b"This string has 29 characters\r\n"
             b"0\r\n\r\n"
         )

From d032a669682838b26d6a1a1b513b9da83b0e0f90 Mon Sep 17 00:00:00 2001
From: Bert JW Regeer <bertjw@regeer.org>
Date: Sat, 12 Mar 2022 18:42:51 -0700
Subject: [PATCH 4/7] Error when receiving back Chunk Extension

Waitress discards chunked extensions and does no further processing on
them, however it failed to validate that the chunked encoding extension
did not contain invalid data.

We now validate that if there are any chunked extensions that they are
well-formed, if they are not and contain invalid characters, then
Waitress will now correctly return a Bad Request and stop any further
processing of the request.
---
 src/waitress/receiver.py | 11 ++++++++++-
 tests/test_functional.py | 22 ++++++++++++++++++++++
 tests/test_receiver.py   | 37 +++++++++++++++++++++++++++++++++++++
 3 files changed, 69 insertions(+), 1 deletion(-)

diff --git a/src/waitress/receiver.py b/src/waitress/receiver.py
index 87852808..6289d1a9 100644
--- a/src/waitress/receiver.py
+++ b/src/waitress/receiver.py
@@ -14,6 +14,7 @@
 """Data Chunk Receiver
 """
 
+from waitress.rfc7230 import CHUNK_EXT_RE, ONLY_HEXDIG_RE
 from waitress.utilities import BadRequest, find_double_newline
 
 
@@ -110,6 +111,7 @@ def received(self, s):
                     s = b""
                 else:
                     self.chunk_end = b""
+
                     if pos == 0:
                         # Chop off the terminating CR LF from the chunk
                         s = s[2:]
@@ -140,7 +142,14 @@ def received(self, s):
                         semi = line.find(b";")
 
                         if semi >= 0:
-                            # discard extension info.
+                            extinfo = line[semi:]
+                            valid_ext_info = CHUNK_EXT_RE.match(extinfo)
+
+                            if not valid_ext_info:
+                                self.error = BadRequest("Invalid chunk extension")
+                                self.all_chunks_received = True
+
+                                break
                             line = line[:semi]
                         try:
                             sz = int(line.strip(), 16)  # hexadecimal
diff --git a/tests/test_functional.py b/tests/test_functional.py
index d1366caf..9e33fc0f 100644
--- a/tests/test_functional.py
+++ b/tests/test_functional.py
@@ -364,6 +364,28 @@ def test_broken_chunked_encoding(self):
             self.send_check_error(to_send)
             self.assertRaises(ConnectionClosed, read_http, fp)
 
+    def test_broken_chunked_encoding_invalid_extension(self):
+        control_line = b"20;invalid=\r\n"  # 20 hex = 32 dec
+        s = b"This string has 32 characters.\r\n"
+        to_send = b"GET / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n"
+        to_send += control_line + s + b"\r\n"
+        self.connect()
+        self.sock.send(to_send)
+        with self.sock.makefile("rb", 0) as fp:
+            line, headers, response_body = read_http(fp)
+            self.assertline(line, "400", "Bad Request", "HTTP/1.1")
+            cl = int(headers["content-length"])
+            self.assertEqual(cl, len(response_body))
+            self.assertIn(b"Invalid chunk extension", response_body)
+            self.assertEqual(
+                sorted(headers.keys()),
+                ["connection", "content-length", "content-type", "date", "server"],
+            )
+            self.assertEqual(headers["content-type"], "text/plain")
+            # connection has been closed
+            self.send_check_error(to_send)
+            self.assertRaises(ConnectionClosed, read_http, fp)
+
     def test_broken_chunked_encoding_missing_chunk_end(self):
         control_line = b"20\r\n"  # 20 hex = 32 dec
         s = b"This string has 32 characters.\r\n"
diff --git a/tests/test_receiver.py b/tests/test_receiver.py
index f55aa68e..a3b6f994 100644
--- a/tests/test_receiver.py
+++ b/tests/test_receiver.py
@@ -1,5 +1,7 @@
 import unittest
 
+import pytest
+
 
 class TestFixedStreamReceiver(unittest.TestCase):
     def _makeOne(self, cl, buf):
@@ -226,6 +228,41 @@ def test_received_multiple_chunks_split(self):
         self.assertEqual(inst.error, None)
 
 
+class TestChunkedReceiverParametrized:
+    def _makeOne(self, buf):
+        from waitress.receiver import ChunkedReceiver
+
+        return ChunkedReceiver(buf)
+
+    @pytest.mark.parametrize(
+        "invalid_extension", [b"\n", b"invalid=", b"\r", b"invalid = true"]
+    )
+    def test_received_invalid_extensions(self, invalid_extension):
+        from waitress.utilities import BadRequest
+
+        buf = DummyBuffer()
+        inst = self._makeOne(buf)
+        data = b"4;" + invalid_extension + b"\r\ntest\r\n"
+        result = inst.received(data)
+        assert result == len(data)
+        assert inst.error.__class__ == BadRequest
+        assert inst.error.body == "Invalid chunk extension"
+
+    @pytest.mark.parametrize(
+        "valid_extension", [b"test", b"valid=true", b"valid=true;other=true"]
+    )
+    def test_received_valid_extensions(self, valid_extension):
+        # While waitress may ignore extensions in Chunked Encoding, we do want
+        # to make sure that we don't fail when we do encounter one that is
+        # valid
+        buf = DummyBuffer()
+        inst = self._makeOne(buf)
+        data = b"4;" + valid_extension + b"\r\ntest\r\n"
+        result = inst.received(data)
+        assert result == len(data)
+        assert inst.error == None
+
+
 class DummyBuffer:
     def __init__(self, data=None):
         if data is None:

From d9bdfa0cf210f6daf017d7c5a3cc149bdec8a9a7 Mon Sep 17 00:00:00 2001
From: Bert JW Regeer <bertjw@regeer.org>
Date: Sat, 12 Mar 2022 18:48:26 -0700
Subject: [PATCH 5/7] Validate chunk size in Chunked Encoding are HEXDIG

RFC7230 states that a chunk-size should be 1*HEXDIG, this is now
validated before passing the resulting string to int() which would also
parse other formats for hex, such as: `0x01` as `1` and `+0x01` as `1`.
This would lead to a potential for a frontend proxy server and waitress
to disagree on where a chunk started and ended, thereby potentially
leading to request smuggling.

With the increased validation if the size is not just hex digits,
Waitress now returns a Bad Request and stops processing the request.
---
 src/waitress/receiver.py | 19 ++++++++++++++-----
 tests/test_functional.py | 22 ++++++++++++++++++++++
 tests/test_receiver.py   | 12 ++++++++++++
 3 files changed, 48 insertions(+), 5 deletions(-)

diff --git a/src/waitress/receiver.py b/src/waitress/receiver.py
index 6289d1a9..2f0b734a 100644
--- a/src/waitress/receiver.py
+++ b/src/waitress/receiver.py
@@ -150,12 +150,21 @@ def received(self, s):
                                 self.all_chunks_received = True
 
                                 break
+
                             line = line[:semi]
-                        try:
-                            sz = int(line.strip(), 16)  # hexadecimal
-                        except ValueError:  # garbage in input
-                            self.error = BadRequest("garbage in chunked encoding input")
-                            sz = 0
+
+                        # Remove any whitespace
+                        line = line.strip()
+
+                        if not ONLY_HEXDIG_RE.match(line):
+                            self.error = BadRequest("Invalid chunk size")
+                            self.all_chunks_received = True
+
+                            break
+
+                        # Can not fail due to matching against the regular
+                        # expression above
+                        sz = int(line.strip(), 16)  # hexadecimal
 
                         if sz > 0:
                             # Start a new chunk.
diff --git a/tests/test_functional.py b/tests/test_functional.py
index 9e33fc0f..60eb24a4 100644
--- a/tests/test_functional.py
+++ b/tests/test_functional.py
@@ -364,6 +364,28 @@ def test_broken_chunked_encoding(self):
             self.send_check_error(to_send)
             self.assertRaises(ConnectionClosed, read_http, fp)
 
+    def test_broken_chunked_encoding_invalid_hex(self):
+        control_line = b"0x20\r\n"  # 20 hex = 32 dec
+        s = b"This string has 32 characters.\r\n"
+        to_send = b"GET / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n"
+        to_send += control_line + s + b"\r\n"
+        self.connect()
+        self.sock.send(to_send)
+        with self.sock.makefile("rb", 0) as fp:
+            line, headers, response_body = read_http(fp)
+            self.assertline(line, "400", "Bad Request", "HTTP/1.1")
+            cl = int(headers["content-length"])
+            self.assertEqual(cl, len(response_body))
+            self.assertIn(b"Invalid chunk size", response_body)
+            self.assertEqual(
+                sorted(headers.keys()),
+                ["connection", "content-length", "content-type", "date", "server"],
+            )
+            self.assertEqual(headers["content-type"], "text/plain")
+            # connection has been closed
+            self.send_check_error(to_send)
+            self.assertRaises(ConnectionClosed, read_http, fp)
+
     def test_broken_chunked_encoding_invalid_extension(self):
         control_line = b"20;invalid=\r\n"  # 20 hex = 32 dec
         s = b"This string has 32 characters.\r\n"
diff --git a/tests/test_receiver.py b/tests/test_receiver.py
index a3b6f994..8e43cc86 100644
--- a/tests/test_receiver.py
+++ b/tests/test_receiver.py
@@ -262,6 +262,18 @@ def test_received_valid_extensions(self, valid_extension):
         assert result == len(data)
         assert inst.error == None
 
+    @pytest.mark.parametrize("invalid_size", [b"0x04", b"+0x04", b"x04", b"+04"])
+    def test_received_invalid_size(self, invalid_size):
+        from waitress.utilities import BadRequest
+
+        buf = DummyBuffer()
+        inst = self._makeOne(buf)
+        data = invalid_size + b"\r\ntest\r\n"
+        result = inst.received(data)
+        assert result == len(data)
+        assert inst.error.__class__ == BadRequest
+        assert inst.error.body == "Invalid chunk size"
+
 
 class DummyBuffer:
     def __init__(self, data=None):

From bd22869c143a3f1284f271399524676efbafa655 Mon Sep 17 00:00:00 2001
From: Bert JW Regeer <bertjw@regeer.org>
Date: Sat, 12 Mar 2022 19:16:23 -0700
Subject: [PATCH 6/7] Remove extraneous calls to .strip() in Chunked Encoding

To be valid chunked encoding we should not be removing any whitespace as
the standard does not allow for optional whitespace.

If whitespace is encountered in the wrong place, it should lead to a 400
Bad Request instead.
---
 src/waitress/receiver.py | 6 +-----
 tests/test_receiver.py   | 4 +++-
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/waitress/receiver.py b/src/waitress/receiver.py
index 2f0b734a..76633552 100644
--- a/src/waitress/receiver.py
+++ b/src/waitress/receiver.py
@@ -135,7 +135,6 @@ def received(self, s):
                     line = s[:pos]
                     s = s[pos + 2 :]
                     self.control_line = b""
-                    line = line.strip()
 
                     if line:
                         # Begin a new chunk.
@@ -153,9 +152,6 @@ def received(self, s):
 
                             line = line[:semi]
 
-                        # Remove any whitespace
-                        line = line.strip()
-
                         if not ONLY_HEXDIG_RE.match(line):
                             self.error = BadRequest("Invalid chunk size")
                             self.all_chunks_received = True
@@ -164,7 +160,7 @@ def received(self, s):
 
                         # Can not fail due to matching against the regular
                         # expression above
-                        sz = int(line.strip(), 16)  # hexadecimal
+                        sz = int(line, 16)  # hexadecimal
 
                         if sz > 0:
                             # Start a new chunk.
diff --git a/tests/test_receiver.py b/tests/test_receiver.py
index 8e43cc86..d160cac4 100644
--- a/tests/test_receiver.py
+++ b/tests/test_receiver.py
@@ -262,7 +262,9 @@ def test_received_valid_extensions(self, valid_extension):
         assert result == len(data)
         assert inst.error == None
 
-    @pytest.mark.parametrize("invalid_size", [b"0x04", b"+0x04", b"x04", b"+04"])
+    @pytest.mark.parametrize(
+        "invalid_size", [b"0x04", b"+0x04", b"x04", b"+04", b" 04", b" 0x04"]
+    )
     def test_received_invalid_size(self, invalid_size):
         from waitress.utilities import BadRequest
 

From b28c9e8bda326ff2f87bf8eb7ea6b110ee0ae6fe Mon Sep 17 00:00:00 2001
From: Bert JW Regeer <bertjw@regeer.org>
Date: Wed, 16 Mar 2022 15:25:23 -0600
Subject: [PATCH 7/7] Prep for 2.1.1

---
 CHANGES.txt | 26 ++++++++++++++++++++++++++
 setup.cfg   |  2 +-
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/CHANGES.txt b/CHANGES.txt
index a1e60fe6..eb7093c5 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,3 +1,29 @@
+2.1.1
+-----
+
+Security Bugfix
+~~~~~~~~~~~~~~~
+
+- Waitress now validates that chunked encoding extensions are valid, and don't
+  contain invalid characters that are not allowed. They are still skipped/not
+  processed, but if they contain invalid data we no longer continue in and
+  return a 400 Bad Request. This stops potential HTTP desync/HTTP request
+  smuggling. Thanks to Zhang Zeyu for reporting this issue. See
+  https://github.com/Pylons/waitress/security/advisories/GHSA-4f7p-27jc-3c36
+
+- Waitress now validates that the chunk length is only valid hex digits when
+  parsing chunked encoding, and values such as ``0x01`` and ``+01`` are no
+  longer supported. This stops potential HTTP desync/HTTP request smuggling.
+  Thanks to Zhang Zeyu for reporting this issue. See
+  https://github.com/Pylons/waitress/security/advisories/GHSA-4f7p-27jc-3c36
+
+- Waitress now validates that the Content-Length sent by a remote contains only
+  digits in accordance with RFC7230 and will return a 400 Bad Request when the
+  Content-Length header contains invalid data, such as ``+10`` which would
+  previously get parsed as ``10`` and accepted. This stops potential HTTP
+  desync/HTTP request smuggling Thanks to Zhang Zeyu for reporting this issue. See
+  https://github.com/Pylons/waitress/security/advisories/GHSA-4f7p-27jc-3c36
+
 2.1.0
 -----
 
diff --git a/setup.cfg b/setup.cfg
index b1d21988..69086dce 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,6 +1,6 @@
 [metadata]
 name = waitress
-version = 2.1.0
+version = 2.1.1
 description = Waitress WSGI server
 long_description = file: README.rst, CHANGES.txt
 long_description_content_type = text/x-rst",
"url": "https://github.com/Pylons/waitress/commit/9e0b8c801e4d505c2ffc91b891af4ba48af715e0.patch"
}
] |
CWE-444: Inconsistent Interpretation of HTTP Requests ('HTTP Request Smuggling')
|
PYSEC-2022-162
| null |
[
{
"commit_message": "[PATCH] vcs: Improve mercurial parameters handling Make sure that all user provided input is handled as expected. weblate/vcs/mercurial.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)",
"patch_text_b64": "RnJvbSAzNWQ1OWYxZjA0MDU0MWMzNThjZWNlMGE4ZDRhNjMxODNjYTkxOWI4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/TWljaGFsPTIwPUM0PThDaWhhPUM1PTk5Pz0gPG1pY2hhbEBjaWhhci5jb20+CkRhdGU6IFRodSwgMyBNYXIgMjAyMiAwODoyNTowMSArMDEwMApTdWJqZWN0OiBbUEFUQ0hdIHZjczogSW1wcm92ZSBtZXJjdXJpYWwgcGFyYW1ldGVycyBoYW5kbGluZwoKTWFrZSBzdXJlIHRoYXQgYWxsIHVzZXIgcHJvdmlkZWQgaW5wdXQgaXMgaGFuZGxlZCBhcyBleHBlY3RlZC4KLS0tCiB3ZWJsYXRlL3Zjcy9tZXJjdXJpYWwucHkgfCA4ICsrKystLS0tCiAxIGZpbGUgY2hhbmdlZCwgNCBpbnNlcnRpb25zKCspLCA0IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3dlYmxhdGUvdmNzL21lcmN1cmlhbC5weSBiL3dlYmxhdGUvdmNzL21lcmN1cmlhbC5weQppbmRleCAwMzk5YzFiMGJhZTIuLjExMzFjMWFiZDFlNSAxMDA2NDQKLS0tIGEvd2VibGF0ZS92Y3MvbWVyY3VyaWFsLnB5CisrKyBiL3dlYmxhdGUvdmNzL21lcmN1cmlhbC5weQpAQCAtNzAsNyArNzAsNyBAQCBkZWYgY2hlY2tfY29uZmlnKHNlbGYpOgogICAgIEBjbGFzc21ldGhvZAogICAgIGRlZiBfY2xvbmUoY2xzLCBzb3VyY2U6IHN0ciwgdGFyZ2V0OiBzdHIsIGJyYW5jaDogc3RyKToKICAgICAgICAgIiIiQ2xvbmUgcmVwb3NpdG9yeS4iIiIKLSAgICAgICAgY2xzLl9wb3BlbihbImNsb25lIiwgIi0tYnJhbmNoIiwgYnJhbmNoLCBzb3VyY2UsIHRhcmdldF0pCisgICAgICAgIGNscy5fcG9wZW4oWyJjbG9uZSIsIGYiLS1icmFuY2g9e2JyYW5jaH0iLCAiLS0iLCBzb3VyY2UsIHRhcmdldF0pCiAKICAgICBkZWYgZ2V0X2NvbmZpZyhzZWxmLCBwYXRoKToKICAgICAgICAgIiIiUmVhZCBlbnRyeSBmcm9tIGNvbmZpZ3VyYXRpb24uIiIiCkBAIC0zMjMsNyArMzIzLDcgQEAgZGVmIG9uX2JyYW5jaChzZWxmLCBicmFuY2gpOgogICAgIGRlZiBjb25maWd1cmVfYnJhbmNoKHNlbGYsIGJyYW5jaCk6CiAgICAgICAgICIiIkNvbmZpZ3VyZSByZXBvc2l0b3J5IGJyYW5jaC4iIiIKICAgICAgICAgaWYgbm90IHNlbGYub25fYnJhbmNoKGJyYW5jaCk6Ci0gICAgICAgICAgICBzZWxmLmV4ZWN1dGUoWyJ1cGRhdGUiLCBicmFuY2hdKQorICAgICAgICAgICAgc2VsZi5leGVjdXRlKFsidXBkYXRlIiwgIi0tIiwgYnJhbmNoXSkKICAgICAgICAgc2VsZi5icmFuY2ggPSBicmFuY2gKIAogICAgIGRlZiBkZXNjcmliZShzZWxmKToKQEAgLTM0Myw3ICszNDMsNyBAQCBkZWYgZGVzY3JpYmUoc2VsZik6CiAgICAgZGVmIHB1c2goc2VsZiwgYnJhbmNoKToKICAgICAgICAgIiIiUHVzaCBnaXZlbiBicmFuY2ggdG8gcmVtb3RlIHJlcG9zaXRvcnkuIiIiCiAgICAgICAgIHRyeToKLSAgICAgICAgICAgIHNlbGYuZXhlY3V0ZShbInB1c2giLCAiLWIiLCBzZWxmLmJyYW5jaF0pCisgICAgICAgICAgICBzZWxmLmV4ZWN1dGUoWyJwdXNoIiwgZiItLWJyYW5jaD17c2VsZi5icmFuY2h9Il0pCiAgICAgICAgIGV4Y2VwdCBSZXBvc2l0b3J5RXhjZXB0aW9uIGFzIGVycm9yOgogICAgICAgICAgICAgaWYgZXJyb3IucmV0Y29kZSA9PSAxOgogICAgICAgICAgICAgICAgICMgTm8gY2hhbmdlcyBmb3VuZApAQCAtMzYzLDcgKzM2Myw3IEBAIGRlZiBjbGVhbnVwKHNlbGYpOgogCiAgICAgZGVmIHVwZGF0ZV9yZW1vdGUoc2VsZik6CiAgICAgICAgICIiIlVwZGF0ZSByZW1vdGUgcmVwb3NpdG9yeS4iIiIKLSAgICAgICAgc2VsZi5leGVjdXRlKFsicHVsbCIsICItLWJyYW5jaCIsIHNlbGYuYnJhbmNoXSkKKyAgICAgICAgc2VsZi5leGVjdXRlKFsicHVsbCIsIGYiLS1icmFuY2g9e3NlbGYuYnJhbmNofSJdKQogICAgICAgICBzZWxmLmNsZWFuX3JldmlzaW9uX2NhY2hlKCkKIAogICAgIGRlZiBwYXJzZV9jaGFuZ2VkX2ZpbGVzKHNlbGYsIGxpbmVzOiBMaXN0W3N0cl0pIC0+IEl0ZXJhdG9yW3N0cl06",
"url": "https://github.com/WeblateOrg/weblate/commit/35d59f1f040541c358cece0a8d4a63183ca919b8.patch"
},
{
"commit_message": "[PATCH] vcs: Improve git parameters handling Make sure that all user provided input is handled as expected. weblate/vcs/git.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/WeblateOrg/weblate/commit/d83672a3e7415da1490334e2c9431e5da1966842.patch"
}
] | null |
|
CVE-2021-21243
|
Pre-Auth Unsafe Deserialization on KubernetesResource
|
OneDev is an all-in-one devops platform. In OneDev before version 4.0.3, a Kubernetes REST endpoint exposes two methods that deserialize untrusted data from the request body. These endpoints do not enforce any authentication or authorization checks. This issue may lead to pre-auth RCE. This issue was fixed in 4.0.3 by not using deserialization at KubernetesResource side.
|
[
{
"commit_message": "[PATCH] Do not deserialize data from job nodes in Kubernetes resource to avoid security vulnerability pom.xml | 4 ++-- server-core/pom.xml | 2 +- server-plugin/pom.xml | 2 +- server-plugin/server-plugin-archetype/pom.xml | 2 +- .../server-plugin-authenticator-ldap/pom.xml | 2 +- .../server-plugin-buildspec-gradle/pom.xml | 2 +- .../server-plugin-buildspec-maven/pom.xml | 2 +- .../server-plugin-buildspec-node/pom.xml | 2 +- .../server-plugin-executor-docker/pom.xml | 2 +- .../server-plugin-executor-kubernetes/pom.xml | 2 +- .../executor/kubernetes/KubernetesResource.java | 16 ++++++++-------- server-plugin/server-plugin-report-html/pom.xml | 2 +- .../server-plugin-report-markdown/pom.xml | 2 +- server-plugin/server-plugin-sso-openid/pom.xml | 2 +- server-product/pom.xml | 2 +- 15 files changed, 23 insertions(+), 23 deletions(-)",
"patch_text_b64": "From 9637fc8fa461c5777282a0021c3deb1e7a48f137 Mon Sep 17 00:00:00 2001
From: Robin Shen <robin@onedev.io>
Date: Thu, 19 Nov 2020 12:09:04 +0800
Subject: [PATCH] Do not deserialize data from job nodes in Kubernetes resource
 to avoid security vulnerability

---
 pom.xml                                          |  4 ++--
 server-core/pom.xml                              |  2 +-
 server-plugin/pom.xml                            |  2 +-
 server-plugin/server-plugin-archetype/pom.xml    |  2 +-
 .../server-plugin-authenticator-ldap/pom.xml     |  2 +-
 .../server-plugin-buildspec-gradle/pom.xml       |  2 +-
 .../server-plugin-buildspec-maven/pom.xml        |  2 +-
 .../server-plugin-buildspec-node/pom.xml         |  2 +-
 .../server-plugin-executor-docker/pom.xml        |  2 +-
 .../server-plugin-executor-kubernetes/pom.xml    |  2 +-
 .../executor/kubernetes/KubernetesResource.java  | 16 ++++++++--------
 server-plugin/server-plugin-report-html/pom.xml  |  2 +-
 .../server-plugin-report-markdown/pom.xml        |  2 +-
 server-plugin/server-plugin-sso-openid/pom.xml   |  2 +-
 server-product/pom.xml                           |  2 +-
 15 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/pom.xml b/pom.xml
index 74c3a1ef06..78dd663ae5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -9,7 +9,7 @@
 		<version>1.0.5</version>
 	</parent>
 	<artifactId>server</artifactId>
-	<version>4.0.0</version>
+	<version>4.0.1</version>
 	<packaging>pom</packaging>
 	<build>
 		<finalName>${project.groupId}.${project.artifactId}-${project.version}</finalName>
@@ -574,7 +574,7 @@
 	</repositories>
 	<properties>
 		<commons.version>1.1.21</commons.version>
-		<k8shelper.version>1.0.20</k8shelper.version>
+		<k8shelper.version>1.0.21</k8shelper.version>
 		<slf4j.version>1.7.5</slf4j.version>
 		<logback.version>1.0.11</logback.version>
 		<antlr.version>4.7.2</antlr.version>
diff --git a/server-core/pom.xml b/server-core/pom.xml
index d2658ebcf3..d6afca5912 100644
--- a/server-core/pom.xml
+++ b/server-core/pom.xml
@@ -7,7 +7,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<build>
 		<plugins>
diff --git a/server-plugin/pom.xml b/server-plugin/pom.xml
index fea6340305..4a905e16ad 100644
--- a/server-plugin/pom.xml
+++ b/server-plugin/pom.xml
@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<dependencies>
 		<dependency>
diff --git a/server-plugin/server-plugin-archetype/pom.xml b/server-plugin/server-plugin-archetype/pom.xml
index 271b0e4a6f..2c2042024a 100644
--- a/server-plugin/server-plugin-archetype/pom.xml
+++ b/server-plugin/server-plugin-archetype/pom.xml
@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server-plugin</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<build>
 		<resources>
diff --git a/server-plugin/server-plugin-authenticator-ldap/pom.xml b/server-plugin/server-plugin-authenticator-ldap/pom.xml
index 76cc188fde..4ccb1c1310 100644
--- a/server-plugin/server-plugin-authenticator-ldap/pom.xml
+++ b/server-plugin/server-plugin-authenticator-ldap/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server-plugin</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<properties>
 		<moduleClass>io.onedev.server.plugin.authenticator.ldap.LdapModule</moduleClass>
diff --git a/server-plugin/server-plugin-buildspec-gradle/pom.xml b/server-plugin/server-plugin-buildspec-gradle/pom.xml
index 5d5e5372da..01063b2c0d 100644
--- a/server-plugin/server-plugin-buildspec-gradle/pom.xml
+++ b/server-plugin/server-plugin-buildspec-gradle/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server-plugin</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<dependencies>
 		<dependency>
diff --git a/server-plugin/server-plugin-buildspec-maven/pom.xml b/server-plugin/server-plugin-buildspec-maven/pom.xml
index 41083dc061..e907cf6b4c 100644
--- a/server-plugin/server-plugin-buildspec-maven/pom.xml
+++ b/server-plugin/server-plugin-buildspec-maven/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server-plugin</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<properties>
 		<moduleClass>io.onedev.server.plugin.buildspec.maven.MavenModule</moduleClass>
diff --git a/server-plugin/server-plugin-buildspec-node/pom.xml b/server-plugin/server-plugin-buildspec-node/pom.xml
index 734f4fb954..43e6921257 100644
--- a/server-plugin/server-plugin-buildspec-node/pom.xml
+++ b/server-plugin/server-plugin-buildspec-node/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server-plugin</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<properties>
 		<moduleClass>io.onedev.server.plugin.buildspec.node.NodePluginModule</moduleClass>
diff --git a/server-plugin/server-plugin-executor-docker/pom.xml b/server-plugin/server-plugin-executor-docker/pom.xml
index 131cdc320c..3e9c721529 100644
--- a/server-plugin/server-plugin-executor-docker/pom.xml
+++ b/server-plugin/server-plugin-executor-docker/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server-plugin</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<properties>
 		<moduleClass>io.onedev.server.plugin.docker.DockerModule</moduleClass>
diff --git a/server-plugin/server-plugin-executor-kubernetes/pom.xml b/server-plugin/server-plugin-executor-kubernetes/pom.xml
index 1ad33b7b4a..de0de3d470 100644
--- a/server-plugin/server-plugin-executor-kubernetes/pom.xml
+++ b/server-plugin/server-plugin-executor-kubernetes/pom.xml
@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server-plugin</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<properties>
 		<moduleClass>io.onedev.server.plugin.executor.kubernetes.KubernetesModule</moduleClass>
diff --git a/server-plugin/server-plugin-executor-kubernetes/src/main/java/io/onedev/server/plugin/executor/kubernetes/KubernetesResource.java b/server-plugin/server-plugin-executor-kubernetes/src/main/java/io/onedev/server/plugin/executor/kubernetes/KubernetesResource.java
index c1271a2024..840c4460a7 100644
--- a/server-plugin/server-plugin-executor-kubernetes/src/main/java/io/onedev/server/plugin/executor/kubernetes/KubernetesResource.java
+++ b/server-plugin/server-plugin-executor-kubernetes/src/main/java/io/onedev/server/plugin/executor/kubernetes/KubernetesResource.java
@@ -25,6 +25,7 @@
 
 import org.apache.commons.lang.SerializationUtils;
 
+import com.google.common.base.Splitter;
 import com.google.common.collect.Lists;
 
 import io.onedev.commons.utils.TarUtils;
@@ -73,20 +74,19 @@ public byte[] getJobContext() {
 	@Consumes(MediaType.APPLICATION_OCTET_STREAM)
 	@Produces(MediaType.APPLICATION_OCTET_STREAM)
     @POST
-    public byte[] allocateJobCaches(byte[] cacheAllocationRequestBytes) {
-		CacheAllocationRequest allocationRequest = (CacheAllocationRequest) SerializationUtils
-				.deserialize(cacheAllocationRequestBytes);
+    public byte[] allocateJobCaches(String cacheAllocationRequestString) {
+		CacheAllocationRequest cacheAllocationRequest = CacheAllocationRequest.fromString(cacheAllocationRequestString);
 		return SerializationUtils.serialize((Serializable) jobManager.allocateJobCaches(
-				getJobToken(), allocationRequest.getCurrentTime(), allocationRequest.getInstances()));
+				getJobToken(), cacheAllocationRequest.getCurrentTime(), cacheAllocationRequest.getInstances()));
     }
 	
 	@Path("/report-job-caches")
 	@Consumes(MediaType.APPLICATION_OCTET_STREAM)
 	@POST
-	public void reportJobCaches(byte[] cacheInstanceBytes) {
-		@SuppressWarnings("unchecked")
-		Collection<CacheInstance> cacheInstances = (Collection<CacheInstance>) SerializationUtils
-				.deserialize(cacheInstanceBytes);
+	public void reportJobCaches(String cacheInstancesString) {
+		Collection<CacheInstance> cacheInstances = new ArrayList<>();
+		for (String field: Splitter.on(';').omitEmptyStrings().split(cacheInstancesString))
+			cacheInstances.add(CacheInstance.fromString(field));
 		jobManager.reportJobCaches(getJobToken(), cacheInstances);
 	}
 	
diff --git a/server-plugin/server-plugin-report-html/pom.xml b/server-plugin/server-plugin-report-html/pom.xml
index 29d04e02c0..c8744f45b9 100644
--- a/server-plugin/server-plugin-report-html/pom.xml
+++ b/server-plugin/server-plugin-report-html/pom.xml
@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server-plugin</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<properties>
 		<moduleClass>io.onedev.server.plugin.report.html.HtmlReportModule</moduleClass>
diff --git a/server-plugin/server-plugin-report-markdown/pom.xml b/server-plugin/server-plugin-report-markdown/pom.xml
index 786a4e675c..8021bed869 100644
--- a/server-plugin/server-plugin-report-markdown/pom.xml
+++ b/server-plugin/server-plugin-report-markdown/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server-plugin</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<properties>
 		<moduleClass>io.onedev.server.plugin.report.markdown.MarkdownReportModule</moduleClass>
diff --git a/server-plugin/server-plugin-sso-openid/pom.xml b/server-plugin/server-plugin-sso-openid/pom.xml
index 50e567a80f..90a99cacc3 100644
--- a/server-plugin/server-plugin-sso-openid/pom.xml
+++ b/server-plugin/server-plugin-sso-openid/pom.xml
@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server-plugin</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<dependencies>
 		<dependency>
diff --git a/server-product/pom.xml b/server-product/pom.xml
index 88aa453714..f9df4216fa 100644
--- a/server-product/pom.xml
+++ b/server-product/pom.xml
@@ -7,7 +7,7 @@
 	<parent>
 		<groupId>io.onedev</groupId>
 		<artifactId>server</artifactId>
-		<version>4.0.0</version>
+		<version>4.0.1</version>
 	</parent>
 	<dependencies>
 		<dependency>",
"url": "https://github.com/theonedev/onedev/commit/9637fc8fa461c5777282a0021c3deb1e7a48f137.patch"
}
] |
CWE-74 Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection')
|
GHSA-cvx7-x8pj-x2gw
|
CoreDNS Vulnerable to DoQ Memory Exhaustion via Stream Amplification
| null |
[
{
"commit_message": "[PATCH] feat: limit concurrent DoQ streams and goroutines (#7296) core/dnsserver/config.go | 8 ++ core/dnsserver/server_quic.go | 49 +++++-- core/dnsserver/zdirectives.go | 1 + core/plugin/zplugin.go | 1 + man/coredns-quic.7 | 69 ++++++++++ plugin.cfg | 1 + plugin/quic/README.md | 48 +++++++ plugin/quic/setup.go | 79 +++++++++++ plugin/quic/setup_test.go | 242 ++++++++++++++++++++++++++++++++++ test/quic_test.go | 189 ++++++++++++++++++++++++++ 10 files changed, 678 insertions(+), 9 deletions(-) create mode 100644 man/coredns-quic.7 create mode 100644 plugin/quic/README.md create mode 100644 plugin/quic/setup.go create mode 100644 plugin/quic/setup_test.go",
"patch_text_b64": "From efaed02c6a480ec147b1f799aab7cf815b17dfe1 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Mon, 19 May 2025 03:49:21 +0300
Subject: [PATCH] feat: limit concurrent DoQ streams and goroutines (#7296)

---
 core/dnsserver/config.go      |   8 ++
 core/dnsserver/server_quic.go |  49 +++++--
 core/dnsserver/zdirectives.go |   1 +
 core/plugin/zplugin.go        |   1 +
 man/coredns-quic.7            |  69 ++++++++++
 plugin.cfg                    |   1 +
 plugin/quic/README.md         |  48 +++++++
 plugin/quic/setup.go          |  79 +++++++++++
 plugin/quic/setup_test.go     | 242 ++++++++++++++++++++++++++++++++++
 test/quic_test.go             | 189 ++++++++++++++++++++++++++
 10 files changed, 678 insertions(+), 9 deletions(-)
 create mode 100644 man/coredns-quic.7
 create mode 100644 plugin/quic/README.md
 create mode 100644 plugin/quic/setup.go
 create mode 100644 plugin/quic/setup_test.go

diff --git a/core/dnsserver/config.go b/core/dnsserver/config.go
index 27f5c2105e..168120795d 100644
--- a/core/dnsserver/config.go
+++ b/core/dnsserver/config.go
@@ -58,6 +58,14 @@ type Config struct {
 	// TLSConfig when listening for encrypted connections (gRPC, DNS-over-TLS).
 	TLSConfig *tls.Config
 
+	// MaxQUICStreams defines the maximum number of concurrent QUIC streams for a QUIC server.
+	// This is nil if not specified, allowing for a default to be used.
+	MaxQUICStreams *int
+
+	// MaxQUICWorkerPoolSize defines the size of the worker pool for processing QUIC streams.
+	// This is nil if not specified, allowing for a default to be used.
+	MaxQUICWorkerPoolSize *int
+
 	// Timeouts for TCP, TLS and HTTPS servers.
 	ReadTimeout  time.Duration
 	WriteTimeout time.Duration
diff --git a/core/dnsserver/server_quic.go b/core/dnsserver/server_quic.go
index 7acfd788ce..1a3b2c4566 100644
--- a/core/dnsserver/server_quic.go
+++ b/core/dnsserver/server_quic.go
@@ -7,7 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math"
 	"net"
 
 	"github.com/coredns/coredns/plugin/metrics/vars"
@@ -32,15 +31,26 @@ const (
 	// DoQCodeProtocolError signals that the DoQ implementation encountered
 	// a protocol error and is forcibly aborting the connection.
 	DoQCodeProtocolError quic.ApplicationErrorCode = 2
+
+	// DefaultMaxQUICStreams is the default maximum number of concurrent QUIC streams
+	// on a per-connection basis. RFC 9250 (DNS-over-QUIC) does not require a high
+	// concurrent-stream limit; normal stub or recursive resolvers open only a handful
+	// of streams in parallel. This default (256) is a safe upper bound.
+	DefaultMaxQUICStreams = 256
+
+	// DefaultQUICStreamWorkers is the default number of workers for processing QUIC streams.
+	DefaultQUICStreamWorkers = 1024
 )
 
 // ServerQUIC represents an instance of a DNS-over-QUIC server.
 type ServerQUIC struct {
 	*Server
-	listenAddr   net.Addr
-	tlsConfig    *tls.Config
-	quicConfig   *quic.Config
-	quicListener *quic.Listener
+	listenAddr        net.Addr
+	tlsConfig         *tls.Config
+	quicConfig        *quic.Config
+	quicListener      *quic.Listener
+	maxStreams        int
+	streamProcessPool chan struct{}
 }
 
 // NewServerQUIC returns a new CoreDNS QUIC server and compiles all plugin in to it.
@@ -63,15 +73,31 @@ func NewServerQUIC(addr string, group []*Config) (*ServerQUIC, error) {
 		tlsConfig.NextProtos = []string{"doq"}
 	}
 
+	maxStreams := DefaultMaxQUICStreams
+	if len(group) > 0 && group[0] != nil && group[0].MaxQUICStreams != nil {
+		maxStreams = *group[0].MaxQUICStreams
+	}
+
+	streamProcessPoolSize := DefaultQUICStreamWorkers
+	if len(group) > 0 && group[0] != nil && group[0].MaxQUICWorkerPoolSize != nil {
+		streamProcessPoolSize = *group[0].MaxQUICWorkerPoolSize
+	}
+
 	var quicConfig = &quic.Config{
 		MaxIdleTimeout:        s.idleTimeout,
-		MaxIncomingStreams:    math.MaxUint16,
-		MaxIncomingUniStreams: math.MaxUint16,
+		MaxIncomingStreams:    int64(maxStreams),
+		MaxIncomingUniStreams: int64(maxStreams),
 		// Enable 0-RTT by default for all connections on the server-side.
 		Allow0RTT: true,
 	}
 
-	return &ServerQUIC{Server: s, tlsConfig: tlsConfig, quicConfig: quicConfig}, nil
+	return &ServerQUIC{
+		Server:            s,
+		tlsConfig:         tlsConfig,
+		quicConfig:        quicConfig,
+		maxStreams:        maxStreams,
+		streamProcessPool: make(chan struct{}, streamProcessPoolSize),
+	}, nil
 }
 
 // ServePacket implements caddy.UDPServer interface.
@@ -119,7 +145,12 @@ func (s *ServerQUIC) serveQUICConnection(conn quic.Connection) {
 			return
 		}
 
-		go s.serveQUICStream(stream, conn)
+		// Use a bounded worker pool
+		s.streamProcessPool <- struct{}{} // Acquire a worker slot, may block
+		go func(st quic.Stream, cn quic.Connection) {
+			defer func() { <-s.streamProcessPool }() // Release worker slot
+			s.serveQUICStream(st, cn)
+		}(stream, conn)
 	}
 }
 
diff --git a/core/dnsserver/zdirectives.go b/core/dnsserver/zdirectives.go
index 56174955c9..9bfcb1f315 100644
--- a/core/dnsserver/zdirectives.go
+++ b/core/dnsserver/zdirectives.go
@@ -15,6 +15,7 @@ var Directives = []string{
 	"geoip",
 	"cancel",
 	"tls",
+	"quic",
 	"timeouts",
 	"multisocket",
 	"reload",
diff --git a/core/plugin/zplugin.go b/core/plugin/zplugin.go
index 12bb4ce156..3aa6b10b5c 100644
--- a/core/plugin/zplugin.go
+++ b/core/plugin/zplugin.go
@@ -42,6 +42,7 @@ import (
 	_ "github.com/coredns/coredns/plugin/multisocket"
 	_ "github.com/coredns/coredns/plugin/nsid"
 	_ "github.com/coredns/coredns/plugin/pprof"
+	_ "github.com/coredns/coredns/plugin/quic"
 	_ "github.com/coredns/coredns/plugin/ready"
 	_ "github.com/coredns/coredns/plugin/reload"
 	_ "github.com/coredns/coredns/plugin/rewrite"
diff --git a/man/coredns-quic.7 b/man/coredns-quic.7
new file mode 100644
index 0000000000..6301ec2295
--- /dev/null
+++ b/man/coredns-quic.7
@@ -0,0 +1,69 @@
+.\" Generated by Mmark Markdown Processer - mmark.miek.nl
+.TH "COREDNS-QUIC" 7 "May 2025" "CoreDNS" "CoreDNS Plugins"
+
+.SH "NAME"
+.PP
+\fIquic\fP - configures DNS-over-QUIC (DoQ) server options.
+
+.SH "DESCRIPTION"
+.PP
+The \fIquic\fP plugin allows you to configure parameters for the DNS-over-QUIC (DoQ) server to fine-tune the security posture and performance of the server.
+
+.PP
+This plugin can only be used once per quic Server Block.
+
+.SH "SYNTAX"
+.PP
+.RS
+
+.nf
+quic {
+    max\_streams POSITIVE\_INTEGER
+    worker\_pool\_size POSITIVE\_INTEGER
+}
+
+.fi
+.RE
+
+.IP \(bu 4
+\fB\fCmax_streams\fR limits the number of concurrent QUIC streams per connection. This helps prevent DoS attacks where an attacker could open many streams on a single connection, exhausting server resources. The default value is 256 if not specified.
+.IP \(bu 4
+\fB\fCworker_pool_size\fR defines the size of the worker pool for processing QUIC streams across all connections. The default value is 512 if not specified. This limits the total number of concurrent streams that can be processed across all connections.
+
+
+.SH "EXAMPLES"
+.PP
+Enable DNS-over-QUIC with default settings (256 concurrent streams per connection, 512 worker pool size):
+
+.PP
+.RS
+
+.nf
+quic://.:8853 {
+    tls cert.pem key.pem
+    quic
+    whoami
+}
+
+.fi
+.RE
+
+.PP
+Set custom limits for maximum QUIC streams per connection and worker pool size:
+
+.PP
+.RS
+
+.nf
+quic://.:8853 {
+    tls cert.pem key.pem
+    quic {
+        max\_streams 16
+        worker\_pool\_size 65536
+    }
+    whoami
+}
+
+.fi
+.RE
+
diff --git a/plugin.cfg b/plugin.cfg
index 36bd367dab..6b3d716df7 100644
--- a/plugin.cfg
+++ b/plugin.cfg
@@ -24,6 +24,7 @@ metadata:metadata
 geoip:geoip
 cancel:cancel
 tls:tls
+quic:quic
 timeouts:timeouts
 multisocket:multisocket
 reload:reload
diff --git a/plugin/quic/README.md b/plugin/quic/README.md
new file mode 100644
index 0000000000..63fe56d120
--- /dev/null
+++ b/plugin/quic/README.md
@@ -0,0 +1,48 @@
+# quic
+
+## Name
+
+*quic* - configures DNS-over-QUIC (DoQ) server options.
+
+## Description
+
+The *quic* plugin allows you to configure parameters for the DNS-over-QUIC (DoQ) server to fine-tune the security posture and performance of the server.
+
+This plugin can only be used once per quic Server Block.
+
+## Syntax
+
+```txt
+quic {
+    max_streams POSITIVE_INTEGER
+    worker_pool_size POSITIVE_INTEGER
+}
+```
+
+* `max_streams` limits the number of concurrent QUIC streams per connection. This helps prevent DoS attacks where an attacker could open many streams on a single connection, exhausting server resources. The default value is 256 if not specified.
+* `worker_pool_size` defines the size of the worker pool for processing QUIC streams across all connections. The default value is 512 if not specified. This limits the total number of concurrent streams that can be processed across all connections.
+
+## Examples
+
+Enable DNS-over-QUIC with default settings (256 concurrent streams per connection, 512 worker pool size):
+
+```
+quic://.:8853 {
+    tls cert.pem key.pem
+    quic
+    whoami
+}
+```
+
+Set custom limits for maximum QUIC streams per connection and worker pool size:
+
+```
+quic://.:8853 {
+    tls cert.pem key.pem
+    quic {
+        max_streams 16
+        worker_pool_size 65536
+    }
+    whoami
+}
+```
diff --git a/plugin/quic/setup.go b/plugin/quic/setup.go
new file mode 100644
index 0000000000..4c49101fd4
--- /dev/null
+++ b/plugin/quic/setup.go
@@ -0,0 +1,79 @@
+package quic
+
+import (
+	"strconv"
+
+	"github.com/coredns/caddy"
+	"github.com/coredns/coredns/core/dnsserver"
+	"github.com/coredns/coredns/plugin"
+)
+
+func init() {
+	caddy.RegisterPlugin("quic", caddy.Plugin{
+		ServerType: "dns",
+		Action:     setup,
+	})
+}
+
+func setup(c *caddy.Controller) error {
+	err := parseQuic(c)
+	if err != nil {
+		return plugin.Error("quic", err)
+	}
+	return nil
+}
+
+func parseQuic(c *caddy.Controller) error {
+	config := dnsserver.GetConfig(c)
+
+	// Skip the "quic" directive itself
+	c.Next()
+
+	// Get any arguments on the "quic" line
+	args := c.RemainingArgs()
+	if len(args) > 0 {
+		return c.ArgErr()
+	}
+
+	// Process all nested directives in the block
+	for c.NextBlock() {
+		switch c.Val() {
+		case "max_streams":
+			args := c.RemainingArgs()
+			if len(args) != 1 {
+				return c.ArgErr()
+			}
+			val, err := strconv.Atoi(args[0])
+			if err != nil {
+				return c.Errf("invalid max_streams value '%s': %v", args[0], err)
+			}
+			if val <= 0 {
+				return c.Errf("max_streams must be a positive integer: %d", val)
+			}
+			if config.MaxQUICStreams != nil {
+				return c.Err("max_streams already defined for this server block")
+			}
+			config.MaxQUICStreams = &val
+		case "worker_pool_size":
+			args := c.RemainingArgs()
+			if len(args) != 1 {
+				return c.ArgErr()
+			}
+			val, err := strconv.Atoi(args[0])
+			if err != nil {
+				return c.Errf("invalid worker_pool_size value '%s': %v", args[0], err)
+			}
+			if val <= 0 {
+				return c.Errf("worker_pool_size must be a positive integer: %d", val)
+			}
+			if config.MaxQUICWorkerPoolSize != nil {
+				return c.Err("worker_pool_size already defined for this server block")
+			}
+			config.MaxQUICWorkerPoolSize = &val
+		default:
+			return c.Errf("unknown property '%s'", c.Val())
+		}
+	}
+
+	return nil
+}
diff --git a/plugin/quic/setup_test.go b/plugin/quic/setup_test.go
new file mode 100644
index 0000000000..48a982bf3f
--- /dev/null
+++ b/plugin/quic/setup_test.go
@@ -0,0 +1,242 @@
+package quic
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/coredns/caddy"
+	"github.com/coredns/coredns/core/dnsserver"
+)
+
+func TestQuicSetup(t *testing.T) {
+	tests := []struct {
+		input                  string
+		shouldErr              bool
+		expectedMaxStreams     *int
+		expectedWorkerPoolSize *int
+		expectedErrContent     string
+	}{
+		// Valid configurations
+		{
+			input:                  `quic`,
+			shouldErr:              false,
+			expectedMaxStreams:     nil,
+			expectedWorkerPoolSize: nil,
+		},
+		{
+			input: `quic {
+			}`,
+			shouldErr:              false,
+			expectedMaxStreams:     nil,
+			expectedWorkerPoolSize: nil,
+		},
+		{
+			input: `quic {
+				max_streams 100
+			}`,
+			shouldErr:              false,
+			expectedMaxStreams:     pint(100),
+			expectedWorkerPoolSize: nil,
+		},
+		{
+			input: `quic {
+				worker_pool_size 1000
+			}`,
+			shouldErr:              false,
+			expectedMaxStreams:     nil,
+			expectedWorkerPoolSize: pint(1000),
+		},
+		{
+			input: `quic {
+				max_streams 100
+				worker_pool_size 1000
+			}`,
+			shouldErr:              false,
+			expectedMaxStreams:     pint(100),
+			expectedWorkerPoolSize: pint(1000),
+		},
+		{
+			input: `quic {
+				# Comment
+			}`,
+			shouldErr:              false,
+			expectedMaxStreams:     nil,
+			expectedWorkerPoolSize: nil,
+		},
+		// Invalid configurations
+		{
+			input:              `quic arg`,
+			shouldErr:          true,
+			expectedErrContent: "Wrong argument count",
+		},
+		{
+			input: `quic {
+				max_streams
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "Wrong argument count",
+		},
+		{
+			input: `quic {
+				max_streams abc
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "invalid max_streams value",
+		},
+		{
+			input: `quic {
+				max_streams 0
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "positive integer",
+		},
+		{
+			input: `quic {
+				max_streams -10
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "positive integer",
+		},
+		{
+			input: `quic {
+				worker_pool_size
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "Wrong argument count",
+		},
+		{
+			input: `quic {
+				worker_pool_size abc
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "invalid worker_pool_size value",
+		},
+		{
+			input: `quic {
+				worker_pool_size 0
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "positive integer",
+		},
+		{
+			input: `quic {
+				worker_pool_size -10
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "positive integer",
+		},
+		{
+			input: `quic {
+				max_streams 100
+				max_streams 200
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "already defined",
+			expectedMaxStreams: pint(100),
+		},
+		{
+			input: `quic {
+				worker_pool_size 1000
+				worker_pool_size 2000
+			}`,
+			shouldErr:              true,
+			expectedErrContent:     "already defined",
+			expectedWorkerPoolSize: pint(1000),
+		},
+		{
+			input: `quic {
+				unknown_directive
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "unknown property",
+		},
+		{
+			input: `quic {
+				max_streams 100 200
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "Wrong argument count",
+		},
+		{
+			input: `quic {
+				worker_pool_size 1000 2000
+			}`,
+			shouldErr:          true,
+			expectedErrContent: "Wrong argument count",
+		},
+	}
+
+	for i, test := range tests {
+		c := caddy.NewTestController("dns", test.input)
+		err := setup(c)
+
+		if test.shouldErr && err == nil {
+			t.Errorf("Test %d (%s): Expected error but found none", i, test.input)
+			continue
+		}
+		if !test.shouldErr && err != nil {
+			t.Errorf("Test %d (%s): Expected no error but found: %v", i, test.input, err)
+			continue
+		}
+
+		if test.shouldErr && !strings.Contains(err.Error(), test.expectedErrContent) {
+			t.Errorf("Test %d (%s): Expected error containing '%s', but got: %v",
+				i, test.input, test.expectedErrContent, err)
+			continue
+		}
+
+		if !test.shouldErr || (test.shouldErr && strings.Contains(test.expectedErrContent, "already defined")) {
+			config := dnsserver.GetConfig(c)
+			assertMaxStreamsValue(t, i, test.input, config.MaxQUICStreams, test.expectedMaxStreams)
+			assertWorkerPoolSizeValue(t, i, test.input, config.MaxQUICWorkerPoolSize, test.expectedWorkerPoolSize)
+		}
+	}
+}
+
+// assertMaxStreamsValue compares the actual MaxQUICStreams value with the expected one
+func assertMaxStreamsValue(t *testing.T, testIndex int, testInput string, actual, expected *int) {
+	if actual == nil && expected == nil {
+		return
+	}
+
+	if (actual == nil) != (expected == nil) {
+		t.Errorf("Test %d (%s): Expected MaxQUICStreams to be %v, but got %v",
+			testIndex, testInput, formatNilableInt(expected), formatNilableInt(actual))
+		return
+	}
+
+	if *actual != *expected {
+		t.Errorf("Test %d (%s): Expected MaxQUICStreams to be %d, but got %d",
+			testIndex, testInput, *expected, *actual)
+	}
+}
+
+// assertWorkerPoolSizeValue compares the actual MaxQUICWorkerPoolSize value with the expected one
+func assertWorkerPoolSizeValue(t *testing.T, testIndex int, testInput string, actual, expected *int) {
+	if actual == nil && expected == nil {
+		return
+	}
+
+	if (actual == nil) != (expected == nil) {
+		t.Errorf("Test %d (%s): Expected MaxQUICWorkerPoolSize to be %v, but got %v",
+			testIndex, testInput, formatNilableInt(expected), formatNilableInt(actual))
+		return
+	}
+
+	if *actual != *expected {
+		t.Errorf("Test %d (%s): Expected MaxQUICWorkerPoolSize to be %d, but got %d",
+			testIndex, testInput, *expected, *actual)
+	}
+}
+
+func formatNilableInt(v *int) string {
+	if v == nil {
+		return "nil"
+	}
+	return fmt.Sprintf("%d", *v)
+}
+
+func pint(i int) *int {
+	return &i
+}
diff --git a/test/quic_test.go b/test/quic_test.go
index 002d232a90..cff86531d9 100644
--- a/test/quic_test.go
+++ b/test/quic_test.go
@@ -7,6 +7,7 @@ import (
 	"errors"
 	"io"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
@@ -22,6 +23,16 @@ var quicCorefile = `quic://.:0 {
 		whoami
 	}`
 
+// Corefile with custom stream limits
+var quicLimitCorefile = `quic://.:0 {
+		tls ../plugin/tls/test_cert.pem ../plugin/tls/test_key.pem ../plugin/tls/test_ca.pem
+		quic {
+			max_streams 5
+			worker_pool_size 10
+		}
+		whoami
+	}`
+
 func TestQUIC(t *testing.T) {
 	q, udp, _, err := CoreDNSServerAndPorts(quicCorefile)
 	if err != nil {
@@ -117,6 +128,184 @@ func TestQUICProtocolError(t *testing.T) {
 	}
 }
 
+// TestQUICStreamLimits tests that the max_streams limit is correctly enforced
+func TestQUICStreamLimits(t *testing.T) {
+	q, udp, _, err := CoreDNSServerAndPorts(quicLimitCorefile)
+	if err != nil {
+		t.Fatalf("Could not get CoreDNS serving instance: %s", err)
+	}
+	defer q.Stop()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	conn, err := quic.DialAddr(ctx, convertAddress(udp), generateTLSConfig(), nil)
+	if err != nil {
+		t.Fatalf("Expected no error but got: %s", err)
+	}
+
+	m := createTestMsg()
+
+	// Test opening exactly the max number of streams
+	var wg sync.WaitGroup
+	streamCount := 5 // Must match max_streams in quicLimitCorefile
+	successCount := 0
+	var mu sync.Mutex
+
+	// Create a slice to store all the streams so we can keep them open
+	streams := make([]quic.Stream, 0, streamCount)
+	streamsMu := sync.Mutex{}
+
+	// Attempt to open exactly the configured number of streams
+	for i := 0; i < streamCount; i++ {
+		wg.Add(1)
+		go func(idx int) {
+			defer wg.Done()
+
+			// Open stream
+			streamSync, err := conn.OpenStreamSync(ctx)
+			if err != nil {
+				t.Logf("Stream %d: Failed to open: %s", idx, err)
+				return
+			}
+
+			// Store the stream so we can keep it open
+			streamsMu.Lock()
+			streams = append(streams, streamSync)
+			streamsMu.Unlock()
+
+			// Write DNS message
+			_, err = streamSync.Write(m)
+			if err != nil {
+				t.Logf("Stream %d: Failed to write: %s", idx, err)
+				return
+			}
+
+			// Read response
+			sizeBuf := make([]byte, 2)
+			_, err = io.ReadFull(streamSync, sizeBuf)
+			if err != nil {
+				t.Logf("Stream %d: Failed to read size: %s", idx, err)
+				return
+			}
+
+			size := binary.BigEndian.Uint16(sizeBuf)
+			buf := make([]byte, size)
+			_, err = io.ReadFull(streamSync, buf)
+			if err != nil {
+				t.Logf("Stream %d: Failed to read response: %s", idx, err)
+				return
+			}
+
+			mu.Lock()
+			successCount++
+			mu.Unlock()
+		}(i)
+	}
+
+	wg.Wait()
+
+	if successCount != streamCount {
+		t.Errorf("Expected all %d streams to succeed, but only %d succeeded", streamCount, successCount)
+	}
+
+	// Now try to open more streams beyond the limit while keeping existing streams open
+	// The QUIC protocol doesn't immediately reject streams; they might be allowed
+	// to open but will be blocked (flow control) until other streams close
+
+	// First, make sure none of our streams have been closed
+	for i, s := range streams {
+		if s == nil {
+			t.Errorf("Stream %d is nil", i)
+			continue
+		}
+	}
+
+	// Try to open a batch of additional streams - with streams limited to 5,
+	// these should either block or be queued but should not allow concurrent use
+	extraCount := 10
+	extraSuccess := 0
+	var extraSuccessMu sync.Mutex
+
+	// Set a shorter timeout for these attempts
+	extraCtx, extraCancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer extraCancel()
+
+	var extraWg sync.WaitGroup
+
+	// Create a channel to signal test completion
+	done := make(chan struct{})
+
+	// Launch goroutines to attempt opening additional streams
+	for i := 0; i < extraCount; i++ {
+		extraWg.Add(1)
+		go func(idx int) {
+			defer extraWg.Done()
+
+			select {
+			case <-done:
+				return // Test is finishing, abandon attempts
+			default:
+				// Continue with the test
+			}
+
+			// Attempt to open an additional stream
+			stream, err := conn.OpenStreamSync(extraCtx)
+			if err != nil {
+				t.Logf("Extra stream %d correctly failed to open: %s", idx, err)
+				return
+			}
+
+			// If we got this far, we managed to open a stream
+			// But we shouldn't be able to use more than max_streams concurrently
+			_, err = stream.Write(m)
+			if err != nil {
+				t.Logf("Extra stream %d failed to write: %s", idx, err)
+				return
+			}
+
+			// Read response
+			sizeBuf := make([]byte, 2)
+			_, err = io.ReadFull(stream, sizeBuf)
+			if err != nil {
+				t.Logf("Extra stream %d failed to read: %s", idx, err)
+				return
+			}
+
+			// This stream completed successfully
+			extraSuccessMu.Lock()
+			extraSuccess++
+			extraSuccessMu.Unlock()
+
+			// Close the stream explicitly
+			_ = stream.Close()
+		}(i)
+	}
+
+	// Start closing original streams after a delay
+	// This should allow extra streams to proceed as slots become available
+	time.Sleep(500 * time.Millisecond)
+
+	// Close all the original streams
+	for _, s := range streams {
+		_ = s.Close()
+	}
+
+	// Allow extra streams some time to progress
+	extraWg.Wait()
+	close(done)
+
+	// Since original streams are now closed, extra streams might succeed
+	// But we shouldn't see more than max_streams succeed during the blocked phase
+	if extraSuccess > streamCount {
+		t.Logf("Warning: %d extra streams succeeded, which is more than the limit of %d. This might be because original streams were closed.",
+			extraSuccess, streamCount)
+	}
+
+	t.Logf("%d/%d extra streams were able to complete after original streams were closed",
+		extraSuccess, extraCount)
+}
+
 func isProtocolErr(err error) bool {
 	var qAppErr *quic.ApplicationError
 	return errors.As(err, &qAppErr) && qAppErr.ErrorCode == 2",
"url": "https://github.com/coredns/coredns/commit/efaed02c6a480ec147b1f799aab7cf815b17dfe1.patch"
}
] | null |
CVE-2022-42895
|
Info Leak in l2cap_core in the Linux Kernel
|
There is an infoleak vulnerability in the Linux kernel's net/bluetooth/l2cap_core.c's l2cap_parse_conf_req function which can be used to leak kernel pointers remotely.
We recommend upgrading past commit https://github.com/torvalds/linux/commit/b1a2cd50c0357f243b7435a732b4e62ba3157a2e https://www.google.com/url
|
[
{
"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: [email protected] Reported-by: Tamás Koczka <[email protected]> Signed-off-by: Luiz Augusto von Dentz <[email protected]> Reviewed-by: Tedd Ho-Jeong An <[email protected]> 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"
}
] |
CWE-824 Access of Uninitialized Pointer
|
CVE-2015-1039
|
Cross-site scripting (XSS) vulnerability in user/login.phtml in ZF-Commons ZfcUser before 1.2.2 allows remote attackers to inject arbitrary web script or HTML via the redirect parameter.
|
[
{
"commit_message": "[PATCH] Fix XSS vulnerability view/zfc-user/user/login.phtml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSBiYWYwZTQ2MDc5NmVhOTJmNmM5MDJmYTliMDA3MTkwYmNjZmYyYjhmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5pZWxzczg5IDxEYW5pZWxzczg5QGdtYWlsLmNvbT4KRGF0ZTogVGh1LCA4IEphbiAyMDE1IDE0OjE4OjQ1ICswMTAwClN1YmplY3Q6IFtQQVRDSF0gRml4IFhTUyB2dWxuZXJhYmlsaXR5CgotLS0KIHZpZXcvemZjLXVzZXIvdXNlci9sb2dpbi5waHRtbCB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL3ZpZXcvemZjLXVzZXIvdXNlci9sb2dpbi5waHRtbCBiL3ZpZXcvemZjLXVzZXIvdXNlci9sb2dpbi5waHRtbAppbmRleCAzZDFkZjNiZC4uNjZkYmZkNjggMTAwNjQ0Ci0tLSBhL3ZpZXcvemZjLXVzZXIvdXNlci9sb2dpbi5waHRtbAorKysgYi92aWV3L3pmYy11c2VyL3VzZXIvbG9naW4ucGh0bWwKQEAgLTI4LDUgKzI4LDUgQEAgJGZvcm0tPnNldEF0dHJpYnV0ZSgnbWV0aG9kJywgJ3Bvc3QnKTsKIDw/cGhwIGVjaG8gJHRoaXMtPmZvcm0oKS0+Y2xvc2VUYWcoKSA/PgogCiA8P3BocCBpZiAoJHRoaXMtPmVuYWJsZVJlZ2lzdHJhdGlvbikgOiA/PgotPD9waHAgZWNobyAkdGhpcy0+dHJhbnNsYXRlKCdOb3QgcmVnaXN0ZXJlZD8nKTsgPz4gPGEgaHJlZj0iPD9waHAgZWNobyAkdGhpcy0+dXJsKCd6ZmN1c2VyL3JlZ2lzdGVyJykgLiAoJHRoaXMtPnJlZGlyZWN0ID8gJz9yZWRpcmVjdD0nLiR0aGlzLT5yZWRpcmVjdCA6ICcnKSA/PiI+PD9waHAgZWNobyAkdGhpcy0+dHJhbnNsYXRlKCdTaWduIHVwIScpOyA/PjwvYT4KKzw/cGhwIGVjaG8gJHRoaXMtPnRyYW5zbGF0ZSgnTm90IHJlZ2lzdGVyZWQ/Jyk7ID8+IDxhIGhyZWY9Ijw/cGhwIGVjaG8gJHRoaXMtPnVybCgnemZjdXNlci9yZWdpc3RlcicpIC4gKCR0aGlzLT5yZWRpcmVjdCA/ICc/cmVkaXJlY3Q9Jy4kdGhpcy0+ZXNjYXBlVXJsKCR0aGlzLT5yZWRpcmVjdCkgOiAnJykgPz4iPjw/cGhwIGVjaG8gJHRoaXMtPnRyYW5zbGF0ZSgnU2lnbiB1cCEnKTsgPz48L2E+CiA8P3BocCBlbmRpZjsgPz4=",
"url": "https://github.com/ZF-Commons/ZfcUser/commit/baf0e460.patch"
}
] |
n/a
|
|
GHSA-f2g6-6jfq-w6cj
| null |
[
{
"commit_message": "[PATCH] xss fix from Steven Chamberlain lib/Smokeping.pm | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSBiYWQ5ZjljMjhmMDkzOWIyNjlmOTAwNzJhYTRjZjQxZjIwZjE1NTYzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb2JpYXMgT2V0aWtlciA8dG9iaUBvZXRpa2VyLmNoPgpEYXRlOiBTdW4sIDE3IE1hciAyMDEzIDEzOjExOjEwICswMTAwClN1YmplY3Q6IFtQQVRDSF0geHNzIGZpeCBmcm9tIFN0ZXZlbiBDaGFtYmVybGFpbgoKLS0tCiBsaWIvU21va2VwaW5nLnBtIHwgNSArKystLQogMSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9saWIvU21va2VwaW5nLnBtIGIvbGliL1Ntb2tlcGluZy5wbQppbmRleCBjZWMxMzBhMi4uMDgwYjUzOGIgMTAwNjQ0Ci0tLSBhL2xpYi9TbW9rZXBpbmcucG0KKysrIGIvbGliL1Ntb2tlcGluZy5wbQpAQCAtMTAyOCw4ICsxMDI4LDkgQEAgc3ViIHNtb2tlY29sICgkKSB7CiAKIHN1YiBwYXJzZV9kYXRldGltZSgkKXsKICAgICBteSAkaW4gPSBzaGlmdDsKLSAgICBmb3IgKCRpbil7Ci0JL14oXGQrKSQvICYmIGRvIHsgbXkgJHZhbHVlID0gJDE7ICR2YWx1ZSA9IHRpbWUgaWYgJHZhbHVlID4gMioqMzI7IHJldHVybiAkdmFsdWV9OworICAgIGZvciAoJGluKXsgCisgICAgICAgICRpbiA9fiBzLyR4c3NCYWRSeC9fL2c7CisgICAgICAgIC9eKFxkKykkLyAmJiBkbyB7IG15ICR2YWx1ZSA9ICQxOyAkdmFsdWUgPSB0aW1lIGlmICR2YWx1ZSA+IDIqKjMyOyByZXR1cm4gJHZhbHVlfTsKICAgICAgICAgL15ccyooXGR7NH0pLShcZHsxLDJ9KS0oXGR7MSwyfSkoPzpccysoXGR7MSwyfSk6KFxkezJ9KSg/OjooXGR7Mn0pKT8pP1xzKiQvICAmJiAKICAgICAgICAgICAgIHJldHVybiBQT1NJWDo6bWt0aW1lKCQ2fHwwLCQ1fHwwLCQ0fHwwLCQzLCQyLTEsJDEtMTkwMCwwLDAsLTEpOwogICAgICAgICAvXm5vdyQvICYmIHJldHVybiB0aW1lOw==",
"url": "https://github.com/oetiker/SmokePing/commit/bad9f9c28f0939b269f90072aa4cf41f20f15563.patch"
}
] | null |
|
GHSA-mv89-p3h4-x57h
| null |
[
{
"commit_message": "[PATCH] [FIX] 0027430 Modules/File/classes/class.ilObjFileGUI.php | 13 +++---------- Services/Utilities/classes/class.ilFileUtils.php | 2 +- lang/ilias_de.lang | 3 ++- lang/ilias_en.lang | 1 + 4 files changed, 7 insertions(+), 12 deletions(-)",
"patch_text_b64": "From 94d9b16010ec3abeae8d2cbb05622ccd999119ad Mon Sep 17 00:00:00 2001
From: Fabian Schmid <fs@studer-raimann.ch>
Date: Mon, 18 May 2020 17:01:57 +0200
Subject: [PATCH] [FIX] 0027430

---
 Modules/File/classes/class.ilObjFileGUI.php      | 13 +++----------
 Services/Utilities/classes/class.ilFileUtils.php |  2 +-
 lang/ilias_de.lang                               |  3 ++-
 lang/ilias_en.lang                               |  1 +
 4 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/Modules/File/classes/class.ilObjFileGUI.php b/Modules/File/classes/class.ilObjFileGUI.php
index f63960831675..08740d381a9a 100755
--- a/Modules/File/classes/class.ilObjFileGUI.php
+++ b/Modules/File/classes/class.ilObjFileGUI.php
@@ -36,6 +36,7 @@ public function __construct($a_id = 0, $a_id_type = self::REPOSITORY_NODE_ID, $a
     {
         $this->log = ilLoggerFactory::getLogger('file');
         parent::__construct($a_id, $a_id_type, $a_parent_node_id);
+        $this->lng->loadLanguageModule('file');
     }
 
 
@@ -187,7 +188,6 @@ protected function initCreationForms($a_new_type)
 
         if ($this->id_type == self::WORKSPACE_NODE_ID) {
             if (!ilDiskQuotaHandler::isUploadPossible()) {
-                $this->lng->loadLanguageModule("file");
                 ilUtil::sendFailure($this->lng->txt("personal_workspace_quota_exceeded_warning"), true);
                 $this->ctrl->redirect($this, "cancel");
             }
@@ -564,8 +564,6 @@ public function edit()
      */
     protected function initPropertiesForm($mode = "create")
     {
-        $this->lng->loadLanguageModule('file');
-
         $form = new ilPropertyFormGUI();
         $form->setFormAction($this->ctrl->getFormAction($this, 'update'));
         $form->setTitle($this->lng->txt('file_edit'));
@@ -706,9 +704,6 @@ public function infoScreenForward()
         $info = new ilInfoScreenGUI($this);
 
         if ($this->checkPermissionBool("read", "sendfile")) {
-            // #9876
-            $this->lng->loadLanguageModule("file");
-
             // #14378
             include_once "Services/UIComponent/Button/classes/class.ilLinkButton.php";
             $button = ilLinkButton::getInstance();
@@ -763,7 +758,6 @@ public function infoScreenForward()
         $uploader = array_shift($uploader);
         $uploader = $uploader["user_id"];
 
-        $this->lng->loadLanguageModule("file");
         include_once "Services/User/classes/class.ilUserUtil.php";
         $info->addProperty($this->lng->txt("file_uploaded_by"), ilUserUtil::getNamePresentation($uploader));
 
@@ -1008,7 +1002,7 @@ public function uploadFiles()
                     }
                 }
             } catch (Exception $ex) {
-                $response->error = $ex->getMessage();
+                $response->error = $this->lng->txt('general_upload_error_occured');
             }
         } else {
             $dnd_input = $dnd_form_gui->getItemByPostVar("upload_files");
@@ -1031,7 +1025,6 @@ public function uploadFiles()
         if ($DIC->upload()->hasBeenProcessed()) {
             foreach ($DIC->upload()->getResults() as $result) {
                 if (!ilFileUtils::hasValidExtension($result->getName())) {
-                    $this->lng->loadLanguageModule('file');
                     ilUtil::sendInfo(
                         $this->lng->txt('file_upload_info_file_with_critical_unknown_extension_later_renamed_when_downloading'),
                         true
@@ -1155,7 +1148,7 @@ protected function handleFileUpload($file_upload)
             } catch (ilFileUtilsException $e) {
                 $response->error = $e->getMessage();
             } catch (Exception $ex) {
-                $response->error = $ex->getMessage();
+                $response->error = $this->lng->txt('general_upload_error_occured');
             }
 
             ilUtil::delDir($newDir);
diff --git a/Services/Utilities/classes/class.ilFileUtils.php b/Services/Utilities/classes/class.ilFileUtils.php
index b296c832ced0..d3dd6c8aa67b 100644
--- a/Services/Utilities/classes/class.ilFileUtils.php
+++ b/Services/Utilities/classes/class.ilFileUtils.php
@@ -882,7 +882,7 @@ public static function rename($a_source, $a_target)
         $pi = pathinfo($a_target);
         if (!in_array(strtolower($pi["extension"]), self::getValidExtensions())) {
             include_once("./Services/Utilities/classes/class.ilFileUtilsException.php");
-            throw new ilFileUtilsException("Invalid target file " . $pi["basename"] . ".");
+            throw new ilFileUtilsException("Invalid target file");
         }
 
         return rename($a_source, $a_target);
diff --git a/lang/ilias_de.lang b/lang/ilias_de.lang
index 8aa678b0302b..0fd2cc8a4286 100644
--- a/lang/ilias_de.lang
+++ b/lang/ilias_de.lang
@@ -8530,7 +8530,8 @@ feed#:#feed_no_valid_url#:#Die URL des Webfeeds ist nicht gültig.
 feed#:#feed_nr_pd_feeds#:#Anzahl externer Webfeeds auf dem Persönlichen Schreibtisch
 feed#:#feed_nr_pd_feeds_info#:#Bestimmt die maximale Anzahl externer Webfeeds, die ein Benutzer auf seinen Persönlichen Schreibtisch legen kann.
 feed#:#feed_open_source_page#:#Gehe zur externen Nachricht
-feed#:#feed_settings#:#Externe Webfeeds
+feed#:#feed_settings#:#Externe Webfeeds^
+file#:#general_upload_error_occured#:#Beim Verarbeiten der Datei ist ein unerwartetet Fehler aufgetreten.
 file#:#enable_personal_workspace_disk_quota#:#Disk-Quota für den Persönlichen Arbeitsraum aktivieren
 file#:#enable_personal_workspace_disk_quota_info#:#Erlaubt die Begrenzung des verfügbaren Plattenplatzes für jedes Benutzerkonto und jede globale Rolle. Dies betrifft nur Dateien im persönlichen Arbeitsraum und in Portfolios. Sobald ein Benutzer die definierte Disk-Quota erreicht, kann dieser keine weiteren Dateien mehr hochladen.
 file#:#file_copy#:#Datei kopieren
diff --git a/lang/ilias_en.lang b/lang/ilias_en.lang
index 0ecaccd15f69..738c055840bc 100644
--- a/lang/ilias_en.lang
+++ b/lang/ilias_en.lang
@@ -10969,6 +10969,7 @@ crs#:#event_list_registered_only#:#Only Registered
 didactic#:#didactic_default_type#:#Default
 pd#:#pd_info_delete_sure_remove#:#Are you sure you want to remove the following objects from your Personal Desktop?
 pd#:#pd_info_delete_sure_unsubscribe#:#Are you sure you want to unsubscribe from the following objects?
+file#:#general_upload_error_occured#:#An unexpected error occured during upload.
 file#:#enable_personal_workspace_disk_quota#:#Activate Hard Quota for Personal Workspace
 file#:#enable_personal_workspace_disk_quota_info#:#Allows definition of a hard disk quota for each user account and each global role. This quota only affects files in the personal workspace and in portfolios. As soon as a user exceeds the defined quota, ILIAS will prohibit the user to upload more files until the used disk space is again under quota.
 file#:#personal_workspace_disk_quota#:#Hard Disk Quota for Personal Workspace",
"url": "https://github.com/ILIAS-eLearning/ILIAS/commit/94d9b16010ec3abeae8d2cbb05622ccd999119ad.patch"
}
] | null |
|
CVE-2022-0932
|
Missing Authorization in saleor/saleor
|
Missing Authorization in GitHub repository saleor/saleor prior to 3.1.2.
|
[
{
"commit_message": "[PATCH] Require manage orders for fetching `user.orders` (#9128) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Require manage orders for fetching customer.orders * Update changelog Co-authored-by: Marcin Gębala <[email protected]> CHANGELOG.md | 3 + .../account/tests/benchmark/test_account.py | 9 +- saleor/graphql/account/tests/test_account.py | 93 +++++++++++++++++-- saleor/graphql/account/types.py | 10 +- 4 files changed, 104 insertions(+), 11 deletions(-)",
"patch_text_b64": "From 521dfd6394f3926a77c60d8633c058e16d0f916d Mon Sep 17 00:00:00 2001
From: Iga Karbowiak <40886528+IKarbowiak@users.noreply.github.com>
Date: Tue, 1 Mar 2022 09:33:10 +0100
Subject: [PATCH] Require manage orders for fetching `user.orders` (#9128)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Require manage orders for fetching customer.orders

* Update changelog

Co-authored-by: Marcin Gębala <5421321+maarcingebala@users.noreply.github.com>
---
 CHANGELOG.md                                  |  3 +
 .../account/tests/benchmark/test_account.py   |  9 +-
 saleor/graphql/account/tests/test_account.py  | 93 +++++++++++++++++--
 saleor/graphql/account/types.py               | 10 +-
 4 files changed, 104 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c378fde9793..77360bc1274 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,9 @@ All notable, unreleased changes to this project will be documented in this file.
 # Unreleased
 
 ### Breaking changes
+- Require manage orders for fetching `user.orders` - #9128 by @IKarbowiak
+  - only staff with `manage orders` and can fetch customer orders
+  - the customer can fetch his own orders, except drafts
 
 ### Other changes
 - Filter Customer/Order/Sale/Product/ProductVariant by datetime of last modification - #9137 by @rafalp
diff --git a/saleor/graphql/account/tests/benchmark/test_account.py b/saleor/graphql/account/tests/benchmark/test_account.py
index 34d5b71da92..187616a7253 100644
--- a/saleor/graphql/account/tests/benchmark/test_account.py
+++ b/saleor/graphql/account/tests/benchmark/test_account.py
@@ -105,7 +105,9 @@ def test_query_staff_user(
     user_id = graphene.Node.to_global_id("User", staff_user.pk)
     variables = {"id": user_id}
     response = staff_api_client.post_graphql(
-        query, variables, permissions=[permission_manage_staff]
+        query,
+        variables,
+        permissions=[permission_manage_staff, permission_manage_orders],
     )
     content = get_graphql_content(response)
     data = content["data"]["user"]
@@ -352,10 +354,13 @@ def test_delete_staff_members(
 def test_customers_query(
     staff_api_client,
     permission_manage_users,
+    permission_manage_orders,
     users_for_customers_benchmarks,
     count_queries,
 ):
-    staff_api_client.user.user_permissions.set([permission_manage_users])
+    staff_api_client.user.user_permissions.set(
+        [permission_manage_users, permission_manage_orders]
+    )
     content = get_graphql_content(staff_api_client.post_graphql(CUSTOMERS_QUERY))
     assert content["data"]["customers"] is not None
 
diff --git a/saleor/graphql/account/tests/test_account.py b/saleor/graphql/account/tests/test_account.py
index f816df34ce7..bd1cfd45b27 100644
--- a/saleor/graphql/account/tests/test_account.py
+++ b/saleor/graphql/account/tests/test_account.py
@@ -181,6 +181,7 @@ def test_query_customer_user(
     gift_card_expiry_date,
     address,
     permission_manage_users,
+    permission_manage_orders,
     media_root,
     settings,
 ):
@@ -199,7 +200,9 @@ def test_query_customer_user(
     query = FULL_USER_QUERY
     ID = graphene.Node.to_global_id("User", customer_user.id)
     variables = {"id": ID}
-    staff_api_client.user.user_permissions.add(permission_manage_users)
+    staff_api_client.user.user_permissions.add(
+        permission_manage_users, permission_manage_orders
+    )
     response = staff_api_client.post_graphql(query, variables)
     content = get_graphql_content(response)
     data = content["data"]["user"]
@@ -268,6 +271,7 @@ def test_query_customer_user_with_orders(
     customer_user,
     order_list,
     permission_manage_users,
+    permission_manage_orders,
 ):
     # given
     query = FULL_USER_QUERY
@@ -291,24 +295,61 @@ def test_query_customer_user_with_orders(
 
     # when
     response = staff_api_client.post_graphql(
-        query, variables, permissions=[permission_manage_users]
+        query,
+        variables,
+        permissions=[permission_manage_users, permission_manage_orders],
     )
 
     # then
     content = get_graphql_content(response)
     user = content["data"]["user"]
     assert {order["node"]["id"] for order in user["orders"]["edges"]} == {
-        graphene.Node.to_global_id("Order", order.pk)
-        for order in [order_unfulfilled, order_unconfirmed]
+        graphene.Node.to_global_id("Order", order.pk) for order in order_list
     }
 
 
+def test_query_customer_user_with_orders_no_manage_orders_perm(
+    staff_api_client,
+    customer_user,
+    order_list,
+    permission_manage_users,
+):
+    # given
+    query = FULL_USER_QUERY
+    order_unfulfilled = order_list[0]
+    order_unfulfilled.user = customer_user
+
+    order_unconfirmed = order_list[1]
+    order_unconfirmed.status = OrderStatus.UNCONFIRMED
+    order_unconfirmed.user = customer_user
+
+    order_draft = order_list[2]
+    order_draft.status = OrderStatus.DRAFT
+    order_draft.user = customer_user
+
+    Order.objects.bulk_update(
+        [order_unconfirmed, order_draft, order_unfulfilled], ["user", "status"]
+    )
+
+    id = graphene.Node.to_global_id("User", customer_user.id)
+    variables = {"id": id}
+
+    # when
+    response = staff_api_client.post_graphql(
+        query, variables, permissions=[permission_manage_users]
+    )
+
+    # then
+    assert_no_permission(response)
+
+
 def test_query_customer_user_app(
     app_api_client,
     customer_user,
     address,
     permission_manage_users,
     permission_manage_staff,
+    permission_manage_orders,
     media_root,
     app,
 ):
@@ -327,7 +368,9 @@ def test_query_customer_user_app(
     query = FULL_USER_QUERY
     ID = graphene.Node.to_global_id("User", customer_user.id)
     variables = {"id": ID}
-    app.permissions.add(permission_manage_staff, permission_manage_users)
+    app.permissions.add(
+        permission_manage_staff, permission_manage_users, permission_manage_orders
+    )
     response = app_api_client.post_graphql(query, variables)
 
     content = get_graphql_content(response)
@@ -365,6 +408,41 @@ def test_query_customer_user_app_no_permission(
     assert_no_permission(response)
 
 
+def test_query_customer_user_with_orders_by_app_no_manage_orders_perm(
+    app_api_client,
+    customer_user,
+    order_list,
+    permission_manage_users,
+):
+    # given
+    query = FULL_USER_QUERY
+    order_unfulfilled = order_list[0]
+    order_unfulfilled.user = customer_user
+
+    order_unconfirmed = order_list[1]
+    order_unconfirmed.status = OrderStatus.UNCONFIRMED
+    order_unconfirmed.user = customer_user
+
+    order_draft = order_list[2]
+    order_draft.status = OrderStatus.DRAFT
+    order_draft.user = customer_user
+
+    Order.objects.bulk_update(
+        [order_unconfirmed, order_draft, order_unfulfilled], ["user", "status"]
+    )
+
+    id = graphene.Node.to_global_id("User", customer_user.id)
+    variables = {"id": id}
+
+    # when
+    response = app_api_client.post_graphql(
+        query, variables, permissions=[permission_manage_users]
+    )
+
+    # then
+    assert_no_permission(response)
+
+
 def test_query_staff_user(
     staff_api_client,
     staff_user,
@@ -993,6 +1071,7 @@ def test_user_with_cancelled_fulfillments(
     staff_api_client,
     customer_user,
     permission_manage_users,
+    permission_manage_orders,
     fulfilled_order_with_cancelled_fulfillment,
 ):
     query = """
@@ -1013,7 +1092,9 @@ def test_user_with_cancelled_fulfillments(
     """
     user_id = graphene.Node.to_global_id("User", customer_user.id)
     variables = {"id": user_id}
-    staff_api_client.user.user_permissions.add(permission_manage_users)
+    staff_api_client.user.user_permissions.add(
+        permission_manage_users, permission_manage_orders
+    )
     response = staff_api_client.post_graphql(query, variables)
     content = get_graphql_content(response)
     order_id = graphene.Node.to_global_id(
diff --git a/saleor/graphql/account/types.py b/saleor/graphql/account/types.py
index 4fbe2d179bf..680d57e055c 100644
--- a/saleor/graphql/account/types.py
+++ b/saleor/graphql/account/types.py
@@ -364,9 +364,13 @@ def resolve_orders(root: models.User, info, **kwargs):
         def _resolve_orders(orders):
             requester = get_user_or_app_from_context(info.context)
             if not requester.has_perm(OrderPermissions.MANAGE_ORDERS):
-                orders = list(
-                    filter(lambda order: order.status != OrderStatus.DRAFT, orders)
-                )
+                # allow fetch requestor orders (except drafts)
+                if root == info.context.user:
+                    orders = list(
+                        filter(lambda order: order.status != OrderStatus.DRAFT, orders)
+                    )
+                else:
+                    raise PermissionDenied()
 
             return create_connection_slice(
                 orders, info, kwargs, OrderCountableConnection",
"url": "https://github.com/saleor/saleor/commit/521dfd6394f3926a77c60d8633c058e16d0f916d.patch"
}
] |
CWE-862 Missing Authorization
|
CVE-2012-10007
|
madgicweb BuddyStream Plugin ShareBox.php cross site scripting
|
A vulnerability was found in madgicweb BuddyStream Plugin up to 3.2.7 on WordPress. It has been declared as problematic. Affected by this vulnerability is an unknown functionality of the file ShareBox.php. The manipulation of the argument content/link/shares leads to cross site scripting. The attack can be launched remotely. Upgrading to version 3.2.8 is able to address this issue. The patch is named 7d5b9a89a27711aad76fd55ab4cc4185b545a1d0. It is recommended to upgrade the affected component. The associated identifier of this vulnerability is VDB-221479.
|
[
{
"commit_message": "[PATCH] fixed vulnerability git-svn-id: https://plugins.svn.wordpress.org/buddystream/trunk@634128 b8457f37-d9ea-0310-8a92-e5e31aec5664 buddystream.php | 4 ++-- extensions/default/templates/ShareBox.php | 10 +++++----- readme.txt | 7 +++++-- 3 files changed, 12 insertions(+), 9 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/madgicweb/buddystream/commit/7d5b9a89a27711aad76fd55ab4cc4185b545a1d0.patch"
}
] |
CWE-79 Cross Site Scripting
|
CVE-2019-11514
|
User/Command/ConfirmEmailHandler.php in Flarum before 0.1.0-beta.8 mishandles invalidation of user email tokens.
|
[
{
"commit_message": "[PATCH] Always invalidate all user email tokens Reported by B. Dhiyaneshwaran of Geek Freak. src/User/Command/ConfirmEmailHandler.php | 3 ++- src/User/User.php | 10 ++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/flarum/core/commit/66607a56749339d50620b049701ad4d6a4dafbd7.patch"
}
] |
n/a
|
|
GHSA-9m5p-c77c-f9j7
|
DoS in Cilium agent DNS proxy from crafted DNS responses
| null |
[
{
"commit_message": "[PATCH] dnsproxy: bail when extracting info from DNS fails The comment asserted that it's okay to fail to extract information from the DNS query/response. I don't think that's true, since based on the qname and the responseIPs we do policy enforcement. I don't think this happens often, but given the previous commit introduces more cases this can fail, let's be a bit more stringent. Signed-off-by: David Bimmler <[email protected]> daemon/cmd/fqdn.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSAxOTcxYmM2ODRiNmIzNjcwM2ViYWUwZGQ3NTM5YzYyM2Y5ODhhMjU3IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEYXZpZCBCaW1tbGVyIDxkYXZpZC5iaW1tbGVyQGlzb3ZhbGVudC5jb20+CkRhdGU6IFRodSwgNSBEZWMgMjAyNCAxMzozNjoxOSArMDEwMApTdWJqZWN0OiBbUEFUQ0hdIGRuc3Byb3h5OiBiYWlsIHdoZW4gZXh0cmFjdGluZyBpbmZvIGZyb20gRE5TIGZhaWxzCgpUaGUgY29tbWVudCBhc3NlcnRlZCB0aGF0IGl0J3Mgb2theSB0byBmYWlsIHRvIGV4dHJhY3QgaW5mb3JtYXRpb24gZnJvbQp0aGUgRE5TIHF1ZXJ5L3Jlc3BvbnNlLiBJIGRvbid0IHRoaW5rIHRoYXQncyB0cnVlLCBzaW5jZSBiYXNlZCBvbiB0aGUKcW5hbWUgYW5kIHRoZSByZXNwb25zZUlQcyB3ZSBkbyBwb2xpY3kgZW5mb3JjZW1lbnQuCgpJIGRvbid0IHRoaW5rIHRoaXMgaGFwcGVucyBvZnRlbiwgYnV0IGdpdmVuIHRoZSBwcmV2aW91cyBjb21taXQKaW50cm9kdWNlcyBtb3JlIGNhc2VzIHRoaXMgY2FuIGZhaWwsIGxldCdzIGJlIGEgYml0IG1vcmUgc3RyaW5nZW50LgoKU2lnbmVkLW9mZi1ieTogRGF2aWQgQmltbWxlciA8ZGF2aWQuYmltbWxlckBpc292YWxlbnQuY29tPgotLS0KIGRhZW1vbi9jbWQvZnFkbi5nbyB8IDQgKystLQogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kYWVtb24vY21kL2ZxZG4uZ28gYi9kYWVtb24vY21kL2ZxZG4uZ28KaW5kZXggM2EyOGMyYTIxOWUzNi4uYzQ1MTI0MjE5ZDQ4MCAxMDA2NDQKLS0tIGEvZGFlbW9uL2NtZC9mcWRuLmdvCisrKyBiL2RhZW1vbi9jbWQvZnFkbi5nbwpAQCAtMzM3LDggKzMzNyw4IEBAIGZ1bmMgKGQgKkRhZW1vbikgbm90aWZ5T25ETlNNc2cobG9va3VwVGltZSB0aW1lLlRpbWUsIGVwICplbmRwb2ludC5FbmRwb2ludCwgZXBJCiAKIAlxbmFtZSwgcmVzcG9uc2VJUHMsIFRUTCwgQ05BTUVzLCByY29kZSwgcmVjb3JkVHlwZXMsIHFUeXBlcywgZXJyIDo9IGRuc3Byb3h5LkV4dHJhY3RNc2dEZXRhaWxzKG1zZykKIAlpZiBlcnIgIT0gbmlsIHsKLQkJLy8gVGhpcyBlcnJvciBpcyBvayBiZWNhdXNlIGFsbCB0aGVzZSB2YWx1ZXMgYXJlIHVzZWQgZm9yIHJlcG9ydGluZywgb3IgZmlsbGluZyBpbiB0aGUgY2FjaGUuCi0JCWxvZy5XaXRoRXJyb3IoZXJyKS5FcnJvcigiY2Fubm90IGV4dHJhY3QgRE5TIG1lc3NhZ2UgZGV0YWlscyIpCisJCWxvZy5XaXRoRXJyb3IoZXJyKS5XaXRoRmllbGQobG9nZmllbGRzLkROU05hbWUsIHFuYW1lKS5FcnJvcigiY2Fubm90IGV4dHJhY3QgRE5TIG1lc3NhZ2UgZGV0YWlscyIpCisJCXJldHVybiBmbXQuRXJyb3JmKCJmYWlsZWQgdG8gZXh0cmFjdCBETlMgbWVzc2FnZSBkZXRhaWxzOiAldyIsIGVycikKIAl9CiAKIAl2YXIgc2VydmVyUG9ydCB1aW50MTY=",
"url": "https://github.com/cilium/cilium/commit/1971bc684b6b36703ebae0dd7539c623f988a257.patch"
},
{
"commit_message": "[PATCH] fqdn/dnsproxy: validate DNS response IPs Since net.IP is just a slice of bytes, there's no guarantee that it represents a valid IP. Don't assume that the underlying DNS library did any resource validation, because it doesn't. Checking the length is all the validation we can do without potentially breaking stuff, since any 4/6 bytes constitute valid IPs in general. Signed-off-by: David Bimmler <[email protected]> pkg/fqdn/dnsproxy/proxy.go | 6 ++++++ 1 file changed, 6 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/cilium/cilium/commit/b1948e217a4212b81175d8bf763d0ef350fcc96c.patch"
}
] | null |
CVE-2019-15140
|
coders/mat.c in ImageMagick 7.0.8-43 Q16 allows remote attackers to cause a denial of service (use-after-free and application crash) or possibly have unspecified other impact by crafting a Matlab image file that is mishandled in ReadImage in MagickCore/constitute.c.
|
[
{
"commit_message": "[PATCH] https://github.com/ImageMagick/ImageMagick/issues/1554 coders/mat.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/ImageMagick/ImageMagick/commit/f7206618d27c2e69d977abf40e3035a33e5f6be0.patch"
}
] |
n/a
|
|
GHSA-qhx6-hpfj-8m4g
| null |
[
{
"commit_message": "[PATCH] [3.12] gh-119342: Fix a potential denial of service in plistlib (GH-119343) (#142149) Reading a specially prepared small Plist file could cause OOM because file's read(n) preallocates a bytes object for reading the specified amount of data. Now plistlib reads large data by chunks, therefore the upper limit of consumed memory is proportional to the size of the input file. (cherry picked from commit 694922cf40aa3a28f898b5f5ee08b71b4922df70) Lib/plistlib.py | 31 ++++++++++------ Lib/test/test_plistlib.py | 37 +++++++++++++++++-- ...-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst | 5 +++ 3 files changed, 59 insertions(+), 14 deletions(-) create mode 100644 Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst",
"patch_text_b64": "From 5a8b19677d818fb41ee55f310233772e15aa1a2b Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Mon, 22 Dec 2025 15:49:44 +0200
Subject: [PATCH] [3.12] gh-119342: Fix a potential denial of service in
 plistlib (GH-119343) (#142149)

Reading a specially prepared small Plist file could cause OOM because file's
read(n) preallocates a bytes object for reading the specified amount of
data. Now plistlib reads large data by chunks, therefore the upper limit of
consumed memory is proportional to the size of the input file.
(cherry picked from commit 694922cf40aa3a28f898b5f5ee08b71b4922df70)
---
 Lib/plistlib.py                               | 31 ++++++++++------
 Lib/test/test_plistlib.py                     | 37 +++++++++++++++++--
 ...-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst |  5 +++
 3 files changed, 59 insertions(+), 14 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst

diff --git a/Lib/plistlib.py b/Lib/plistlib.py
index 3292c30d5fb29b..c5554ea1f753b0 100644
--- a/Lib/plistlib.py
+++ b/Lib/plistlib.py
@@ -73,6 +73,9 @@
 PlistFormat = enum.Enum('PlistFormat', 'FMT_XML FMT_BINARY', module=__name__)
 globals().update(PlistFormat.__members__)
 
+# Data larger than this will be read in chunks, to prevent extreme
+# overallocation.
+_MIN_READ_BUF_SIZE = 1 << 20
 
 class UID:
     def __init__(self, data):
@@ -499,12 +502,24 @@ def _get_size(self, tokenL):
 
         return tokenL
 
+    def _read(self, size):
+        cursize = min(size, _MIN_READ_BUF_SIZE)
+        data = self._fp.read(cursize)
+        while True:
+            if len(data) != cursize:
+                raise InvalidFileException
+            if cursize == size:
+                return data
+            delta = min(cursize, size - cursize)
+            data += self._fp.read(delta)
+            cursize += delta
+
     def _read_ints(self, n, size):
-        data = self._fp.read(size * n)
+        data = self._read(size * n)
         if size in _BINARY_FORMAT:
             return struct.unpack(f'>{n}{_BINARY_FORMAT[size]}', data)
         else:
-            if not size or len(data) != size * n:
+            if not size:
                 raise InvalidFileException()
             return tuple(int.from_bytes(data[i: i + size], 'big')
                          for i in range(0, size * n, size))
@@ -561,22 +576,16 @@ def _read_object(self, ref):
 
         elif tokenH == 0x40:  # data
             s = self._get_size(tokenL)
-            result = self._fp.read(s)
-            if len(result) != s:
-                raise InvalidFileException()
+            result = self._read(s)
 
         elif tokenH == 0x50:  # ascii string
             s = self._get_size(tokenL)
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('ascii')
 
         elif tokenH == 0x60:  # unicode string
             s = self._get_size(tokenL) * 2
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('utf-16be')
 
         elif tokenH == 0x80:  # UID
diff --git a/Lib/test/test_plistlib.py b/Lib/test/test_plistlib.py
index fa46050658afe0..229a5a242eced3 100644
--- a/Lib/test/test_plistlib.py
+++ b/Lib/test/test_plistlib.py
@@ -841,8 +841,7 @@ def test_xml_plist_with_entity_decl(self):
 
 class TestBinaryPlistlib(unittest.TestCase):
 
-    @staticmethod
-    def decode(*objects, offset_size=1, ref_size=1):
+    def build(self, *objects, offset_size=1, ref_size=1):
         data = [b'bplist00']
         offset = 8
         offsets = []
@@ -854,7 +853,11 @@ def decode(*objects, offset_size=1, ref_size=1):
                            len(objects), 0, offset)
         data.extend(offsets)
         data.append(tail)
-        return plistlib.loads(b''.join(data), fmt=plistlib.FMT_BINARY)
+        return b''.join(data)
+
+    def decode(self, *objects, offset_size=1, ref_size=1):
+        data = self.build(*objects, offset_size=offset_size, ref_size=ref_size)
+        return plistlib.loads(data, fmt=plistlib.FMT_BINARY)
 
     def test_nonstandard_refs_size(self):
         # Issue #21538: Refs and offsets are 24-bit integers
@@ -963,6 +966,34 @@ def test_invalid_binary(self):
                 with self.assertRaises(plistlib.InvalidFileException):
                     plistlib.loads(b'bplist00' + data, fmt=plistlib.FMT_BINARY)
 
+    def test_truncated_large_data(self):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        def check(data):
+            with open(os_helper.TESTFN, 'wb') as f:
+                f.write(data)
+            # buffered file
+            with open(os_helper.TESTFN, 'rb') as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+            # unbuffered file
+            with open(os_helper.TESTFN, 'rb', buffering=0) as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+        for w in range(20, 64):
+            s = 1 << w
+            # data
+            check(self.build(b'\x4f\x13' + s.to_bytes(8, 'big')))
+            # ascii string
+            check(self.build(b'\x5f\x13' + s.to_bytes(8, 'big')))
+            # unicode string
+            check(self.build(b'\x6f\x13' + s.to_bytes(8, 'big')))
+            # array
+            check(self.build(b'\xaf\x13' + s.to_bytes(8, 'big')))
+            # dict
+            check(self.build(b'\xdf\x13' + s.to_bytes(8, 'big')))
+            # number of objects
+            check(b'bplist00' + struct.pack('>6xBBQQQ', 1, 1, s, 0, 8))
+
 
 class TestKeyedArchive(unittest.TestCase):
     def test_keyed_archive_data(self):
diff --git a/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst b/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst
new file mode 100644
index 00000000000000..04fd8faca4cf7e
--- /dev/null
+++ b/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst
@@ -0,0 +1,5 @@
+Fix a potential memory denial of service in the :mod:`plistlib` module.
+When reading a Plist file received from untrusted source, it could cause
+an arbitrary amount of memory to be allocated.
+This could have led to symptoms including a :exc:`MemoryError`, swapping, out
+of memory (OOM) killed processes or containers, or even system crashes.",
"url": "https://github.com/python/cpython/commit/5a8b19677d818fb41ee55f310233772e15aa1a2b.patch"
},
{
"commit_message": "[PATCH] gh-119342: Fix a potential denial of service in plistlib (GH-119343) Reading a specially prepared small Plist file could cause OOM because file's read(n) preallocates a bytes object for reading the specified amount of data. Now plistlib reads large data by chunks, therefore the upper limit of consumed memory is proportional to the size of the input file. Lib/plistlib.py | 31 ++++++++++------ Lib/test/test_plistlib.py | 37 +++++++++++++++++-- ...-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst | 5 +++ 3 files changed, 59 insertions(+), 14 deletions(-) create mode 100644 Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst",
"patch_text_b64": "From 694922cf40aa3a28f898b5f5ee08b71b4922df70 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Mon, 1 Dec 2025 17:28:15 +0200
Subject: [PATCH] gh-119342: Fix a potential denial of service in plistlib
 (GH-119343)

Reading a specially prepared small Plist file could cause OOM because file's
read(n) preallocates a bytes object for reading the specified amount of
data. Now plistlib reads large data by chunks, therefore the upper limit of
consumed memory is proportional to the size of the input file.
---
 Lib/plistlib.py                               | 31 ++++++++++------
 Lib/test/test_plistlib.py                     | 37 +++++++++++++++++--
 ...-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst |  5 +++
 3 files changed, 59 insertions(+), 14 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst

diff --git a/Lib/plistlib.py b/Lib/plistlib.py
index 67e832db217319..655c51eea3da5d 100644
--- a/Lib/plistlib.py
+++ b/Lib/plistlib.py
@@ -73,6 +73,9 @@
 PlistFormat = enum.Enum('PlistFormat', 'FMT_XML FMT_BINARY', module=__name__)
 globals().update(PlistFormat.__members__)
 
+# Data larger than this will be read in chunks, to prevent extreme
+# overallocation.
+_MIN_READ_BUF_SIZE = 1 << 20
 
 class UID:
     def __init__(self, data):
@@ -508,12 +511,24 @@ def _get_size(self, tokenL):
 
         return tokenL
 
+    def _read(self, size):
+        cursize = min(size, _MIN_READ_BUF_SIZE)
+        data = self._fp.read(cursize)
+        while True:
+            if len(data) != cursize:
+                raise InvalidFileException
+            if cursize == size:
+                return data
+            delta = min(cursize, size - cursize)
+            data += self._fp.read(delta)
+            cursize += delta
+
     def _read_ints(self, n, size):
-        data = self._fp.read(size * n)
+        data = self._read(size * n)
         if size in _BINARY_FORMAT:
             return struct.unpack(f'>{n}{_BINARY_FORMAT[size]}', data)
         else:
-            if not size or len(data) != size * n:
+            if not size:
                 raise InvalidFileException()
             return tuple(int.from_bytes(data[i: i + size], 'big')
                          for i in range(0, size * n, size))
@@ -573,22 +588,16 @@ def _read_object(self, ref):
 
         elif tokenH == 0x40:  # data
             s = self._get_size(tokenL)
-            result = self._fp.read(s)
-            if len(result) != s:
-                raise InvalidFileException()
+            result = self._read(s)
 
         elif tokenH == 0x50:  # ascii string
             s = self._get_size(tokenL)
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('ascii')
 
         elif tokenH == 0x60:  # unicode string
             s = self._get_size(tokenL) * 2
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('utf-16be')
 
         elif tokenH == 0x80:  # UID
diff --git a/Lib/test/test_plistlib.py b/Lib/test/test_plistlib.py
index a0c76e5dec5ebe..de2a2fd1fc34bf 100644
--- a/Lib/test/test_plistlib.py
+++ b/Lib/test/test_plistlib.py
@@ -903,8 +903,7 @@ def test_dump_naive_datetime_with_aware_datetime_option(self):
 
 class TestBinaryPlistlib(unittest.TestCase):
 
-    @staticmethod
-    def decode(*objects, offset_size=1, ref_size=1):
+    def build(self, *objects, offset_size=1, ref_size=1):
         data = [b'bplist00']
         offset = 8
         offsets = []
@@ -916,7 +915,11 @@ def decode(*objects, offset_size=1, ref_size=1):
                            len(objects), 0, offset)
         data.extend(offsets)
         data.append(tail)
-        return plistlib.loads(b''.join(data), fmt=plistlib.FMT_BINARY)
+        return b''.join(data)
+
+    def decode(self, *objects, offset_size=1, ref_size=1):
+        data = self.build(*objects, offset_size=offset_size, ref_size=ref_size)
+        return plistlib.loads(data, fmt=plistlib.FMT_BINARY)
 
     def test_nonstandard_refs_size(self):
         # Issue #21538: Refs and offsets are 24-bit integers
@@ -1024,6 +1027,34 @@ def test_invalid_binary(self):
                 with self.assertRaises(plistlib.InvalidFileException):
                     plistlib.loads(b'bplist00' + data, fmt=plistlib.FMT_BINARY)
 
+    def test_truncated_large_data(self):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        def check(data):
+            with open(os_helper.TESTFN, 'wb') as f:
+                f.write(data)
+            # buffered file
+            with open(os_helper.TESTFN, 'rb') as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+            # unbuffered file
+            with open(os_helper.TESTFN, 'rb', buffering=0) as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+        for w in range(20, 64):
+            s = 1 << w
+            # data
+            check(self.build(b'\x4f\x13' + s.to_bytes(8, 'big')))
+            # ascii string
+            check(self.build(b'\x5f\x13' + s.to_bytes(8, 'big')))
+            # unicode string
+            check(self.build(b'\x6f\x13' + s.to_bytes(8, 'big')))
+            # array
+            check(self.build(b'\xaf\x13' + s.to_bytes(8, 'big')))
+            # dict
+            check(self.build(b'\xdf\x13' + s.to_bytes(8, 'big')))
+            # number of objects
+            check(b'bplist00' + struct.pack('>6xBBQQQ', 1, 1, s, 0, 8))
+
     def test_load_aware_datetime(self):
         data = (b'bplist003B\x04>\xd0d\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00'
                 b'\x01\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00'
diff --git a/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst b/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst
new file mode 100644
index 00000000000000..04fd8faca4cf7e
--- /dev/null
+++ b/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst
@@ -0,0 +1,5 @@
+Fix a potential memory denial of service in the :mod:`plistlib` module.
+When reading a Plist file received from untrusted source, it could cause
+an arbitrary amount of memory to be allocated.
+This could have led to symptoms including a :exc:`MemoryError`, swapping, out
+of memory (OOM) killed processes or containers, or even system crashes.",
"url": "https://github.com/python/cpython/commit/694922cf40aa3a28f898b5f5ee08b71b4922df70.patch"
},
{
"commit_message": "<[email protected]> [PATCH] [3.13] gh-119342: Fix a potential denial of service in plistlib (GH-119343) (GH-142144) Reading a specially prepared small Plist file could cause OOM because file's read(n) preallocates a bytes object for reading the specified amount of data. Now plistlib reads large data by chunks, therefore the upper limit of consumed memory is proportional to the size of the input file. (cherry picked from commit 694922cf40aa3a28f898b5f5ee08b71b4922df70) Co-authored-by: Serhiy Storchaka <[email protected]> Lib/plistlib.py | 31 ++++++++++------ Lib/test/test_plistlib.py | 37 +++++++++++++++++-- ...-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst | 5 +++ 3 files changed, 59 insertions(+), 14 deletions(-) create mode 100644 Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst",
"patch_text_b64": "From 71fa8eb8233b37f16c88b6e3e583b461b205d1ba Mon Sep 17 00:00:00 2001
From: "Miss Islington (bot)"
 <31488909+miss-islington@users.noreply.github.com>
Date: Mon, 1 Dec 2025 16:50:28 +0100
Subject: [PATCH] [3.13] gh-119342: Fix a potential denial of service in
 plistlib (GH-119343) (GH-142144)

Reading a specially prepared small Plist file could cause OOM because file's
read(n) preallocates a bytes object for reading the specified amount of
data. Now plistlib reads large data by chunks, therefore the upper limit of
consumed memory is proportional to the size of the input file.
(cherry picked from commit 694922cf40aa3a28f898b5f5ee08b71b4922df70)

Co-authored-by: Serhiy Storchaka <storchaka@gmail.com>
---
 Lib/plistlib.py                               | 31 ++++++++++------
 Lib/test/test_plistlib.py                     | 37 +++++++++++++++++--
 ...-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst |  5 +++
 3 files changed, 59 insertions(+), 14 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst

diff --git a/Lib/plistlib.py b/Lib/plistlib.py
index 67e832db217319..655c51eea3da5d 100644
--- a/Lib/plistlib.py
+++ b/Lib/plistlib.py
@@ -73,6 +73,9 @@
 PlistFormat = enum.Enum('PlistFormat', 'FMT_XML FMT_BINARY', module=__name__)
 globals().update(PlistFormat.__members__)
 
+# Data larger than this will be read in chunks, to prevent extreme
+# overallocation.
+_MIN_READ_BUF_SIZE = 1 << 20
 
 class UID:
     def __init__(self, data):
@@ -508,12 +511,24 @@ def _get_size(self, tokenL):
 
         return tokenL
 
+    def _read(self, size):
+        cursize = min(size, _MIN_READ_BUF_SIZE)
+        data = self._fp.read(cursize)
+        while True:
+            if len(data) != cursize:
+                raise InvalidFileException
+            if cursize == size:
+                return data
+            delta = min(cursize, size - cursize)
+            data += self._fp.read(delta)
+            cursize += delta
+
     def _read_ints(self, n, size):
-        data = self._fp.read(size * n)
+        data = self._read(size * n)
         if size in _BINARY_FORMAT:
             return struct.unpack(f'>{n}{_BINARY_FORMAT[size]}', data)
         else:
-            if not size or len(data) != size * n:
+            if not size:
                 raise InvalidFileException()
             return tuple(int.from_bytes(data[i: i + size], 'big')
                          for i in range(0, size * n, size))
@@ -573,22 +588,16 @@ def _read_object(self, ref):
 
         elif tokenH == 0x40:  # data
             s = self._get_size(tokenL)
-            result = self._fp.read(s)
-            if len(result) != s:
-                raise InvalidFileException()
+            result = self._read(s)
 
         elif tokenH == 0x50:  # ascii string
             s = self._get_size(tokenL)
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('ascii')
 
         elif tokenH == 0x60:  # unicode string
             s = self._get_size(tokenL) * 2
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('utf-16be')
 
         elif tokenH == 0x80:  # UID
diff --git a/Lib/test/test_plistlib.py b/Lib/test/test_plistlib.py
index 001f86f2893f2f..3813227bd93964 100644
--- a/Lib/test/test_plistlib.py
+++ b/Lib/test/test_plistlib.py
@@ -904,8 +904,7 @@ def test_dump_naive_datetime_with_aware_datetime_option(self):
 
 class TestBinaryPlistlib(unittest.TestCase):
 
-    @staticmethod
-    def decode(*objects, offset_size=1, ref_size=1):
+    def build(self, *objects, offset_size=1, ref_size=1):
         data = [b'bplist00']
         offset = 8
         offsets = []
@@ -917,7 +916,11 @@ def decode(*objects, offset_size=1, ref_size=1):
                            len(objects), 0, offset)
         data.extend(offsets)
         data.append(tail)
-        return plistlib.loads(b''.join(data), fmt=plistlib.FMT_BINARY)
+        return b''.join(data)
+
+    def decode(self, *objects, offset_size=1, ref_size=1):
+        data = self.build(*objects, offset_size=offset_size, ref_size=ref_size)
+        return plistlib.loads(data, fmt=plistlib.FMT_BINARY)
 
     def test_nonstandard_refs_size(self):
         # Issue #21538: Refs and offsets are 24-bit integers
@@ -1025,6 +1028,34 @@ def test_invalid_binary(self):
                 with self.assertRaises(plistlib.InvalidFileException):
                     plistlib.loads(b'bplist00' + data, fmt=plistlib.FMT_BINARY)
 
+    def test_truncated_large_data(self):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        def check(data):
+            with open(os_helper.TESTFN, 'wb') as f:
+                f.write(data)
+            # buffered file
+            with open(os_helper.TESTFN, 'rb') as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+            # unbuffered file
+            with open(os_helper.TESTFN, 'rb', buffering=0) as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+        for w in range(20, 64):
+            s = 1 << w
+            # data
+            check(self.build(b'\x4f\x13' + s.to_bytes(8, 'big')))
+            # ascii string
+            check(self.build(b'\x5f\x13' + s.to_bytes(8, 'big')))
+            # unicode string
+            check(self.build(b'\x6f\x13' + s.to_bytes(8, 'big')))
+            # array
+            check(self.build(b'\xaf\x13' + s.to_bytes(8, 'big')))
+            # dict
+            check(self.build(b'\xdf\x13' + s.to_bytes(8, 'big')))
+            # number of objects
+            check(b'bplist00' + struct.pack('>6xBBQQQ', 1, 1, s, 0, 8))
+
     def test_load_aware_datetime(self):
         data = (b'bplist003B\x04>\xd0d\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00'
                 b'\x01\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00'
diff --git a/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst b/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst
new file mode 100644
index 00000000000000..04fd8faca4cf7e
--- /dev/null
+++ b/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst
@@ -0,0 +1,5 @@
+Fix a potential memory denial of service in the :mod:`plistlib` module.
+When reading a Plist file received from untrusted source, it could cause
+an arbitrary amount of memory to be allocated.
+This could have led to symptoms including a :exc:`MemoryError`, swapping, out
+of memory (OOM) killed processes or containers, or even system crashes.",
"url": "https://github.com/python/cpython/commit/71fa8eb8233b37f16c88b6e3e583b461b205d1ba.patch"
},
{
"commit_message": "<[email protected]> [PATCH] [3.14] gh-119342: Fix a potential denial of service in plistlib (GH-119343) (GH-142143) Reading a specially prepared small Plist file could cause OOM because file's read(n) preallocates a bytes object for reading the specified amount of data. Now plistlib reads large data by chunks, therefore the upper limit of consumed memory is proportional to the size of the input file. (cherry picked from commit 694922cf40aa3a28f898b5f5ee08b71b4922df70) Co-authored-by: Serhiy Storchaka <[email protected]> Lib/plistlib.py | 31 ++++++++++------ Lib/test/test_plistlib.py | 37 +++++++++++++++++-- ...-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst | 5 +++ 3 files changed, 59 insertions(+), 14 deletions(-) create mode 100644 Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst",
"patch_text_b64": "From b64441e4852383645af5b435411a6f849dd1b4cb Mon Sep 17 00:00:00 2001
From: "Miss Islington (bot)"
 <31488909+miss-islington@users.noreply.github.com>
Date: Mon, 1 Dec 2025 16:54:58 +0100
Subject: [PATCH] [3.14] gh-119342: Fix a potential denial of service in
 plistlib (GH-119343) (GH-142143)

Reading a specially prepared small Plist file could cause OOM because file's
read(n) preallocates a bytes object for reading the specified amount of
data. Now plistlib reads large data by chunks, therefore the upper limit of
consumed memory is proportional to the size of the input file.
(cherry picked from commit 694922cf40aa3a28f898b5f5ee08b71b4922df70)

Co-authored-by: Serhiy Storchaka <storchaka@gmail.com>
---
 Lib/plistlib.py                               | 31 ++++++++++------
 Lib/test/test_plistlib.py                     | 37 +++++++++++++++++--
 ...-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst |  5 +++
 3 files changed, 59 insertions(+), 14 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst

diff --git a/Lib/plistlib.py b/Lib/plistlib.py
index 67e832db217319..655c51eea3da5d 100644
--- a/Lib/plistlib.py
+++ b/Lib/plistlib.py
@@ -73,6 +73,9 @@
 PlistFormat = enum.Enum('PlistFormat', 'FMT_XML FMT_BINARY', module=__name__)
 globals().update(PlistFormat.__members__)
 
+# Data larger than this will be read in chunks, to prevent extreme
+# overallocation.
+_MIN_READ_BUF_SIZE = 1 << 20
 
 class UID:
     def __init__(self, data):
@@ -508,12 +511,24 @@ def _get_size(self, tokenL):
 
         return tokenL
 
+    def _read(self, size):
+        cursize = min(size, _MIN_READ_BUF_SIZE)
+        data = self._fp.read(cursize)
+        while True:
+            if len(data) != cursize:
+                raise InvalidFileException
+            if cursize == size:
+                return data
+            delta = min(cursize, size - cursize)
+            data += self._fp.read(delta)
+            cursize += delta
+
     def _read_ints(self, n, size):
-        data = self._fp.read(size * n)
+        data = self._read(size * n)
         if size in _BINARY_FORMAT:
             return struct.unpack(f'>{n}{_BINARY_FORMAT[size]}', data)
         else:
-            if not size or len(data) != size * n:
+            if not size:
                 raise InvalidFileException()
             return tuple(int.from_bytes(data[i: i + size], 'big')
                          for i in range(0, size * n, size))
@@ -573,22 +588,16 @@ def _read_object(self, ref):
 
         elif tokenH == 0x40:  # data
             s = self._get_size(tokenL)
-            result = self._fp.read(s)
-            if len(result) != s:
-                raise InvalidFileException()
+            result = self._read(s)
 
         elif tokenH == 0x50:  # ascii string
             s = self._get_size(tokenL)
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('ascii')
 
         elif tokenH == 0x60:  # unicode string
             s = self._get_size(tokenL) * 2
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('utf-16be')
 
         elif tokenH == 0x80:  # UID
diff --git a/Lib/test/test_plistlib.py b/Lib/test/test_plistlib.py
index a0c76e5dec5ebe..de2a2fd1fc34bf 100644
--- a/Lib/test/test_plistlib.py
+++ b/Lib/test/test_plistlib.py
@@ -903,8 +903,7 @@ def test_dump_naive_datetime_with_aware_datetime_option(self):
 
 class TestBinaryPlistlib(unittest.TestCase):
 
-    @staticmethod
-    def decode(*objects, offset_size=1, ref_size=1):
+    def build(self, *objects, offset_size=1, ref_size=1):
         data = [b'bplist00']
         offset = 8
         offsets = []
@@ -916,7 +915,11 @@ def decode(*objects, offset_size=1, ref_size=1):
                            len(objects), 0, offset)
         data.extend(offsets)
         data.append(tail)
-        return plistlib.loads(b''.join(data), fmt=plistlib.FMT_BINARY)
+        return b''.join(data)
+
+    def decode(self, *objects, offset_size=1, ref_size=1):
+        data = self.build(*objects, offset_size=offset_size, ref_size=ref_size)
+        return plistlib.loads(data, fmt=plistlib.FMT_BINARY)
 
     def test_nonstandard_refs_size(self):
         # Issue #21538: Refs and offsets are 24-bit integers
@@ -1024,6 +1027,34 @@ def test_invalid_binary(self):
                 with self.assertRaises(plistlib.InvalidFileException):
                     plistlib.loads(b'bplist00' + data, fmt=plistlib.FMT_BINARY)
 
+    def test_truncated_large_data(self):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        def check(data):
+            with open(os_helper.TESTFN, 'wb') as f:
+                f.write(data)
+            # buffered file
+            with open(os_helper.TESTFN, 'rb') as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+            # unbuffered file
+            with open(os_helper.TESTFN, 'rb', buffering=0) as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+        for w in range(20, 64):
+            s = 1 << w
+            # data
+            check(self.build(b'\x4f\x13' + s.to_bytes(8, 'big')))
+            # ascii string
+            check(self.build(b'\x5f\x13' + s.to_bytes(8, 'big')))
+            # unicode string
+            check(self.build(b'\x6f\x13' + s.to_bytes(8, 'big')))
+            # array
+            check(self.build(b'\xaf\x13' + s.to_bytes(8, 'big')))
+            # dict
+            check(self.build(b'\xdf\x13' + s.to_bytes(8, 'big')))
+            # number of objects
+            check(b'bplist00' + struct.pack('>6xBBQQQ', 1, 1, s, 0, 8))
+
     def test_load_aware_datetime(self):
         data = (b'bplist003B\x04>\xd0d\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00'
                 b'\x01\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00'
diff --git a/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst b/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst
new file mode 100644
index 00000000000000..04fd8faca4cf7e
--- /dev/null
+++ b/Misc/NEWS.d/next/Security/2024-05-21-22-11-31.gh-issue-119342.BTFj4Z.rst
@@ -0,0 +1,5 @@
+Fix a potential memory denial of service in the :mod:`plistlib` module.
+When reading a Plist file received from untrusted source, it could cause
+an arbitrary amount of memory to be allocated.
+This could have led to symptoms including a :exc:`MemoryError`, swapping, out
+of memory (OOM) killed processes or containers, or even system crashes.",
"url": "https://github.com/python/cpython/commit/b64441e4852383645af5b435411a6f849dd1b4cb.patch"
}
] | null |
|
CVE-2024-29192
|
GHSL-2023-206 gotortc Cross-Site Request Forgery vulnerability
|
gotortc is a camera streaming application. Versions 1.8.5 and prior are vulnerable to Cross-Site Request Forgery. The `/api/config` endpoint allows one to modify the existing configuration with user-supplied values. While the API is only allowing localhost to interact without authentication, an attacker may be able to achieve that depending on how go2rtc is set up on the upstream application, and given that this endpoint is not protected against CSRF, it allows requests from any origin (e.g. a "drive-by" attack) . The `exec` handler allows for any stream to execute arbitrary commands. An attacker may add a custom stream through `api/config`, which may lead to arbitrary command execution. In the event of a victim visiting the server in question, their browser will execute the requests against the go2rtc instance. Commit 8793c3636493c5efdda08f3b5ed5c6e1ea594fd9 adds a warning about secure API access.
|
[
{
"commit_message": "[PATCH] Add warning about secure access for API to docs README.md | 2 ++ 1 file changed, 2 insertions(+)",
"patch_text_b64": "RnJvbSA4NzkzYzM2MzY0OTNjNWVmZGRhMDhmM2I1ZWQ1YzZlMWVhNTk0ZmQ5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbGV4IFggPGFsZXhleS5raGl0QGdtYWlsLmNvbT4KRGF0ZTogVGh1LCAxMSBKYW4gMjAyNCAxNDoyNjo1MSArMDMwMApTdWJqZWN0OiBbUEFUQ0hdIEFkZCB3YXJuaW5nIGFib3V0IHNlY3VyZSBhY2Nlc3MgZm9yIEFQSSB0byBkb2NzCgotLS0KIFJFQURNRS5tZCB8IDIgKysKIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9SRUFETUUubWQgYi9SRUFETUUubWQKaW5kZXggOGFiNTI5MWYzLi5hYWVkOTQxMGMgMTAwNjQ0Ci0tLSBhL1JFQURNRS5tZAorKysgYi9SRUFETUUubWQKQEAgLTc5MCw2ICs3OTAsOCBAQCBzdHJlYW1zOgogCiBUaGUgSFRUUCBBUEkgaXMgdGhlIG1haW4gcGFydCBmb3IgaW50ZXJhY3Rpbmcgd2l0aCB0aGUgYXBwbGljYXRpb24uIERlZmF1bHQgYWRkcmVzczogYGh0dHA6Ly9sb2NhbGhvc3Q6MTk4NC9gLgogCisqKkltcG9ydGFudCEqKiBnbzJydGMgcGFzc2VzIHJlcXVlc3RzIGZyb20gbG9jYWxob3N0IGFuZCBmcm9tIHVuaXggc29ja2V0IHdpdGhvdXQgSFRUUCBhdXRob3Jpc2F0aW9uLCBldmVuIGlmIHlvdSBoYXZlIGl0IGNvbmZpZ3VyZWQhIEl0IGlzIHlvdXIgcmVzcG9uc2liaWxpdHkgdG8gc2V0IHVwIHNlY3VyZSBleHRlcm5hbCBhY2Nlc3MgdG8gQVBJLiBJZiBub3QgcHJvcGVybHkgY29uZmlndXJlZCwgYW4gYXR0YWNrZXIgY2FuIGdhaW4gYWNjZXNzIHRvIHlvdXIgY2FtZXJhcyBhbmQgZXZlbiB5b3VyIHNlcnZlci4KKwogW0FQSSBkZXNjcmlwdGlvbl0oaHR0cHM6Ly9naXRodWIuY29tL0FsZXh4SVQvZ28ycnRjL3RyZWUvbWFzdGVyL2FwaSkuCiAKICoqTW9kdWxlIGNvbmZpZyoq",
"url": "https://github.com/AlexxIT/go2rtc/commit/8793c3636493c5efdda08f3b5ed5c6e1ea594fd9.patch"
}
] |
CWE-352: Cross-Site Request Forgery (CSRF)
|
GHSA-vc3v-ppc7-v486
|
vantage6-server node accepts non-whitelisted algorithms from malicious server
| null |
[
{
"commit_message": "[PATCH] Remove lines that skip checking if algorithm is allowed when parent id is set This is a security vulnerability when the server is adapted to set a parent_id for each task. In such cases, any algorithm image would be run vantage6-node/vantage6/node/docker/docker_manager.py | 5 ----- 1 file changed, 5 deletions(-)",
"patch_text_b64": "RnJvbSA5MjE1OTU4MGYxMWExN2NkMmUwNmY3M2Y2MzYwODhiYmNiZmU5Y2JjIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCYXJ0IHZhbiBCZXVzZWtvbSA8Yi52YW5iZXVzZWtvbUBpa25sLm5sPgpEYXRlOiBUdWUsIDE0IE5vdiAyMDIzIDA5OjMzOjQ4ICswMTAwClN1YmplY3Q6IFtQQVRDSF0gUmVtb3ZlIGxpbmVzIHRoYXQgc2tpcCBjaGVja2luZyBpZiBhbGdvcml0aG0gaXMgYWxsb3dlZCB3aGVuCiBwYXJlbnQgaWQgaXMgc2V0CgpUaGlzIGlzIGEgc2VjdXJpdHkgdnVsbmVyYWJpbGl0eSB3aGVuIHRoZSBzZXJ2ZXIgaXMgYWRhcHRlZCB0byBzZXQgYSBwYXJlbnRfaWQgZm9yIGVhY2ggdGFzay4gSW4gc3VjaCBjYXNlcywgYW55IGFsZ29yaXRobSBpbWFnZSB3b3VsZCBiZSBydW4KLS0tCiB2YW50YWdlNi1ub2RlL3ZhbnRhZ2U2L25vZGUvZG9ja2VyL2RvY2tlcl9tYW5hZ2VyLnB5IHwgNSAtLS0tLQogMSBmaWxlIGNoYW5nZWQsIDUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvdmFudGFnZTYtbm9kZS92YW50YWdlNi9ub2RlL2RvY2tlci9kb2NrZXJfbWFuYWdlci5weSBiL3ZhbnRhZ2U2LW5vZGUvdmFudGFnZTYvbm9kZS9kb2NrZXIvZG9ja2VyX21hbmFnZXIucHkKaW5kZXggZWE0NDNjZGJjLi5kODAwM2QzYjcgMTAwNjQ0Ci0tLSBhL3ZhbnRhZ2U2LW5vZGUvdmFudGFnZTYvbm9kZS9kb2NrZXIvZG9ja2VyX21hbmFnZXIucHkKKysrIGIvdmFudGFnZTYtbm9kZS92YW50YWdlNi9ub2RlL2RvY2tlci9kb2NrZXJfbWFuYWdlci5weQpAQCAtMjYyLDExICsyNjIsNiBAQCBkZWYgaXNfZG9ja2VyX2ltYWdlX2FsbG93ZWQoCiAgICAgICAgIGJvb2wKICAgICAgICAgICAgIFdoZXRoZXIgZG9ja2VyIGltYWdlIGlzIGFsbG93ZWQgb3Igbm90CiAgICAgICAgICIiIgotICAgICAgICAjIGluIGNhc2Ugb2Ygc3VidGFza3MsIGRvbid0IGNoZWNrIGFueW1vcmUsIGFzIHBhcmVudCBoYXMgYWxyZWFkeQotICAgICAgICAjIGJlZW4gY2hlY2tlZAotICAgICAgICBpZiB0YXNrX2luZm9bJ3BhcmVudCddIGlzIG5vdCBOb25lOgotICAgICAgICAgICAgcmV0dXJuIFRydWUKLQogICAgICAgICAjIGNoZWNrIGlmIGFsZ29yaXRobSBtYXRjaGVzIGFueSBvZiB0aGUgcmVnZXggY2FzZXMKICAgICAgICAgYWxsb3dfYmFzaWNzID0gc2VsZi5fcG9saWNpZXMuZ2V0KCdhbGxvd19iYXNpY3NfYWxnb3JpdGhtJywgVHJ1ZSkKICAgICAgICAgYWxsb3dlZF9hbGdvcml0aG1zID0gc2VsZi5fcG9saWNpZXMuZ2V0KCdhbGxvd2VkX2FsZ29yaXRobXMnKQ==",
"url": "https://github.com/vantage6/vantage6/commit/bf83521eb12fa80aa5fc92ef1692010a9a7f8243.patch"
}
] | null |
CVE-2018-8795
|
rdesktop versions up to and including v1.8.3 contain an Integer Overflow that leads to a Heap-Based Buffer Overflow in function process_bitmap_updates() and results in a memory corruption and probably even a remote code execution.
|
[
{
"commit_message": "[PATCH] Malicious RDP server security fixes This commit includes fixes for a set of 21 vulnerabilities in rdesktop when a malicious RDP server is used. All vulnerabilities was identified and reported by Eyal Itkin. * Add rdp_protocol_error function that is used in several fixes * Refactor of process_bitmap_updates * Fix possible integer overflow in s_check_rem() on 32bit arch * Fix memory corruption in process_bitmap_data - CVE-2018-8794 * Fix remote code execution in process_bitmap_data - CVE-2018-8795 * Fix remote code execution in process_plane - CVE-2018-8797 * Fix Denial of Service in mcs_recv_connect_response - CVE-2018-20175 * Fix Denial of Service in mcs_parse_domain_params - CVE-2018-20175 * Fix Denial of Service in sec_parse_crypt_info - CVE-2018-20176 * Fix Denial of Service in sec_recv - CVE-2018-20176 * Fix minor information leak in rdpdr_process - CVE-2018-8791 * Fix Denial of Service in cssp_read_tsrequest - CVE-2018-8792 * Fix remote code execution in cssp_read_tsrequest - CVE-2018-8793 * Fix Denial of Service in process_bitmap_data - CVE-2018-8796 * Fix minor information leak in rdpsnd_process_ping - CVE-2018-8798 * Fix Denial of Service in process_secondary_order - CVE-2018-8799 * Fix remote code execution in in ui_clip_handle_data - CVE-2018-8800 * Fix major information leak in ui_clip_handle_data - CVE-2018-20174 * Fix memory corruption in rdp_in_unistr - CVE-2018-20177 * Fix Denial of Service in process_demand_active - CVE-2018-20178 * Fix remote code execution in lspci_process - CVE-2018-20179 * Fix remote code execution in rdpsnddbg_process - CVE-2018-20180 * Fix remote code execution in seamless_process - CVE-2018-20181 * Fix remote code execution in seamless_process_line - CVE-2018-20182 asn.c | 2 +- bitmap.c | 8 +-- cliprdr.c | 6 ++ constants.h | 3 + cssp.c | 17 ++++- lspci.c | 9 ++- mcs.c | 20 +++++- orders.c | 6 ++ proto.h | 3 +- rdp.c | 192 ++++++++++++++++++++++++++++++++++++---------------- rdpdr.c | 11 +++ rdpsnd.c | 11 +++ seamless.c | 12 ++++ secure.c | 17 +++++ stream.h | 2 +- types.h | 2 + 16 files changed, 250 insertions(+), 71 deletions(-)",
"patch_text_b64": "From 4dca546d04321a610c1835010b5dad85163b65e1 Mon Sep 17 00:00:00 2001
From: Henrik Andersson <hean01@cendio.com>
Date: Wed, 16 Jan 2019 10:45:33 +0100
Subject: [PATCH] Malicious RDP server security fixes

This commit includes fixes for a set of 21 vulnerabilities in
rdesktop when a malicious RDP server is used.

All vulnerabilities was identified and reported by Eyal Itkin.

 * Add rdp_protocol_error function that is used in several fixes
 * Refactor of process_bitmap_updates
 * Fix possible integer overflow in s_check_rem() on 32bit arch
 * Fix memory corruption in process_bitmap_data - CVE-2018-8794
 * Fix remote code execution in process_bitmap_data - CVE-2018-8795
 * Fix remote code execution in process_plane - CVE-2018-8797
 * Fix Denial of Service in mcs_recv_connect_response - CVE-2018-20175
 * Fix Denial of Service in mcs_parse_domain_params - CVE-2018-20175
 * Fix Denial of Service in sec_parse_crypt_info - CVE-2018-20176
 * Fix Denial of Service in sec_recv - CVE-2018-20176
 * Fix minor information leak in rdpdr_process - CVE-2018-8791
 * Fix Denial of Service in cssp_read_tsrequest - CVE-2018-8792
 * Fix remote code execution in cssp_read_tsrequest - CVE-2018-8793
 * Fix Denial of Service in process_bitmap_data - CVE-2018-8796
 * Fix minor information leak in rdpsnd_process_ping - CVE-2018-8798
 * Fix Denial of Service in process_secondary_order - CVE-2018-8799
 * Fix remote code execution in in ui_clip_handle_data - CVE-2018-8800
 * Fix major information leak in ui_clip_handle_data - CVE-2018-20174
 * Fix memory corruption in rdp_in_unistr - CVE-2018-20177
 * Fix Denial of Service in process_demand_active - CVE-2018-20178
 * Fix remote code execution in lspci_process - CVE-2018-20179
 * Fix remote code execution in rdpsnddbg_process - CVE-2018-20180
 * Fix remote code execution in seamless_process - CVE-2018-20181
 * Fix remote code execution in seamless_process_line - CVE-2018-20182
---
 asn.c       |   2 +-
 bitmap.c    |   8 +--
 cliprdr.c   |   6 ++
 constants.h |   3 +
 cssp.c      |  17 ++++-
 lspci.c     |   9 ++-
 mcs.c       |  20 +++++-
 orders.c    |   6 ++
 proto.h     |   3 +-
 rdp.c       | 192 ++++++++++++++++++++++++++++++++++++----------------
 rdpdr.c     |  11 +++
 rdpsnd.c    |  11 +++
 seamless.c  |  12 ++++
 secure.c    |  17 +++++
 stream.h    |   2 +-
 types.h     |   2 +
 16 files changed, 250 insertions(+), 71 deletions(-)

diff --git a/asn.c b/asn.c
index 26b0e9b4..1b9fea4c 100644
--- a/asn.c
+++ b/asn.c
@@ -22,7 +22,7 @@
 
 /* Parse an ASN.1 BER header */
 RD_BOOL
-ber_parse_header(STREAM s, int tagval, int *length)
+ber_parse_header(STREAM s, int tagval, uint32 *length)
 {
 	int tag, len;
 
diff --git a/bitmap.c b/bitmap.c
index 775622cc..55c768c1 100644
--- a/bitmap.c
+++ b/bitmap.c
@@ -794,7 +794,7 @@ process_plane(uint8 * in, int width, int height, uint8 * out, int size)
 					replen = revcode;
 					collen = 0;
 				}
-				while (collen > 0)
+				while (indexw < width && collen > 0)
 				{
 					color = CVAL(in);
 					*out = color;
@@ -802,7 +802,7 @@ process_plane(uint8 * in, int width, int height, uint8 * out, int size)
 					indexw++;
 					collen--;
 				}
-				while (replen > 0)
+				while (indexw < width && replen > 0)
 				{
 					*out = color;
 					out += 4;
@@ -824,7 +824,7 @@ process_plane(uint8 * in, int width, int height, uint8 * out, int size)
 					replen = revcode;
 					collen = 0;
 				}
-				while (collen > 0)
+				while (indexw < width && collen > 0)
 				{
 					x = CVAL(in);
 					if (x & 1)
@@ -844,7 +844,7 @@ process_plane(uint8 * in, int width, int height, uint8 * out, int size)
 					indexw++;
 					collen--;
 				}
-				while (replen > 0)
+				while (indexw < width && replen > 0)
 				{
 					x = last_line[indexw * 4] + color;
 					*out = x;
diff --git a/cliprdr.c b/cliprdr.c
index 3f68213b..76eb98d0 100644
--- a/cliprdr.c
+++ b/cliprdr.c
@@ -118,6 +118,7 @@ cliprdr_process(STREAM s)
 	uint16 type, status;
 	uint32 length, format;
 	uint8 *data;
+	struct stream packet = *s;
 
 	in_uint16_le(s, type);
 	in_uint16_le(s, status);
@@ -127,6 +128,11 @@ cliprdr_process(STREAM s)
 	logger(Clipboard, Debug, "cliprdr_process(), type=%d, status=%d, length=%d", type, status,
 	       length);
 
+	if (!s_check_rem(s, length))
+	{
+		rdp_protocol_error("cliprdr_process(), consume of packet from stream would overrun", &packet);
+	}
+
 	if (status == CLIPRDR_ERROR)
 	{
 		switch (type)
diff --git a/constants.h b/constants.h
index 7dfc2e3d..63015029 100644
--- a/constants.h
+++ b/constants.h
@@ -751,6 +751,9 @@ enum RDP_DESKTOP_ORIENTATION
 #define ENC_SALTED_CHECKSUM		0x0010
 #define NO_BITMAP_COMPRESSION_HDR	0x0400
 
+/* [MS-RDPBCGR], TS_BITMAP_DATA, flags */
+#define BITMAP_COMPRESSION              0x0001
+
 /* orderFlags, [MS-RDPBCGR] 2.2.7.1.3 */
 #define NEGOTIATEORDERSUPPORT	0x0002
 #define ZEROBOUNDSDELTASSUPPORT 0x0008
diff --git a/cssp.c b/cssp.c
index 33544c3b..6b2d0f70 100644
--- a/cssp.c
+++ b/cssp.c
@@ -595,6 +595,7 @@ cssp_read_tsrequest(STREAM token, STREAM pubkey)
 	STREAM s;
 	int length;
 	int tagval;
+	struct stream packet;
 
 	s = tcp_recv(NULL, 4);
 
@@ -622,6 +623,7 @@ cssp_read_tsrequest(STREAM token, STREAM pubkey)
 
 	// receive the remainings of message
 	s = tcp_recv(s, length);
+	packet = *s;
 
 	// parse the response and into nego token
 	if (!ber_in_header(s, &tagval, &length) ||
@@ -632,6 +634,12 @@ cssp_read_tsrequest(STREAM token, STREAM pubkey)
 	if (!ber_in_header(s, &tagval, &length) ||
 	    tagval != (BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 0))
 		return False;
+
+	if (!s_check_rem(s, length))
+	{
+		 rdp_protocol_error("cssp_read_tsrequest(), consume of version from stream would overrun",
+				    &packet);
+	}
 	in_uint8s(s, length);
 
 	// negoToken [1]
@@ -653,7 +661,14 @@ cssp_read_tsrequest(STREAM token, STREAM pubkey)
 		if (!ber_in_header(s, &tagval, &length) || tagval != BER_TAG_OCTET_STRING)
 			return False;
 
-		token->end = token->p = token->data;
+		if (!s_check_rem(s, length))
+		{
+			rdp_protocol_error("cssp_read_tsrequest(), consume of token from stream would overrun",
+					   &packet);
+		}
+
+		s_realloc(token, length);
+		s_reset(token);
 		out_uint8p(token, s->p, length);
 		s_mark_end(token);
 	}
diff --git a/lspci.c b/lspci.c
index c4c8ce63..2d17161c 100644
--- a/lspci.c
+++ b/lspci.c
@@ -1,7 +1,8 @@
 /*  -*- c-basic-offset: 8 -*-
    rdesktop: A Remote Desktop Protocol client.
    Support for the Matrox "lspci" channel
-   Copyright (C) 2005 Matrox Graphics Inc. 
+   Copyright (C) 2005 Matrox Graphics Inc.
+   Copyright 2018 Henrik Andersson <hean01@cendio.se> for Cendio AB
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -134,6 +135,12 @@ lspci_process(STREAM s)
 	unsigned int pkglen;
 	static char *rest = NULL;
 	char *buf;
+	struct stream packet = *s;
+
+	if (!s_check(s))
+	{
+		rdp_protocol_error("lspci_process(), stream is in unstable state", &packet);
+	}
 
 	pkglen = s->end - s->p;
 	/* str_handle_lines requires null terminated strings */
diff --git a/mcs.c b/mcs.c
index 10b73a14..0f2360e8 100644
--- a/mcs.c
+++ b/mcs.c
@@ -45,9 +45,16 @@ mcs_out_domain_params(STREAM s, int max_channels, int max_users, int max_tokens,
 static RD_BOOL
 mcs_parse_domain_params(STREAM s)
 {
-	int length;
+	uint32 length;
+	struct stream packet = *s;
 
 	ber_parse_header(s, MCS_TAG_DOMAIN_PARAMS, &length);
+
+	if (!s_check_rem(s, length))
+	{
+		rdp_protocol_error("mcs_parse_domain_params(), consume domain params from stream would overrun", &packet);
+	}
+
 	in_uint8s(s, length);
 
 	return s_check(s);
@@ -89,8 +96,9 @@ mcs_recv_connect_response(STREAM mcs_data)
 {
 	UNUSED(mcs_data);
 	uint8 result;
-	int length;
+	uint32 length;
 	STREAM s;
+	struct stream packet;
 	RD_BOOL is_fastpath;
 	uint8 fastpath_hdr;
 
@@ -99,6 +107,8 @@ mcs_recv_connect_response(STREAM mcs_data)
 
 	if (s == NULL)
 		return False;
+	
+	packet = *s;
 
 	ber_parse_header(s, MCS_CONNECT_RESPONSE, &length);
 
@@ -112,6 +122,12 @@ mcs_recv_connect_response(STREAM mcs_data)
 
 	ber_parse_header(s, BER_TAG_INTEGER, &length);
 	in_uint8s(s, length);	/* connect id */
+
+	if (!s_check_rem(s, length))
+	{
+		rdp_protocol_error("mcs_recv_connect_response(), consume connect id from stream would overrun", &packet);
+	}
+
 	mcs_parse_domain_params(s);
 
 	ber_parse_header(s, BER_TAG_OCTET_STRING, &length);
diff --git a/orders.c b/orders.c
index ba9cfa1a..5e34770b 100644
--- a/orders.c
+++ b/orders.c
@@ -1259,11 +1259,17 @@ process_secondary_order(STREAM s)
 	uint16 flags;
 	uint8 type;
 	uint8 *next_order;
+	struct stream packet = *s;
 
 	in_uint16_le(s, length);
 	in_uint16_le(s, flags);	/* used by bmpcache2 */
 	in_uint8(s, type);
 
+	if (!s_check_rem(s, length + 7))
+	{
+		rdp_protocol_error("process_secondary_order(), next order pointer would overrun stream", &packet);
+	}
+
 	next_order = s->p + (sint16) length + 7;
 
 	switch (type)
diff --git a/proto.h b/proto.h
index 73449dde..0d6a6c98 100644
--- a/proto.h
+++ b/proto.h
@@ -164,6 +164,7 @@ RD_BOOL rdp_connect(char *server, uint32 flags, char *domain, char *password, ch
 		    char *directory, RD_BOOL reconnect);
 void rdp_reset_state(void);
 void rdp_disconnect(void);
+void rdp_protocol_error(const char *message, STREAM s);
 /* rdpdr.c */
 int get_device_index(RD_NTHANDLE handle);
 void convert_to_unix_filename(char *filename);
@@ -224,7 +225,7 @@ void tcp_run_ui(RD_BOOL run);
 /* asn.c */
 RD_BOOL ber_in_header(STREAM s, int *tagval, int *length);
 void ber_out_header(STREAM s, int tagval, int length);
-RD_BOOL ber_parse_header(STREAM s, int tagval, int *length);
+RD_BOOL ber_parse_header(STREAM s, int tagval, uint32 *length);
 void ber_out_integer(STREAM s, int value);
 void ber_out_sequence(STREAM s, STREAM contents);
 
diff --git a/rdp.c b/rdp.c
index f98f49cb..1654e581 100644
--- a/rdp.c
+++ b/rdp.c
@@ -285,6 +285,19 @@ rdp_in_unistr(STREAM s, int in_len, char **string, uint32 * str_size)
 	size_t ibl, obl;
 	char *pin, *pout;
 
+	struct stream packet = *s;
+
+	if ((in_len < 0) || ((uint32)in_len >= (RD_UINT32_MAX / 2)))
+	{
+		logger(Protocol, Error, "rdp_in_unistr(), length of unicode data is out of bounds.");
+		abort();
+	}
+
+	if (!s_check_rem(s, in_len))
+	{
+		rdp_protocol_error("rdp_in_unistr(), consume of unicode data from stream would overrun", &packet);
+	}
+
 	// if not already open
 	if (!icv_utf16_to_local)
 	{
@@ -1211,6 +1224,7 @@ process_demand_active(STREAM s)
 {
 	uint8 type;
 	uint16 len_src_descriptor, len_combined_caps;
+	struct stream packet = *s;
 
 	/* at this point we need to ensure that we have ui created */
 	rd_create_ui();
@@ -1218,6 +1232,11 @@ process_demand_active(STREAM s)
 	in_uint32_le(s, g_rdp_shareid);
 	in_uint16_le(s, len_src_descriptor);
 	in_uint16_le(s, len_combined_caps);
+
+	if (!s_check_rem(s, len_src_descriptor))
+	{
+		rdp_protocol_error("rdp_demand_active(), consume of source descriptor from stream would overrun", &packet);
+	}
 	in_uint8s(s, len_src_descriptor);
 
 	logger(Protocol, Debug, "process_demand_active(), shareid=0x%x", g_rdp_shareid);
@@ -1390,78 +1409,113 @@ process_pointer_pdu(STREAM s)
 	}
 }
 
-/* Process bitmap updates */
-void
-process_bitmap_updates(STREAM s)
+/* Process TS_BITMAP_DATA */
+static void
+process_bitmap_data(STREAM s)
 {
-	uint16 num_updates;
 	uint16 left, top, right, bottom, width, height;
-	uint16 cx, cy, bpp, Bpp, compress, bufsize, size;
+	uint16 cx, cy, bpp, Bpp, flags, bufsize, size;
 	uint8 *data, *bmpdata;
-	int i;
-
+	
 	logger(Protocol, Debug, "%s()", __func__);
 
-	in_uint16_le(s, num_updates);
+	struct stream packet = *s;
 
-	for (i = 0; i < num_updates; i++)
-	{
-		in_uint16_le(s, left);
-		in_uint16_le(s, top);
-		in_uint16_le(s, right);
-		in_uint16_le(s, bottom);
-		in_uint16_le(s, width);
-		in_uint16_le(s, height);
-		in_uint16_le(s, bpp);
-		Bpp = (bpp + 7) / 8;
-		in_uint16_le(s, compress);
-		in_uint16_le(s, bufsize);
-
-		cx = right - left + 1;
-		cy = bottom - top + 1;
-
-		logger(Graphics, Debug,
-		       "process_bitmap_updates(), [%d,%d,%d,%d], [%d,%d], bpp=%d, compression=%d",
-		       left, top, right, bottom, width, height, Bpp, compress);
-
-		if (!compress)
-		{
-			int y;
-			bmpdata = (uint8 *) xmalloc(width * height * Bpp);
-			for (y = 0; y < height; y++)
-			{
-				in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)],
-					  width * Bpp);
-			}
-			ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
-			xfree(bmpdata);
-			continue;
-		}
+	in_uint16_le(s, left); /* destLeft */
+	in_uint16_le(s, top); /* destTop */
+	in_uint16_le(s, right); /* destRight */
+	in_uint16_le(s, bottom); /* destBottom */
+	in_uint16_le(s, width); /* width */
+	in_uint16_le(s, height); /* height */
+	in_uint16_le(s, bpp); /*bitsPerPixel */
+	Bpp = (bpp + 7) / 8;
+	in_uint16_le(s, flags); /* flags */
+	in_uint16_le(s, bufsize); /* bitmapLength */
 
+	cx = right - left + 1;
+	cy = bottom - top + 1;
 
-		if (compress & 0x400)
-		{
-			size = bufsize;
-		}
-		else
-		{
-			in_uint8s(s, 2);	/* pad */
-			in_uint16_le(s, size);
-			in_uint8s(s, 4);	/* line_size, final_size */
-		}
-		in_uint8p(s, data, size);
+	/* FIXME: There are a assumtion that we do not consider in
+		this code. The value of bpp is not passed to
+		ui_paint_bitmap() which relies on g_server_bpp for drawing
+		the bitmap data.
+
+		Does this means that we can sanity check bpp with g_server_bpp ?
+	*/
+
+	if (Bpp == 0 || width == 0 || height == 0)
+	{
+        logger(Protocol, Warning, "%s(), [%d,%d,%d,%d], [%d,%d], bpp=%d, flags=%x", __func__,
+				left, top, right, bottom, width, height, bpp, flags);
+		rdp_protocol_error("TS_BITMAP_DATA, unsafe size of bitmap data received from server", &packet);
+	}
+
+	if ((RD_UINT32_MAX / Bpp) <= (width * height))
+	{
+		logger(Protocol, Warning, "%s(), [%d,%d,%d,%d], [%d,%d], bpp=%d, flags=%x", __func__,
+				left, top, right, bottom, width, height, bpp, flags);
+		rdp_protocol_error("TS_BITMAP_DATA, unsafe size of bitmap data received from server", &packet);
+	}
+ 
+	if (flags == 0)
+	{
+		/* read uncompressed bitmap data */
+		int y;
 		bmpdata = (uint8 *) xmalloc(width * height * Bpp);
-		if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
+		for (y = 0; y < height; y++)
 		{
-			ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
+			in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)], width * Bpp);
 		}
-		else
-		{
-			logger(Graphics, Warning,
-			       "process_bitmap_updates(), failed to decompress bitmap");
-		}
-
+		
+		ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
 		xfree(bmpdata);
+		return;
+	}
+
+	if (flags & NO_BITMAP_COMPRESSION_HDR)
+	{
+		size = bufsize;
+	}
+	else
+	{
+		/* Read TS_CD_HEADER */
+		in_uint8s(s, 2);        /* skip cbCompFirstRowSize (must be 0x0000) */
+		in_uint16_le(s, size);  /* cbCompMainBodySize */
+		in_uint8s(s, 2);        /* skip cbScanWidth */
+		in_uint8s(s, 2);        /* skip cbUncompressedSize */
+	}
+
+	/* read compressed bitmap data */
+	if (!s_check_rem(s, size))
+	{
+		rdp_protocol_error("process_bitmap_data(), consume of bitmap data from stream would overrun", &packet);
+	}
+	in_uint8p(s, data, size);
+	bmpdata = (uint8 *) xmalloc(width * height * Bpp);
+	if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
+	{
+		ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
+	}
+	else
+	{
+		logger(Protocol, Warning, "%s(), failed to decompress bitmap", __func__);
+	}
+
+	xfree(bmpdata);
+}
+
+/* Process TS_UPDATE_BITMAP_DATA */
+void
+process_bitmap_updates(STREAM s)
+{
+	int i;
+	uint16 num_updates;
+	
+	in_uint16_le(s, num_updates);   /* rectangles */
+
+	for (i = 0; i < num_updates; i++)
+	{
+		process_bitmap_data(s);
 	}
 }
 
@@ -2013,3 +2067,21 @@ rdp_disconnect(void)
 	logger(Protocol, Debug, "%s()", __func__);
 	sec_disconnect();
 }
+
+/* Abort rdesktop upon protocol error
+
+   A protocol error is defined as:
+
+    - A value is outside specified range for example;
+      bpp for a bitmap is not allowed to be greater than the
+      value 32 but is represented by a byte in protocol.
+
+*/
+void
+rdp_protocol_error(const char *message, STREAM s)
+{
+	logger(Protocol, Error, "%s(), %s", __func__, message);
+	if (s)
+		hexdump(s->p, s_length(s));
+	exit(0);
+}
diff --git a/rdpdr.c b/rdpdr.c
index e8f54316..0abcacd8 100644
--- a/rdpdr.c
+++ b/rdpdr.c
@@ -854,6 +854,7 @@ rdpdr_process(STREAM s)
 	uint16 vmin;
 	uint16 component;
 	uint16 pakid;
+	struct stream packet = *s;
 
 	logger(Protocol, Debug, "rdpdr_process()");
 	/* hexdump(s->p, s->end - s->p); */
@@ -873,8 +874,18 @@ rdpdr_process(STREAM s)
 				/* DR_CORE_SERVER_ANNOUNCE_REQ */
 				in_uint8s(s, 2);	/* skip versionMajor */
 				in_uint16_le(s, vmin);	/* VersionMinor */
+
 				in_uint32_le(s, g_client_id);	/* ClientID */
 
+				/* g_client_id is sent back to server,
+				   so lets check that we actually got
+				   valid data from stream to prevent
+				   that we leak back data to server */
+				if (!s_check(s))
+				{
+					rdp_protocol_error("rdpdr_process(), consume of g_client_id from stream did overrun", &packet);
+				}
+
 				/* The RDP client is responsibility to provide a random client id
 				   if server version is < 12 */
 				if (vmin < 0x000c)
diff --git a/rdpsnd.c b/rdpsnd.c
index 71a3bf25..40881b76 100644
--- a/rdpsnd.c
+++ b/rdpsnd.c
@@ -269,6 +269,12 @@ rdpsnd_process_training(STREAM in)
 	uint16 tick;
 	uint16 packsize;
 	STREAM out;
+	struct stream packet = *in;
+
+	if (!s_check_rem(in, 4))
+	{
+		rdp_protocol_error("rdpsnd_process_training(), consume of training data from stream would overrun", &packet);
+	}
 
 	in_uint16_le(in, tick);
 	in_uint16_le(in, packsize);
@@ -445,6 +451,11 @@ rdpsnddbg_process(STREAM s)
 	static char *rest = NULL;
 	char *buf;
 
+	if (!s_check(s))
+	{
+		rdp_protocol_error("rdpsnddbg_process(), stream is in unstable state", s);
+	}
+
 	pkglen = s->end - s->p;
 	/* str_handle_lines requires null terminated strings */
 	buf = (char *) xmalloc(pkglen + 1);
diff --git a/seamless.c b/seamless.c
index 8fde8ddd..1935074f 100644
--- a/seamless.c
+++ b/seamless.c
@@ -168,6 +168,12 @@ seamless_process_line(const char *line, void *data)
 
 			icon_buf[len] = strtol(byte, NULL, 16);
 			len++;
+
+			if ((size_t)len >= sizeof(icon_buf))
+			{
+				logger(Protocol, Warning, "seamless_process_line(), icon data would overrun icon_buf");
+				break;
+			}
 		}
 
 		ui_seamless_seticon(id, tok5, width, height, chunk, icon_buf, len);
@@ -370,6 +376,12 @@ seamless_process(STREAM s)
 {
 	unsigned int pkglen;
 	char *buf;
+	struct stream packet = *s;
+
+	if (!s_check(s))
+	{
+		rdp_protocol_error("seamless_process(), stream is in unstable state", &packet);
+	}
 
 	pkglen = s->end - s->p;
 	/* str_handle_lines requires null terminated strings */
diff --git a/secure.c b/secure.c
index 48d9d010..f548a4ff 100644
--- a/secure.c
+++ b/secure.c
@@ -296,6 +296,9 @@ sec_encrypt(uint8 * data, int length)
 void
 sec_decrypt(uint8 * data, int length)
 {
+	if (length <= 0)
+		return;
+
 	if (g_sec_decrypt_use_count == 4096)
 	{
 		sec_update(g_sec_decrypt_key, g_sec_decrypt_update_key);
@@ -848,9 +851,11 @@ sec_recv(RD_BOOL * is_fastpath)
 	uint16 sec_flags;
 	uint16 channel;
 	STREAM s;
+	struct stream packet;
 
 	while ((s = mcs_recv(&channel, is_fastpath, &fastpath_hdr)) != NULL)
 	{
+		packet = *s;
 		if (*is_fastpath == True)
 		{
 			/* If fastpath packet is encrypted, read data
@@ -859,6 +864,10 @@ sec_recv(RD_BOOL * is_fastpath)
 			fastpath_flags = (fastpath_hdr & 0xC0) >> 6;
 			if (fastpath_flags & FASTPATH_OUTPUT_ENCRYPTED)
 			{
+				if (!s_check_rem(s, 8)) {
+					rdp_protocol_error("sec_recv(), consume fastpath signature from stream would overrun", &packet);
+				}
+
 				in_uint8s(s, 8);	/* signature */
 				sec_decrypt(s->p, s->end - s->p);
 			}
@@ -875,6 +884,10 @@ sec_recv(RD_BOOL * is_fastpath)
 			{
 				if (sec_flags & SEC_ENCRYPT)
 				{
+					if (!s_check_rem(s, 8)) {
+						rdp_protocol_error("sec_recv(), consume encrypt signature from stream would overrun", &packet);
+					}
+
 					in_uint8s(s, 8);	/* signature */
 					sec_decrypt(s->p, s->end - s->p);
 				}
@@ -889,6 +902,10 @@ sec_recv(RD_BOOL * is_fastpath)
 				{
 					uint8 swapbyte;
 
+					if (!s_check_rem(s, 8)) {
+						rdp_protocol_error("sec_recv(), consume redirect signature from stream would overrun", &packet);
+					}
+
 					in_uint8s(s, 8);	/* signature */
 					sec_decrypt(s->p, s->end - s->p);
 
diff --git a/stream.h b/stream.h
index ccc125db..a9196e5f 100644
--- a/stream.h
+++ b/stream.h
@@ -54,7 +54,7 @@ size_t in_ansi_string(STREAM s, char *string, size_t len);
 #define s_pop_layer(s,h)	(s)->p = (s)->h;
 #define s_mark_end(s)		(s)->end = (s)->p;
 #define s_check(s)		((s)->p <= (s)->end)
-#define s_check_rem(s,n)	((s)->p + n <= (s)->end)
+#define s_check_rem(s,n) (s_check(s) && (n <= (s)->end - (s)->p))
 #define s_check_end(s)		((s)->p == (s)->end)
 #define s_length(s)		((s)->end - (s)->data)
 #define s_left(s)               ((s)->size - ((s)->p - (s)->data))
diff --git a/types.h b/types.h
index b139b863..4556ab48 100644
--- a/types.h
+++ b/types.h
@@ -43,6 +43,8 @@ typedef signed short sint16;
 typedef unsigned int uint32;
 typedef signed int sint32;
 
+#define RD_UINT32_MAX (uint32)(-1)
+
 typedef void *RD_HBITMAP;
 typedef void *RD_HGLYPH;
 typedef void *RD_HCOLOURMAP;",
"url": "https://github.com/rdesktop/rdesktop/commit/4dca546d04321a610c1835010b5dad85163b65e1.patch"
}
] |
CWE-680: Integer Overflow to Buffer Overflow
|
|
CVE-2024-39690
|
Capsule tenant owner with "patch namespace" permission can hijack system namespaces
|
Capsule is a multi-tenancy and policy-based framework for Kubernetes. In Capsule v0.7.0 and earlier, the tenant-owner can patch any arbitrary namespace that has not been taken over by a tenant (i.e., namespaces without the ownerReference field), thereby gaining control of that namespace. Version 0.7.1 contains a patch.
|
[
{
"commit_message": "[PATCH] Merge commit from fork MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Oliver Bähler <[email protected]> .../templates/configuration-default.yaml | 3 +- e2e/namespace_hijacking_test.go | 119 ++++++++++++++++++ pkg/webhook/ownerreference/patching.go | 35 +++++- 3 files changed, 152 insertions(+), 5 deletions(-) create mode 100644 e2e/namespace_hijacking_test.go",
"patch_text_b64": "From d620b0457ddec01616b8eab8512a10611611f584 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oliver=20B=C3=A4hler?= <oliverbaehler@hotmail.com>
Date: Tue, 20 Aug 2024 10:19:14 +0200
Subject: [PATCH] Merge commit from fork
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Oliver Bähler <oliverbaehler@hotmail.com>
---
 .../templates/configuration-default.yaml      |   3 +-
 e2e/namespace_hijacking_test.go               | 119 ++++++++++++++++++
 pkg/webhook/ownerreference/patching.go        |  35 +++++-
 3 files changed, 152 insertions(+), 5 deletions(-)
 create mode 100644 e2e/namespace_hijacking_test.go

diff --git a/charts/capsule/templates/configuration-default.yaml b/charts/capsule/templates/configuration-default.yaml
index e4a7754c9..bc3b07ec8 100644
--- a/charts/capsule/templates/configuration-default.yaml
+++ b/charts/capsule/templates/configuration-default.yaml
@@ -25,4 +25,5 @@ spec:
   nodeMetadata:
     {{- toYaml . | nindent 4 }}
   {{- end }}
-{{- end }}
\ No newline at end of file
+{{- end }}
+
diff --git a/e2e/namespace_hijacking_test.go b/e2e/namespace_hijacking_test.go
new file mode 100644
index 000000000..7b7540e8d
--- /dev/null
+++ b/e2e/namespace_hijacking_test.go
@@ -0,0 +1,119 @@
+//go:build e2e
+
+// Copyright 2020-2023 Project Capsule Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package e2e
+
+import (
+	"context"
+	"fmt"
+	corev1 "k8s.io/api/core/v1"
+	"math/rand"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	capsulev1beta2 "github.com/projectcapsule/capsule/api/v1beta2"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+)
+
+var _ = Describe("creating several Namespaces for a Tenant", func() {
+	tnt := &capsulev1beta2.Tenant{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "capsule-ns-attack-1",
+		},
+		Spec: capsulev1beta2.TenantSpec{
+			Owners: capsulev1beta2.OwnerListSpec{
+				{
+					Name: "charlie",
+					Kind: "User",
+				},
+				{
+					Kind: "ServiceAccount",
+					Name: "system:serviceaccount:attacker-system:attacker",
+				},
+			},
+		},
+	}
+
+	kubeSystem := &corev1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "kube-system",
+		},
+	}
+	JustBeforeEach(func() {
+		EventuallyCreation(func() (err error) {
+			tnt.ResourceVersion = ""
+			err = k8sClient.Create(context.TODO(), tnt)
+
+			return
+		}).Should(Succeed())
+	})
+	JustAfterEach(func() {
+		Expect(k8sClient.Delete(context.TODO(), tnt)).Should(Succeed())
+
+	})
+
+	It("Can't hijack offlimits namespace", func() {
+		tenant := &capsulev1beta2.Tenant{}
+		Expect(k8sClient.Get(context.TODO(), types.NamespacedName{Name: tnt.Name}, tenant)).Should(Succeed())
+
+		// Get the namespace
+		Expect(k8sClient.Get(context.TODO(), types.NamespacedName{Name: kubeSystem.GetName()}, kubeSystem)).Should(Succeed())
+
+		for _, owner := range tnt.Spec.Owners {
+			cs := ownerClient(owner)
+
+			patch := []byte(fmt.Sprintf(`{"metadata":{"ownerReferences":[{"apiVersion":"%s/%s","kind":"Tenant","name":"%s","uid":"%s"}]}}`, capsulev1beta2.GroupVersion.Group, capsulev1beta2.GroupVersion.Version, tenant.GetName(), tenant.GetUID()))
+
+			_, err := cs.CoreV1().Namespaces().Patch(context.TODO(), kubeSystem.Name, types.StrategicMergePatchType, patch, metav1.PatchOptions{})
+			Expect(err).To(HaveOccurred())
+
+		}
+	})
+
+	It("Owners can create and attempt to patch new namespaces but patches should not be applied", func() {
+		for _, owner := range tnt.Spec.Owners {
+			cs := ownerClient(owner)
+
+			// Each owner creates a new namespace
+			ns := NewNamespace("")
+			NamespaceCreation(ns, owner, defaultTimeoutInterval).Should(Succeed())
+
+			// Attempt to patch the owner references of the new namespace
+			tenant := &capsulev1beta2.Tenant{}
+			Expect(k8sClient.Get(context.TODO(), types.NamespacedName{Name: tnt.Name}, tenant)).Should(Succeed())
+
+			randomUID := types.UID(fmt.Sprintf("%d", rand.Int()))
+			randomName := fmt.Sprintf("random-tenant-%d", rand.Int())
+			patch := []byte(fmt.Sprintf(`{"metadata":{"ownerReferences":[{"apiVersion":"%s/%s","kind":"Tenant","name":"%s","uid":"%s"}]}}`, capsulev1beta2.GroupVersion.Group, capsulev1beta2.GroupVersion.Version, randomName, randomUID))
+
+			_, err := cs.CoreV1().Namespaces().Patch(context.TODO(), ns.Name, types.StrategicMergePatchType, patch, metav1.PatchOptions{})
+			Expect(err).ToNot(HaveOccurred())
+
+			retrievedNs := &corev1.Namespace{}
+			Expect(k8sClient.Get(context.TODO(), types.NamespacedName{Name: ns.Name}, retrievedNs)).Should(Succeed())
+
+			// Check if the namespace has an owner reference with the specific UID and name
+			hasSpecificOwnerRef := false
+			for _, ownerRef := range retrievedNs.OwnerReferences {
+				if ownerRef.UID == randomUID && ownerRef.Name == randomName {
+					hasSpecificOwnerRef = true
+					break
+				}
+			}
+			Expect(hasSpecificOwnerRef).To(BeFalse(), "Namespace should not have owner reference with UID %s and name %s", randomUID, randomName)
+
+			hasOriginReference := false
+			for _, ownerRef := range retrievedNs.OwnerReferences {
+				if ownerRef.UID == tenant.GetUID() && ownerRef.Name == tenant.GetName() {
+					hasOriginReference = true
+					break
+				}
+			}
+			Expect(hasOriginReference).To(BeTrue(), "Namespace should have origin reference", tenant.GetUID(), tenant.GetName())
+		}
+	})
+
+})
diff --git a/pkg/webhook/ownerreference/patching.go b/pkg/webhook/ownerreference/patching.go
index 9b32a793f..8dde28165 100644
--- a/pkg/webhook/ownerreference/patching.go
+++ b/pkg/webhook/ownerreference/patching.go
@@ -7,6 +7,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"k8s.io/apimachinery/pkg/fields"
 	"net/http"
 	"sort"
 	"strings"
@@ -49,15 +50,26 @@ func (h *handler) OnDelete(client.Client, admission.Decoder, record.EventRecorde
 	}
 }
 
-func (h *handler) OnUpdate(_ client.Client, decoder admission.Decoder, _ record.EventRecorder) capsulewebhook.Func {
-	return func(_ context.Context, req admission.Request) *admission.Response {
+func (h *handler) OnUpdate(c client.Client, decoder admission.Decoder, recorder record.EventRecorder) capsulewebhook.Func {
+	return func(ctx context.Context, req admission.Request) *admission.Response {
 		oldNs := &corev1.Namespace{}
 		if err := decoder.DecodeRaw(req.OldObject, oldNs); err != nil {
 			return utils.ErroredResponse(err)
 		}
 
-		if len(oldNs.OwnerReferences) == 0 {
-			return nil
+		tntList := &capsulev1beta2.TenantList{}
+		if err := c.List(ctx, tntList, client.MatchingFieldsSelector{
+			Selector: fields.OneTermEqualSelector(".status.namespaces", oldNs.Name),
+		}); err != nil {
+			return utils.ErroredResponse(err)
+		}
+
+		if !h.namespaceIsOwned(oldNs, tntList, req) {
+			recorder.Eventf(oldNs, corev1.EventTypeWarning, "OfflimitNamespace", "Namespace %s can not be patched", oldNs.GetName())
+
+			response := admission.Denied("Denied patch request for this namespace")
+
+			return &response
 		}
 
 		newNs := &corev1.Namespace{}
@@ -101,6 +113,21 @@ func (h *handler) OnUpdate(_ client.Client, decoder admission.Decoder, _ record.
 	}
 }
 
+func (h *handler) namespaceIsOwned(ns *corev1.Namespace, tenantList *capsulev1beta2.TenantList, req admission.Request) bool {
+	for _, tenant := range tenantList.Items {
+		for _, ownerRef := range ns.OwnerReferences {
+			if !capsuleutils.IsTenantOwnerReference(ownerRef) {
+				continue
+			}
+			if ownerRef.UID == tenant.UID && utils.IsTenantOwner(tenant.Spec.Owners, req.UserInfo) {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
 func (h *handler) setOwnerRef(ctx context.Context, req admission.Request, client client.Client, decoder admission.Decoder, recorder record.EventRecorder) *admission.Response {
 	ns := &corev1.Namespace{}
 	if err := decoder.Decode(req, ns); err != nil {",
"url": "https://github.com/projectcapsule/capsule/commit/d620b0457ddec01616b8eab8512a10611611f584.patch"
}
] |
CWE-863: Incorrect Authorization
|
GHSA-2m39-62fm-q8r3
|
Regular Expression Denial of Service in sshpk
| null |
[
{
"commit_message": "[PATCH] joyent/node-sshpk#44 Performance issues parsing long SSH public keys Reviewed by: Cody Peter Mello <[email protected]> lib/formats/ssh.js | 6 +++--- package.json | 2 +- test/horrors.js | 24 ++++++++++++++++++++++++ 3 files changed, 28 insertions(+), 4 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/joyent/node-sshpk/commit/46065d38a5e6d1bccf86d3efb2fb83c14e3f9957.patch"
}
] | null |
GHSA-6fvq-23cw-5628
|
vLLM: Resource-Exhaustion (DoS) through Malicious Jinja Template in OpenAI-Compatible Server
| null |
[
{
"commit_message": "[PATCH] Add filtering for chat template kwargs (#25794) Signed-off-by: Isotr0py <[email protected]> Co-authored-by: Isotr0py <[email protected]> tests/entrypoints/test_chat_utils.py | 85 +++++++++++++++++++++++++ vllm/entrypoints/chat_utils.py | 54 +++++++++++++++- vllm/entrypoints/openai/api_server.py | 1 + vllm/entrypoints/openai/cli_args.py | 10 ++- vllm/entrypoints/openai/serving_chat.py | 14 +++- 5 files changed, 158 insertions(+), 6 deletions(-)",
"patch_text_b64": "From 7977e5027c2250a4abc1f474c5619c40b4e5682f Mon Sep 17 00:00:00 2001
From: Russell Bryant <rbryant@redhat.com>
Date: Sat, 27 Sep 2025 06:46:49 -0400
Subject: [PATCH] Add filtering for chat template kwargs (#25794)

Signed-off-by: Isotr0py <mozf@mail2.sysu.edu.cn>
Co-authored-by: Isotr0py <mozf@mail2.sysu.edu.cn>
---
 tests/entrypoints/test_chat_utils.py    | 85 +++++++++++++++++++++++++
 vllm/entrypoints/chat_utils.py          | 54 +++++++++++++++-
 vllm/entrypoints/openai/api_server.py   |  1 +
 vllm/entrypoints/openai/cli_args.py     | 10 ++-
 vllm/entrypoints/openai/serving_chat.py | 14 +++-
 5 files changed, 158 insertions(+), 6 deletions(-)

diff --git a/tests/entrypoints/test_chat_utils.py b/tests/entrypoints/test_chat_utils.py
index 78370d199b56..a268f573ef90 100644
--- a/tests/entrypoints/test_chat_utils.py
+++ b/tests/entrypoints/test_chat_utils.py
@@ -19,6 +19,7 @@
                                          parse_chat_messages,
                                          parse_chat_messages_futures,
                                          resolve_chat_template_content_format,
+                                         resolve_chat_template_kwargs,
                                          resolve_hf_chat_template)
 from vllm.multimodal import MultiModalDataDict, MultiModalUUIDDict
 from vllm.multimodal.utils import (encode_audio_base64, encode_image_base64,
@@ -37,6 +38,7 @@
 QWEN2VL_MODEL_ID = "Qwen/Qwen2-VL-2B-Instruct"
 QWEN25VL_MODEL_ID = "Qwen/Qwen2.5-VL-3B-Instruct"
 QWEN25OMNI_MODEL_ID = "Qwen/Qwen2.5-Omni-7B"
+QWEN3_MODEL_ID = "Qwen/Qwen3-8B"
 LLAMA_GUARD_MODEL_ID = "meta-llama/Llama-Guard-3-1B"
 HERMES_MODEL_ID = "NousResearch/Hermes-3-Llama-3.1-8B"
 MISTRAL_MODEL_ID = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
@@ -2255,6 +2257,89 @@ def test_resolve_hf_chat_template(sample_json_schema, model, use_tools):
     assert isinstance(chat_template, str)
 
 
+@pytest.mark.parametrize(
+    "model, expected_kwargs",
+    [
+        (
+            QWEN2VL_MODEL_ID,
+            {
+                "add_vision_id", "add_generation_prompt",
+                "continue_final_message", "tools"
+            },
+        ),
+        (
+            QWEN3_MODEL_ID,
+            {
+                "enable_thinking", "add_generation_prompt",
+                "continue_final_message", "tools"
+            },
+        ),
+    ],
+)
+def test_resolve_hf_chat_template_kwargs(sample_json_schema, model,
+                                         expected_kwargs):
+    """checks that chat_template is a dict type for HF models."""
+    model_info = HF_EXAMPLE_MODELS.find_hf_info(model)
+    model_info.check_available_online(on_fail="skip")
+
+    tools = ([{
+        "type": "function",
+        "function": {
+            "name": "dummy_function_name",
+            "description": "This is a dummy function",
+            "parameters": sample_json_schema,
+        },
+    }])
+
+    chat_template_kwargs = {
+        # both unused
+        "unsed_kwargs_1": 123,
+        "unsed_kwargs_2": "abc",
+        # should not appear
+        "chat_template": "{% Hello world! %}",
+        # used by tokenizer
+        "continue_final_message": True,
+        "tools": tools,
+        # both used by Qwen2-VL and Qwen3
+        "add_generation_prompt": True,
+        # only used by Qwen2-VL
+        "add_vision_id": True,
+        # only used by Qwen3
+        "enable_thinking": True,
+    }
+
+    model_config = ModelConfig(
+        model,
+        tokenizer=model_info.tokenizer or model,
+        tokenizer_mode=model_info.tokenizer_mode,
+        revision=model_info.revision,
+        trust_remote_code=model_info.trust_remote_code,
+        hf_overrides=model_info.hf_overrides,
+        skip_tokenizer_init=model_info.skip_tokenizer_init,
+        enforce_eager=model_info.enforce_eager,
+        dtype=model_info.dtype)
+
+    # Build the tokenizer
+    tokenizer = get_tokenizer(
+        model,
+        trust_remote_code=model_config.trust_remote_code,
+    )
+
+    # Test detecting the tokenizer's chat_template
+    chat_template = resolve_hf_chat_template(
+        tokenizer,
+        chat_template=None,
+        tools=tools,
+        model_config=model_config,
+    )
+    resolved_chat_template_kwargs = resolve_chat_template_kwargs(
+        tokenizer,
+        chat_template=chat_template,
+        chat_template_kwargs=chat_template_kwargs,
+    )
+    assert set(resolved_chat_template_kwargs.keys()) == expected_kwargs
+
+
 # NOTE: Qwen2-Audio default chat template is specially defined inside
 # processor class instead of using `tokenizer_config.json`
 # yapf: disable
diff --git a/vllm/entrypoints/chat_utils.py b/vllm/entrypoints/chat_utils.py
index 4e1ecb9ed4c5..6b0ed23277d3 100644
--- a/vllm/entrypoints/chat_utils.py
+++ b/vllm/entrypoints/chat_utils.py
@@ -11,7 +11,12 @@
 from typing import (Any, Callable, Generic, Literal, Optional, TypeVar, Union,
                     cast)
 
+import jinja2
+import jinja2.ext
+import jinja2.meta
 import jinja2.nodes
+import jinja2.parser
+import jinja2.sandbox
 import transformers.utils.chat_template_utils as hf_chat_utils
 # yapf conflicts with isort for this block
 # yapf: disable
@@ -50,7 +55,7 @@
 # yapf: enable
 from vllm.transformers_utils.processor import cached_get_processor
 from vllm.transformers_utils.tokenizer import AnyTokenizer, MistralTokenizer
-from vllm.utils import random_uuid
+from vllm.utils import random_uuid, supports_kw
 
 logger = init_logger(__name__)
 
@@ -1554,6 +1559,46 @@ def parse_chat_messages_futures(
     return conversation, mm_tracker.all_mm_data(), mm_tracker.all_mm_uuids()
 
 
+# adapted from https://github.com/huggingface/transformers/blob/v4.56.2/src/transformers/utils/chat_template_utils.py#L398-L412
+# only preserve the parse function used to resolve chat template kwargs
+class AssistantTracker(jinja2.ext.Extension):
+    tags = {"generation"}
+
+    def parse(self, parser: jinja2.parser.Parser) -> jinja2.nodes.CallBlock:
+        lineno = next(parser.stream).lineno
+        body = parser.parse_statements(["name:endgeneration"], drop_needle=True)
+        call = self.call_method("_generation_support")
+        call_block = jinja2.nodes.CallBlock(call, [], [], body)
+        return call_block.set_lineno(lineno)
+
+
+def resolve_chat_template_kwargs(
+    tokenizer: Union[PreTrainedTokenizer, PreTrainedTokenizerFast],
+    chat_template: str,
+    chat_template_kwargs: dict[str, Any],
+) -> dict[str, Any]:
+    fn_kw = {
+        k for k in chat_template_kwargs
+        if supports_kw(tokenizer.apply_chat_template, k, allow_var_kwargs=False)
+    }
+
+    env = jinja2.sandbox.ImmutableSandboxedEnvironment(
+        trim_blocks=True,
+        lstrip_blocks=True,
+        extensions=[AssistantTracker, jinja2.ext.loopcontrols],
+    )
+    parsed_content = env.parse(chat_template)
+    template_vars = jinja2.meta.find_undeclared_variables(parsed_content)
+
+    # We exclude chat_template from kwargs here, because
+    # chat template has been already resolved at this stage
+    unexpected_vars = {"chat_template"}
+    accept_vars = (fn_kw | template_vars) - unexpected_vars
+    return {
+        k: v for k, v in chat_template_kwargs.items() if k in accept_vars
+    }
+
+
 def apply_hf_chat_template(
     tokenizer: Union[PreTrainedTokenizer, PreTrainedTokenizerFast],
     conversation: list[ConversationMessage],
@@ -1579,12 +1624,17 @@ def apply_hf_chat_template(
         )
 
     try:
+        resolved_kwargs = resolve_chat_template_kwargs(
+            tokenizer=tokenizer,
+            chat_template=hf_chat_template,
+            chat_template_kwargs=kwargs,
+        )
         return tokenizer.apply_chat_template(
             conversation=conversation,  # type: ignore[arg-type]
             tools=tools,  # type: ignore[arg-type]
             chat_template=hf_chat_template,
             tokenize=tokenize,
-            **kwargs,
+            **resolved_kwargs,
         )
 
     # External library exceptions can sometimes occur despite the framework's
diff --git a/vllm/entrypoints/openai/api_server.py b/vllm/entrypoints/openai/api_server.py
index d054e2826744..15844d3162fe 100644
--- a/vllm/entrypoints/openai/api_server.py
+++ b/vllm/entrypoints/openai/api_server.py
@@ -1716,6 +1716,7 @@ async def init_app_state(
         request_logger=request_logger,
         chat_template=resolved_chat_template,
         chat_template_content_format=args.chat_template_content_format,
+        trust_request_chat_template=args.trust_request_chat_template,
         return_tokens_as_token_ids=args.return_tokens_as_token_ids,
         enable_auto_tools=args.enable_auto_tool_choice,
         exclude_tools_when_tool_choice_none=args.
diff --git a/vllm/entrypoints/openai/cli_args.py b/vllm/entrypoints/openai/cli_args.py
index 1c2a6f58197d..a306c2bb7cb5 100644
--- a/vllm/entrypoints/openai/cli_args.py
+++ b/vllm/entrypoints/openai/cli_args.py
@@ -103,9 +103,13 @@ class FrontendArgs:
     chat_template_content_format: ChatTemplateContentFormatOption = "auto"
     """The format to render message content within a chat template.
 
-* "string" will render the content as a string. Example: `"Hello World"`
-* "openai" will render the content as a list of dictionaries, similar to OpenAI
-schema. Example: `[{"type": "text", "text": "Hello world!"}]`"""
+    * "string" will render the content as a string. Example: `"Hello World"`
+    * "openai" will render the content as a list of dictionaries, similar to
+      OpenAI schema. Example: `[{"type": "text", "text": "Hello world!"}]`"""
+    trust_request_chat_template: bool = False
+    """Whether to trust the chat template provided in the request. If False,
+    the server will always use the chat template specified by `--chat-template`
+    or the ones from tokenizer."""
     response_role: str = "assistant"
     """The role name to return if `request.add_generation_prompt=true`."""
     ssl_keyfile: Optional[str] = None
diff --git a/vllm/entrypoints/openai/serving_chat.py b/vllm/entrypoints/openai/serving_chat.py
index 0780448ad733..ab4bf75102f4 100644
--- a/vllm/entrypoints/openai/serving_chat.py
+++ b/vllm/entrypoints/openai/serving_chat.py
@@ -68,6 +68,7 @@ def __init__(
         request_logger: Optional[RequestLogger],
         chat_template: Optional[str],
         chat_template_content_format: ChatTemplateContentFormatOption,
+        trust_request_chat_template: bool = False,
         return_tokens_as_token_ids: bool = False,
         reasoning_parser: str = "",
         enable_auto_tools: bool = False,
@@ -89,6 +90,7 @@ def __init__(
         self.response_role = response_role
         self.chat_template = chat_template
         self.chat_template_content_format: Final = chat_template_content_format
+        self.trust_request_chat_template = trust_request_chat_template
         self.enable_log_outputs = enable_log_outputs
 
         # set up tool use
@@ -220,6 +222,16 @@ async def create_chat_completion(
 
             if not self.use_harmony:
                 # Common case.
+                request_chat_template = request.chat_template
+                chat_template_kwargs = request.chat_template_kwargs
+                if not self.trust_request_chat_template and (
+                        request_chat_template is not None or
+                    (chat_template_kwargs and
+                     chat_template_kwargs.get("chat_template") is not None)):
+                    return self.create_error_response(
+                        "Chat template is passed with request, but "
+                        "--trust-request-chat-template is not set. "
+                        "Refused request with untrusted chat template.")
                 (
                     conversation,
                     request_prompts,
@@ -228,7 +240,7 @@ async def create_chat_completion(
                     request,
                     tokenizer,
                     request.messages,
-                    chat_template=request.chat_template or self.chat_template,
+                    chat_template=request_chat_template or self.chat_template,
                     chat_template_content_format=self.
                     chat_template_content_format,
                     add_generation_prompt=request.add_generation_prompt,",
"url": "https://github.com/vllm-project/vllm/commit/7977e5027c2250a4abc1f474c5619c40b4e5682f.patch"
}
] | null |
GHSA-h93h-48cq-mpcw
| null |
[
{
"commit_message": "[PATCH] issue #30 issue #31 issue #32: no multiple format chunks in WAV or W64 cli/riff.c | 7 ++++++- cli/wave64.c | 6 ++++++ 2 files changed, 12 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/dbry/WavPack/commit/26cb47f99d481ad9b93eeff80d26e6b63bbd7e15.patch"
}
] | null |
|
CVE-2023-3521
|
Cross-site Scripting (XSS) - Reflected in fossbilling/fossbilling
|
Cross-site Scripting (XSS) - Reflected in GitHub repository fossbilling/fossbilling prior to 0.5.4.
|
[
{
"commit_message": "[PATCH] Prevent exceptions from being interpreted as HTML (#1394) src/library/FOSSBilling/ErrorPage.php | 2 +- src/load.php | 9 +++++---- 2 files changed, 6 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/fossbilling/fossbilling/commit/5eb516d4ebcb764db1b2edf9c8d0539e76ebde52.patch"
}
] |
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
GHSA-qppg-v75c-r5ff
|
S3Scanner allows Directory Traversal
| null |
[
{
"commit_message": "[PATCH 1/4] Verify object will land in output dir when downloading S3Scanner/S3Service.py | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-)",
"patch_text_b64": "From f03c8ee6673b6d5335b8be2354a611d5be407f4c Mon Sep 17 00:00:00 2001
From: Dan Salmon <dan@salmon.cat>
Date: Sat, 20 Nov 2021 10:43:44 -0600
Subject: [PATCH 1/4] Verify object will land in output dir when downloading

---
 S3Scanner/S3Service.py | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/S3Scanner/S3Service.py b/S3Scanner/S3Service.py
index 64788ec8..19fa312d 100644
--- a/S3Scanner/S3Service.py
+++ b/S3Scanner/S3Service.py
@@ -10,11 +10,12 @@
 from botocore.client import Config
 import datetime
 from S3Scanner.exceptions import AccessDeniedException, InvalidEndpointException, BucketMightNotExistException
-from os.path import normpath
 import pathlib
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from functools import partial
 from urllib3 import disable_warnings
+import os
+
 
 ALL_USERS_URI = 'uri=http://acs.amazonaws.com/groups/global/AllUsers'
 AUTH_USERS_URI = 'uri=http://acs.amazonaws.com/groups/global/AuthenticatedUsers'
@@ -284,7 +285,7 @@ def dump_bucket_multithread(self, bucket, dest_directory, verbose=False, threads
 
             for future in as_completed(futures):
                 if future.exception():
-                    print(f"{bucket.name} | Download failed: {futures[future]}")
+                    print(f"{bucket.name} | Download failed: {futures[future]} | {future.exception()}")
 
         print(f"{bucket.name} | Dumping completed")
 
@@ -298,7 +299,11 @@ def download_file(self, dest_directory, bucket, verbose, obj):
         :param S3BucketObject obj: Object to downlaod
         :return: None
         """
-        dest_file_path = pathlib.Path(normpath(dest_directory + obj.key))
+        dest_file_path = pathlib.Path(os.path.normpath(dest_directory + obj.key))
+
+        if not self.is_safe_file_to_download(obj.key, dest_directory):
+            print(f"{bucket.name} | Skipping file {obj.key}. File references a parent directory.")
+            return
         if dest_file_path.exists():
             if dest_file_path.stat().st_size == obj.size:
                 if verbose:
@@ -342,6 +347,20 @@ def enumerate_bucket_objects(self, bucket):
                 raise AccessDeniedException("AccessDenied while enumerating bucket objects")
         bucket.objects_enumerated = True
 
+    def is_safe_file_to_download(self, file_to_check, dest_directory):
+        """
+        Check if bucket object would be saved outside of `dest_directory` if downloaded.
+        AWS allows object keys to include relative path characters like '../' which can lead to a 
+        path traversal-like issue where objects get saved outside of the intended directory.
+
+        :param string file_to_check: Bucket object key
+        :param string dest_directory: Path to directory to save file in
+        :return: bool
+        """
+        file_to_check = os.path.abspath(os.path.join(dest_directory, file_to_check))
+        safe_dir = os.path.abspath(dest_directory)
+        return os.path.commonpath([safe_dir]) == os.path.commonpath([safe_dir, file_to_check])
+
     def parse_found_acl(self, bucket):
         """
         Translate ACL grants into permission properties. If we were able to read the ACLs, we should be able to skip

From 2807176ba92caedcd88b2e0d322da529536c7195 Mon Sep 17 00:00:00 2001
From: Dan Salmon <dan@salmon.cat>
Date: Sat, 20 Nov 2021 10:59:53 -0600
Subject: [PATCH 2/4] Fix issue with no trailing slash in dump dir

---
 S3Scanner/S3Service.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/S3Scanner/S3Service.py b/S3Scanner/S3Service.py
index 19fa312d..2ac38d19 100644
--- a/S3Scanner/S3Service.py
+++ b/S3Scanner/S3Service.py
@@ -293,13 +293,13 @@ def download_file(self, dest_directory, bucket, verbose, obj):
         """
         Download `obj` from `bucket` into `dest_directory`
 
-        :param str dest_directory: Directory to store the object into
+        :param str dest_directory: Directory to store the object into. _Must_ end in a slash
         :param S3Bucket bucket: Bucket to download the object from
         :param bool verbose: Output verbose messages to the user
         :param S3BucketObject obj: Object to downlaod
         :return: None
         """
-        dest_file_path = pathlib.Path(os.path.normpath(dest_directory + obj.key))
+        dest_file_path = pathlib.Path(os.path.normpath(os.path.join(dest_directory, obj.key)))
 
         if not self.is_safe_file_to_download(obj.key, dest_directory):
             print(f"{bucket.name} | Skipping file {obj.key}. File references a parent directory.")

From 125cb908e8f4c79716fae6e0cd51a822eb828947 Mon Sep 17 00:00:00 2001
From: Dan Salmon <dan@salmon.cat>
Date: Sat, 20 Nov 2021 11:23:44 -0600
Subject: [PATCH 3/4] Add tests for new check method

---
 tests/test_service.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/tests/test_service.py b/tests/test_service.py
index 3502743b..e51d0945 100644
--- a/tests/test_service.py
+++ b/tests/test_service.py
@@ -545,6 +545,19 @@ def test_download_file():
     b = S3Bucket("bucket-no-existo")
     s.download_file(os.path.join(dest_folder, ''), b, True, o)
 
+def test_is_safe_file_to_download():
+    test_setup_new()
+    s = S3Service()
+
+    # Check a good file name
+    assert s.is_safe_file_to_download("file.txt", "./bucket_dir/") == True
+    assert s.is_safe_file_to_download("file.txt", "./bucket_dir") == True
+
+    # Check file with relative name
+    assert s.is_safe_file_to_download("../file.txt", "./buckets/") == False
+    assert s.is_safe_file_to_download("../", "./buckets/") == False
+    assert s.is_safe_file_to_download("/file.txt", "./buckets/") == False
+
 
 def test_validate_endpoint_url_nonaws():
     disable_warnings()

From 37421e7f4f7a50f14bcf6635849a71089ebff19b Mon Sep 17 00:00:00 2001
From: Dan Salmon <dan@salmon.cat>
Date: Sun, 28 Nov 2021 14:48:17 -0600
Subject: [PATCH 4/4] Bump version to 2.0.2

---
 S3Scanner/__main__.py | 2 +-
 setup.cfg             | 2 +-
 tests/test_scanner.py | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/S3Scanner/__main__.py b/S3Scanner/__main__.py
index aeeee36b..ad9c0694 100644
--- a/S3Scanner/__main__.py
+++ b/S3Scanner/__main__.py
@@ -16,7 +16,7 @@
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from .exceptions import InvalidEndpointException
 
-CURRENT_VERSION = '2.0.1'
+CURRENT_VERSION = '2.0.2'
 AWS_ENDPOINT = 'https://s3.amazonaws.com'
 
 
diff --git a/setup.cfg b/setup.cfg
index 818f41fd..79fa8636 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,6 +1,6 @@
 [metadata]
 name = S3Scanner
-version = 2.0.1
+version = 2.0.2
 author = Dan Salmon
 author_email = dan@salmon.cat
 description = Scan for open S3 buckets and dump the contents
diff --git a/tests/test_scanner.py b/tests/test_scanner.py
index a892a2c1..664fc997 100644
--- a/tests/test_scanner.py
+++ b/tests/test_scanner.py
@@ -11,7 +11,7 @@ def test_arguments():
     s = S3Service()
 
     a = subprocess.run([sys.executable, '-m', 'S3Scanner', '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    assert a.stdout.decode('utf-8').strip() == '2.0.1'
+    assert a.stdout.decode('utf-8').strip() == '2.0.2'
 
     b = subprocess.run([sys.executable, '-m', 'S3Scanner', 'scan', '--bucket', 'flaws.cloud'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     assert_scanner_output(s, 'flaws.cloud | bucket_exists | AuthUsers: [], AllUsers: [Read]', b.stdout.decode('utf-8').strip())",
"url": "https://github.com/sa7mon/S3Scanner/commit/fafa30a3bd35b496b3f7db9bfc35b75a8a06bcd1.patch"
}
] | null |
GHSA-8gvg-8vhf-h26g
|
Out-of-bounds write
| null |
[
{
"commit_message": "[PATCH] [CVE-2019-0937] lib/Runtime/ByteCode/ByteCodeEmitter.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+)",
"patch_text_b64": "RnJvbSA3ODI3ZTExNzc1MzA1MmQ0NzlmYWJlMTlhMjVjZmVjZTg4MDU5YmNhIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBQYXVsIExlYXRoZXJzIDxwbGVhdGhAbWljcm9zb2Z0LmNvbT4KRGF0ZTogV2VkLCAxNyBBcHIgMjAxOSAxNTo0MjozNSAtMDcwMApTdWJqZWN0OiBbUEFUQ0hdIFtDVkUtMjAxOS0wOTM3XQoKLS0tCiBsaWIvUnVudGltZS9CeXRlQ29kZS9CeXRlQ29kZUVtaXR0ZXIuY3BwIHwgMTAgKysrKysrKysrKwogMSBmaWxlIGNoYW5nZWQsIDEwIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9saWIvUnVudGltZS9CeXRlQ29kZS9CeXRlQ29kZUVtaXR0ZXIuY3BwIGIvbGliL1J1bnRpbWUvQnl0ZUNvZGUvQnl0ZUNvZGVFbWl0dGVyLmNwcAppbmRleCA1YzA3OTgyYjkyYi4uOTMzYTIxZDM4NWQgMTAwNjQ0Ci0tLSBhL2xpYi9SdW50aW1lL0J5dGVDb2RlL0J5dGVDb2RlRW1pdHRlci5jcHAKKysrIGIvbGliL1J1bnRpbWUvQnl0ZUNvZGUvQnl0ZUNvZGVFbWl0dGVyLmNwcApAQCAtNDAwNiw2ICs0MDA2LDExIEBAIHZvaWQgQnl0ZUNvZGVHZW5lcmF0b3I6OlN0YXJ0RW1pdENhdGNoKFBhcnNlTm9kZUNhdGNoICpwbm9kZUNhdGNoKQogICAgICAgICAgICAgICAgIHN5bS0+U2V0SXNHbG9iYWxDYXRjaCh0cnVlKTsKICAgICAgICAgICAgIH0KIAorICAgICAgICAgICAgaWYgKHN5bS0+TmVlZHNTY29wZU9iamVjdCgpKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICAgIHNjb3BlLT5TZXRJc09iamVjdCgpOworICAgICAgICAgICAgfQorCiAgICAgICAgICAgICBBc3NlcnQoc3ltLT5HZXRTY29wZVNsb3QoKSA9PSBKczo6Q29uc3RhbnRzOjpOb1Byb3BlcnR5KTsKICAgICAgICAgICAgIGlmIChzeW0tPk5lZWRzU2xvdEFsbG9jKHRoaXMsIGZ1bmNJbmZvKSkKICAgICAgICAgICAgIHsKQEAgLTQwMjksNiArNDAzNCwxMSBAQCB2b2lkIEJ5dGVDb2RlR2VuZXJhdG9yOjpTdGFydEVtaXRDYXRjaChQYXJzZU5vZGVDYXRjaCAqcG5vZGVDYXRjaCkKICAgICAgICAgICAgIHN5bS0+U2V0SXNHbG9iYWxDYXRjaCh0cnVlKTsKICAgICAgICAgfQogCisgICAgICAgIGlmIChzeW0tPk5lZWRzU2NvcGVPYmplY3QoKSkKKyAgICAgICAgeworICAgICAgICAgICAgc2NvcGUtPlNldElzT2JqZWN0KCk7CisgICAgICAgIH0KKwogICAgICAgICBpZiAoc2NvcGUtPkdldE11c3RJbnN0YW50aWF0ZSgpKQogICAgICAgICB7CiAgICAgICAgICAgICBpZiAoc3ltLT5Jc0luU2xvdCh0aGlzLCBmdW5jSW5mbykp",
"url": "https://github.com/chakra-core/ChakraCore/commit/7827e117753052d479fabe19a25cfece88059bca.patch"
},
{
"commit_message": "[PATCH 01/13] [CVE-2019-0922] Type confusion in Edge - Individual lib/Backend/GlobOptArrays.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)",
"patch_text_b64": "From a9ab1aae31078e80593b9227db11d316c2239ef3 Mon Sep 17 00:00:00 2001
From: Meghana Gupta <megupta@microsoft.com>
Date: Fri, 12 Apr 2019 16:15:50 -0700
Subject: [PATCH 01/13] [CVE-2019-0922] Type confusion in Edge - Individual

---
 lib/Backend/GlobOptArrays.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/Backend/GlobOptArrays.cpp b/lib/Backend/GlobOptArrays.cpp
index 135fcf5c108..9ac28c59c12 100644
--- a/lib/Backend/GlobOptArrays.cpp
+++ b/lib/Backend/GlobOptArrays.cpp
@@ -1736,7 +1736,14 @@ void GlobOpt::ArraySrcOpt::Optimize()
     {
         if (newBaseValueType != baseValueType)
         {
-            UpdateValue(nullptr, nullptr, nullptr);
+            if (globOpt->IsSafeToTransferInPrePass(baseOpnd, baseValue))
+            {
+                UpdateValue(nullptr, nullptr, nullptr);
+            }
+            else if (globOpt->IsOperationThatLikelyKillsJsArraysWithNoMissingValues(instr) && baseValueInfo->HasNoMissingValues())
+            {
+                globOpt->ChangeValueType(nullptr, baseValue, baseValueInfo->Type().SetHasNoMissingValues(false), true);
+            }
         }
 
         // For javascript arrays and objects with javascript arrays:

From 6615113a09c0618ecc10e5680ffb978bf665641f Mon Sep 17 00:00:00 2001
From: Paul Leathers <pleath@microsoft.com>
Date: Tue, 16 Apr 2019 15:24:32 -0700
Subject: [PATCH 02/13] [CVE-2019-0924]

---
 lib/Backend/BackwardPass.cpp   |  3 +--
 lib/Backend/GlobOptBailOut.cpp |  8 ++++++
 lib/Backend/Inline.cpp         |  2 ++
 lib/Backend/Lower.cpp          | 46 +++++++++++++++++++++++-----------
 lib/Runtime/ByteCode/OpCodes.h |  4 +--
 5 files changed, 45 insertions(+), 18 deletions(-)

diff --git a/lib/Backend/BackwardPass.cpp b/lib/Backend/BackwardPass.cpp
index d94e79fab7f..be4e42d4be4 100644
--- a/lib/Backend/BackwardPass.cpp
+++ b/lib/Backend/BackwardPass.cpp
@@ -4677,10 +4677,9 @@ BackwardPass::ProcessNewScObject(IR::Instr* instr)
         return;
     }
 
-    if (instr->HasBailOutInfo())
+    if (instr->HasBailOutInfo() && (instr->GetBailOutKind() & ~IR::BailOutKindBits) == IR::BailOutFailedCtorGuardCheck)
     {
         Assert(instr->IsProfiledInstr());
-        Assert(instr->GetBailOutKind() == IR::BailOutFailedCtorGuardCheck);
         Assert(instr->GetDst()->IsRegOpnd());
 
         BasicBlock * block = this->currentBlock;
diff --git a/lib/Backend/GlobOptBailOut.cpp b/lib/Backend/GlobOptBailOut.cpp
index c27a7af7863..f168545b3b2 100644
--- a/lib/Backend/GlobOptBailOut.cpp
+++ b/lib/Backend/GlobOptBailOut.cpp
@@ -1337,6 +1337,14 @@ GlobOpt::MayNeedBailOnImplicitCall(IR::Instr const * instr, Value const * src1Va
             );
     }
 
+    case Js::OpCode::NewScObjectNoCtor:
+        if (instr->HasBailOutInfo() && (instr->GetBailOutKind() & ~IR::BailOutKindBits) == IR::BailOutFailedCtorGuardCheck)
+        {
+            // No helper call with this bailout.
+            return false;
+        }
+        break;
+
     default:
         break;
     }
diff --git a/lib/Backend/Inline.cpp b/lib/Backend/Inline.cpp
index b185ad83aea..5703333c78c 100644
--- a/lib/Backend/Inline.cpp
+++ b/lib/Backend/Inline.cpp
@@ -4204,6 +4204,8 @@ Inline::SplitConstructorCallCommon(
     {
         createObjInstr->SetByteCodeOffset(newObjInstr);
         createObjInstr->GetSrc1()->SetIsJITOptimizedReg(true);
+        // We're splitting a single byte code, so the interpreter has to resume from the beginning if we bail out.
+        createObjInstr->forcePreOpBailOutIfNeeded = true;
         newObjInstr->InsertBefore(createObjInstr);
 
         createObjDst->SetValueType(ValueType::GetObject(ObjectType::UninitializedObject));
diff --git a/lib/Backend/Lower.cpp b/lib/Backend/Lower.cpp
index a5d19c4021e..52b5be80238 100644
--- a/lib/Backend/Lower.cpp
+++ b/lib/Backend/Lower.cpp
@@ -4601,18 +4601,40 @@ Lowerer::LowerNewScObject(IR::Instr *newObjInstr, bool callCtor, bool hasArgs, b
         {
             Assert(!newObjDst->CanStoreTemp());
             // createObjDst = NewScObject...(ctorOpnd)
-            newScHelper = !callCtor ?
-                (isBaseClassConstructorNewScObject ?
-                    (hasArgs ? IR::HelperNewScObjectNoCtorFull : IR::HelperNewScObjectNoArgNoCtorFull) :
-                    (hasArgs ? IR::HelperNewScObjectNoCtor : IR::HelperNewScObjectNoArgNoCtor)) :
-                (hasArgs || usedFixedCtorCache ? IR::HelperNewScObjectNoCtor : IR::HelperNewScObjectNoArg);
 
             LoadScriptContext(newObjInstr);
-            m_lowererMD.LoadHelperArgument(newObjInstr, newObjInstr->GetSrc1());
 
-            newScObjCall = IR::Instr::New(Js::OpCode::Call, createObjDst, IR::HelperCallOpnd::New(newScHelper, func), func);
-            newObjInstr->InsertBefore(newScObjCall);
-            m_lowererMD.LowerCall(newScObjCall, 0);
+            if (callCtor)
+            {
+                newScHelper = (hasArgs || usedFixedCtorCache ? IR::HelperNewScObjectNoCtor : IR::HelperNewScObjectNoArg);
+
+                m_lowererMD.LoadHelperArgument(newObjInstr, newObjInstr->GetSrc1());
+
+                newScObjCall = IR::Instr::New(Js::OpCode::Call, createObjDst, IR::HelperCallOpnd::New(newScHelper, func), func);
+                newObjInstr->InsertBefore(newScObjCall);
+                m_lowererMD.LowerCall(newScObjCall, 0);
+            }
+            else
+            {
+                newScHelper = 
+                    (isBaseClassConstructorNewScObject ?
+                        (hasArgs ? IR::HelperNewScObjectNoCtorFull : IR::HelperNewScObjectNoArgNoCtorFull) :
+                        (hasArgs ? IR::HelperNewScObjectNoCtor : IR::HelperNewScObjectNoArgNoCtor));
+
+                // Branch around the helper call to execute the inlined ctor.
+                Assert(callCtorLabel != nullptr);
+                newObjInstr->InsertAfter(callCtorLabel);
+
+                // Change the NewScObject* to a helper call on the spot. This generates implicit call bailout for us if we need one.
+                m_lowererMD.LoadHelperArgument(newObjInstr, newObjInstr->UnlinkSrc1());
+                m_lowererMD.ChangeToHelperCall(newObjInstr, newScHelper);
+
+                // Then we're done.
+                Assert(createObjDst == newObjDst);
+
+                // Return the first instruction above the region we've just lowered.
+                return RemoveLoweredRegionStartMarker(startMarkerInstr);                    
+            }
         }
     }
 
@@ -4857,9 +4879,6 @@ bool Lowerer::TryLowerNewScObjectWithFixedCtorCache(IR::Instr* newObjInstr, IR::
     skipNewScObj = false;
     returnNewScObj = false;
 
-    AssertMsg(!PHASE_OFF(Js::ObjTypeSpecNewObjPhase, this->m_func) || !newObjInstr->HasBailOutInfo(),
-        "Why do we have bailout on NewScObject when ObjTypeSpecNewObj is off?");
-
     if (PHASE_OFF(Js::FixedNewObjPhase, newObjInstr->m_func) && PHASE_OFF(Js::ObjTypeSpecNewObjPhase, this->m_func))
     {
         return false;
@@ -4867,11 +4886,10 @@ bool Lowerer::TryLowerNewScObjectWithFixedCtorCache(IR::Instr* newObjInstr, IR::
 
     JITTimeConstructorCache * ctorCache;
 
-    if (newObjInstr->HasBailOutInfo())
+    if (newObjInstr->HasBailOutInfo() && (newObjInstr->GetBailOutKind() & ~IR::BailOutKindBits) == IR::BailOutFailedCtorGuardCheck)
     {
         Assert(newObjInstr->IsNewScObjectInstr());
         Assert(newObjInstr->IsProfiledInstr());
-        Assert(newObjInstr->GetBailOutKind() == IR::BailOutFailedCtorGuardCheck);
 
         emitBailOut = true;
 
diff --git a/lib/Runtime/ByteCode/OpCodes.h b/lib/Runtime/ByteCode/OpCodes.h
index cb9d1ed9552..d75019d0d04 100755
--- a/lib/Runtime/ByteCode/OpCodes.h
+++ b/lib/Runtime/ByteCode/OpCodes.h
@@ -577,8 +577,8 @@ MACRO_EXTEND_WMS_AND_PROFILED(NewScObjectSpread,   CallIExtended, OpSideEffect|O
 MACRO_WMS_PROFILED2(    NewScObjArray,      CallI,          OpSideEffect|OpUseAllFields|OpCallInstr)        // Create new ScriptObject instance
 MACRO_WMS_PROFILED2(    NewScObjArraySpread, CallIExtended, OpSideEffect|OpUseAllFields|OpCallInstr)        // Create new ScriptObject instance
 MACRO(                  NewScObject_A,      Auxiliary,      OpSideEffect|OpUseAllFields)                    // Create new ScriptObject instance passing only constants
-MACRO_WMS(              NewScObjectNoCtorFull, Reg2,        OpTempObjectCanStoreTemp)                       // Create new object that will be used for the 'this' binding in a base class constructor
-MACRO_BACKEND_ONLY(     NewScObjectNoCtor,  Empty,          OpTempObjectCanStoreTemp)                       // Create new object that will be passed into a constructor
+MACRO_WMS(              NewScObjectNoCtorFull, Reg2,        OpTempObjectCanStoreTemp|OpHasImplicitCall)     // Create new object that will be used for the 'this' binding in a base class constructor
+MACRO_BACKEND_ONLY(     NewScObjectNoCtor,  Empty,          OpTempObjectCanStoreTemp|OpHasImplicitCall)     // Create new object that will be passed into a constructor
 MACRO_BACKEND_ONLY(     GetNewScObject,     Empty,          OpTempObjectTransfer)                           // Determine which object to finally use as the result of NewScObject (object passed into constructor as 'this', or object returned by constructor)
 MACRO_BACKEND_ONLY(     UpdateNewScObjectCache, Empty,      None)                                           // Update the cache used for NewScObject
 MACRO_WMS(              NewScObjectSimple,  Reg1,           OpTempObjectCanStoreTemp)

From 32ca10f3955f2a3ca56c6671c721b1264eca06b8 Mon Sep 17 00:00:00 2001
From: Paul Leathers <pleath@microsoft.com>
Date: Tue, 16 Apr 2019 17:19:00 -0700
Subject: [PATCH 03/13] [CVE-2019-0925]

---
 lib/Backend/GlobOpt.cpp       | 1 +
 lib/Backend/GlobOptFields.cpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/lib/Backend/GlobOpt.cpp b/lib/Backend/GlobOpt.cpp
index 76af5504773..661c72dcb0b 100644
--- a/lib/Backend/GlobOpt.cpp
+++ b/lib/Backend/GlobOpt.cpp
@@ -13462,6 +13462,7 @@ GlobOpt::CheckJsArrayKills(IR::Instr *const instr)
             break;
 
         case Js::OpCode::NewScObjectNoCtor:
+        case Js::OpCode::NewScObjectNoCtorFull:
             if(doNativeArrayTypeSpec)
             {
                 // Class/object construction can make something a prototype
diff --git a/lib/Backend/GlobOptFields.cpp b/lib/Backend/GlobOptFields.cpp
index dbddb245921..c355563523d 100644
--- a/lib/Backend/GlobOptFields.cpp
+++ b/lib/Backend/GlobOptFields.cpp
@@ -492,6 +492,7 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
     case Js::OpCode::InitClass:
     case Js::OpCode::InitProto:
     case Js::OpCode::NewScObjectNoCtor:
+    case Js::OpCode::NewScObjectNoCtorFull:
         if (inGlobOpt)
         {
             // Opcodes that make an object into a prototype may break object-header-inlining and final type opt.

From a2deba5e1850782014a2a34678464b251e448337 Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Wed, 17 Apr 2019 09:51:46 -0700
Subject: [PATCH 04/13] [CVE-2019-0911]

---
 lib/Runtime/Library/ES5Array.cpp        | 4 ++++
 lib/Runtime/Library/JavascriptArray.cpp | 3 +++
 2 files changed, 7 insertions(+)

diff --git a/lib/Runtime/Library/ES5Array.cpp b/lib/Runtime/Library/ES5Array.cpp
index 67351df1b84..fa978be3af7 100644
--- a/lib/Runtime/Library/ES5Array.cpp
+++ b/lib/Runtime/Library/ES5Array.cpp
@@ -148,6 +148,10 @@ namespace Js
             {
                 JavascriptError::ThrowRangeError(scriptContext, JSERR_ArrayLengthAssignIncorrect);
             }
+
+            // Conversion can change the type (e.g. from String), invalidating assumptions made by the JIT
+            scriptContext->GetThreadContext()->AddImplicitCallFlags(ImplicitCall_Accessor);
+
             return newLen;
         }
     }
diff --git a/lib/Runtime/Library/JavascriptArray.cpp b/lib/Runtime/Library/JavascriptArray.cpp
index a762a4d9cbb..e05f2313551 100644
--- a/lib/Runtime/Library/JavascriptArray.cpp
+++ b/lib/Runtime/Library/JavascriptArray.cpp
@@ -2930,6 +2930,9 @@ using namespace Js;
         double dblValue = JavascriptConversion::ToNumber(newLength, scriptContext);
         if (dblValue == uintValue)
         {
+            // Conversion can change the type (e.g. from String), invalidating assumptions made by the JIT
+            scriptContext->GetThreadContext()->AddImplicitCallFlags(ImplicitCall_Accessor);
+
             this->SetLength(uintValue);
         }
         else

From 936a5af1c07e0fdec9aab85c05339dabe4aaeeb1 Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Wed, 17 Apr 2019 10:18:03 -0700
Subject: [PATCH 05/13] [CVE-2019-0912]

---
 lib/Backend/GlobOptFields.cpp | 31 ++++++++++++++++++++++++-------
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/lib/Backend/GlobOptFields.cpp b/lib/Backend/GlobOptFields.cpp
index c355563523d..2eff8b7c61f 100644
--- a/lib/Backend/GlobOptFields.cpp
+++ b/lib/Backend/GlobOptFields.cpp
@@ -415,11 +415,19 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
 
     case Js::OpCode::InlineArrayPush:
     case Js::OpCode::InlineArrayPop:
-        KillLiveFields(this->lengthEquivBv, bv);
-        if (inGlobOpt)
+        if(instr->m_func->GetThisOrParentInlinerHasArguments())
         {
-            // Deleting an item, or pushing a property to a non-array, may change object layout
-            KillAllObjectTypes(bv);
+            this->KillAllFields(bv);
+            this->SetAnyPropertyMayBeWrittenTo();
+        }
+        else
+        {
+            KillLiveFields(this->lengthEquivBv, bv);
+            if (inGlobOpt)
+            {
+                // Deleting an item, or pushing a property to a non-array, may change object layout
+                KillAllObjectTypes(bv);
+            }
         }
         break;
 
@@ -444,14 +452,23 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
                 // Kill length field for built-ins that can update it.
                 if (nullptr != this->lengthEquivBv)
                 {
-                    KillLiveFields(this->lengthEquivBv, bv);
+                    // If has arguments, all fields are killed in fall through
+                    if (!instr->m_func->GetThisOrParentInlinerHasArguments())
+                    {
+                        KillLiveFields(this->lengthEquivBv, bv);
+                    }
                 }
                 // fall through
 
             case IR::JnHelperMethod::HelperArray_Reverse:
-                // Deleting an item may change object layout
-                if (inGlobOpt)
+                if (instr->m_func->GetThisOrParentInlinerHasArguments())
+                {
+                    this->KillAllFields(bv);
+                    this->SetAnyPropertyMayBeWrittenTo();
+                }
+                else if (inGlobOpt)
                 {
+                    // Deleting an item may change object layout
                     KillAllObjectTypes(bv);
                 }
                 break;

From 87ac2b5a751710ee288fdda3fd4d9818e22387a1 Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Wed, 17 Apr 2019 10:22:17 -0700
Subject: [PATCH 06/13] [CVE-2019-0927]

---
 lib/Backend/GlobOptFields.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/Backend/GlobOptFields.cpp b/lib/Backend/GlobOptFields.cpp
index 2eff8b7c61f..05594e71269 100644
--- a/lib/Backend/GlobOptFields.cpp
+++ b/lib/Backend/GlobOptFields.cpp
@@ -394,6 +394,7 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
     case Js::OpCode::StRootFldStrict:
     case Js::OpCode::StSlot:
     case Js::OpCode::StSlotChkUndecl:
+    case Js::OpCode::StSuperFld:
         Assert(dstOpnd != nullptr);
         sym = dstOpnd->AsSymOpnd()->m_sym;
         if (inGlobOpt)

From 1a550c67b33b27675c0553152cabd09e4ffe3abf Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Wed, 17 Apr 2019 10:27:02 -0700
Subject: [PATCH 07/13] [CVE-2019-0933]

---
 lib/Backend/GlobOpt.cpp     | 1 +
 lib/Backend/GlobOptExpr.cpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/lib/Backend/GlobOpt.cpp b/lib/Backend/GlobOpt.cpp
index 661c72dcb0b..7928a50f46d 100644
--- a/lib/Backend/GlobOpt.cpp
+++ b/lib/Backend/GlobOpt.cpp
@@ -13251,6 +13251,7 @@ GlobOpt::CheckJsArrayKills(IR::Instr *const instr)
 
         case Js::OpCode::StFld:
         case Js::OpCode::StFldStrict:
+        case Js::OpCode::StSuperFld:
         {
             Assert(instr->GetDst());
 
diff --git a/lib/Backend/GlobOptExpr.cpp b/lib/Backend/GlobOptExpr.cpp
index cc1d4ff0820..13a9bfb0f49 100644
--- a/lib/Backend/GlobOptExpr.cpp
+++ b/lib/Backend/GlobOptExpr.cpp
@@ -822,6 +822,7 @@ GlobOpt::ProcessArrayValueKills(IR::Instr *instr)
     case Js::OpCode::StRootFld:
     case Js::OpCode::StFldStrict:
     case Js::OpCode::StRootFldStrict:
+    case Js::OpCode::StSuperFld:
     case Js::OpCode::StSlot:
     case Js::OpCode::StSlotChkUndecl:
     case Js::OpCode::DeleteFld:

From d85b5025b047f10784c53c6c1dd771775d417f5f Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Wed, 17 Apr 2019 10:34:39 -0700
Subject: [PATCH 08/13] 
 [CVE-2019-0913][CVE-2019-0914][CVE-2019-0915][CVE-2019-0916]

---
 lib/Backend/GlobOpt.cpp       |  5 +++++
 lib/Backend/GlobOptExpr.cpp   |  7 +++++++
 lib/Backend/GlobOptFields.cpp | 25 +++++++++++++++++++++++++
 3 files changed, 37 insertions(+)

diff --git a/lib/Backend/GlobOpt.cpp b/lib/Backend/GlobOpt.cpp
index 7928a50f46d..261d6b9a5ca 100644
--- a/lib/Backend/GlobOpt.cpp
+++ b/lib/Backend/GlobOpt.cpp
@@ -13199,6 +13199,7 @@ GlobOpt::CheckJsArrayKills(IR::Instr *const instr)
     const bool useValueTypes = !IsLoopPrePass(); // Source value types are not guaranteed to be correct in a loop prepass
     switch(instr->m_opcode)
     {
+        case Js::OpCode::StElemC:
         case Js::OpCode::StElemI_A:
         case Js::OpCode::StElemI_A_Strict:
         {
@@ -13249,6 +13250,10 @@ GlobOpt::CheckJsArrayKills(IR::Instr *const instr)
             }
             break;
 
+        case Js::OpCode::ConsoleScopedStFld:
+        case Js::OpCode::ConsoleScopedStFldStrict:
+        case Js::OpCode::ScopedStFld:
+        case Js::OpCode::ScopedStFldStrict:
         case Js::OpCode::StFld:
         case Js::OpCode::StFldStrict:
         case Js::OpCode::StSuperFld:
diff --git a/lib/Backend/GlobOptExpr.cpp b/lib/Backend/GlobOptExpr.cpp
index 13a9bfb0f49..d95b63779ce 100644
--- a/lib/Backend/GlobOptExpr.cpp
+++ b/lib/Backend/GlobOptExpr.cpp
@@ -814,10 +814,15 @@ GlobOpt::ProcessArrayValueKills(IR::Instr *instr)
 {
     switch (instr->m_opcode)
     {
+    case Js::OpCode::StElemC:
     case Js::OpCode::StElemI_A:
     case Js::OpCode::StElemI_A_Strict:
     case Js::OpCode::DeleteElemI_A:
     case Js::OpCode::DeleteElemIStrict_A:
+    case Js::OpCode::ConsoleScopedStFld:
+    case Js::OpCode::ConsoleScopedStFldStrict:
+    case Js::OpCode::ScopedStFld:
+    case Js::OpCode::ScopedStFldStrict:
     case Js::OpCode::StFld:
     case Js::OpCode::StRootFld:
     case Js::OpCode::StFldStrict:
@@ -829,6 +834,8 @@ GlobOpt::ProcessArrayValueKills(IR::Instr *instr)
     case Js::OpCode::DeleteRootFld:
     case Js::OpCode::DeleteFldStrict:
     case Js::OpCode::DeleteRootFldStrict:
+    case Js::OpCode::ScopedDeleteFld:
+    case Js::OpCode::ScopedDeleteFldStrict:
     case Js::OpCode::StArrViewElem:
     // These array helpers may change A.length (and A[i] could be A.length)...
     case Js::OpCode::InlineArrayPush:
diff --git a/lib/Backend/GlobOptFields.cpp b/lib/Backend/GlobOptFields.cpp
index 05594e71269..5a0e3fa8337 100644
--- a/lib/Backend/GlobOptFields.cpp
+++ b/lib/Backend/GlobOptFields.cpp
@@ -335,6 +335,7 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
     IR::JnHelperMethod fnHelper;
     switch(instr->m_opcode)
     {
+    case Js::OpCode::StElemC:
     case Js::OpCode::StElemI_A:
     case Js::OpCode::StElemI_A_Strict:
         Assert(dstOpnd != nullptr);
@@ -366,6 +367,8 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
     case Js::OpCode::DeleteRootFld:
     case Js::OpCode::DeleteFldStrict:
     case Js::OpCode::DeleteRootFldStrict:
+    case Js::OpCode::ScopedDeleteFld:
+    case Js::OpCode::ScopedDeleteFldStrict:
         sym = instr->GetSrc1()->AsSymOpnd()->m_sym;
         KillLiveFields(sym->AsPropertySym(), bv);
         if (inGlobOpt)
@@ -387,7 +390,29 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
             this->KillAllObjectTypes(bv);
         }
         break;
+
+    case Js::OpCode::ConsoleScopedStFld:
+    case Js::OpCode::ConsoleScopedStFldStrict:
+    case Js::OpCode::ScopedStFld:
+    case Js::OpCode::ScopedStFldStrict:
+        // This is already taken care of for FastFld opcodes
+
+        if (inGlobOpt)
+        {
+            KillObjectHeaderInlinedTypeSyms(this->currentBlock, false);
+        }
+
+        // fall through
+
     case Js::OpCode::InitFld:
+    case Js::OpCode::InitConstFld:
+    case Js::OpCode::InitLetFld:
+    case Js::OpCode::InitRootFld:
+    case Js::OpCode::InitRootConstFld:
+    case Js::OpCode::InitRootLetFld:
+#if !FLOATVAR
+    case Js::OpCode::StSlotBoxTemp:
+#endif
     case Js::OpCode::StFld:
     case Js::OpCode::StRootFld:
     case Js::OpCode::StFldStrict:

From 972584709518380a4a3c2410b5fa151f6f0239b1 Mon Sep 17 00:00:00 2001
From: Akrosh Gandhi <akroshg@microsoft.com>
Date: Wed, 17 Apr 2019 13:42:43 -0700
Subject: [PATCH 09/13] [CVE-2019-0923] Scripting Engine Memory Corruption -
 Individual

After reparsing the coroutines (generator/async functions) the register which holds yield data has changed.
This is due to scoping structure for debugger.
In order to fix that allow the same scoping numbering for coroutine as well.
Also added a failfast to see if the yield register information is the same before and after reparsing.
---
 lib/Runtime/ByteCode/ByteCodeEmitter.cpp   |  1 +
 lib/Runtime/ByteCode/ByteCodeGenerator.cpp | 12 ++++----
 lib/Runtime/Debug/DebugContext.cpp         | 34 +++++++++++++++++++++-
 3 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
index 5820ab38a8d..5c07982b92b 100644
--- a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
+++ b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
@@ -3590,6 +3590,7 @@ void ByteCodeGenerator::StartEmitFunction(ParseNodeFnc *pnodeFnc)
 #if ENABLE_TTD
                     && !funcInfo->GetParsedFunctionBody()->GetScriptContext()->GetThreadContext()->IsRuntimeInTTDMode()
 #endif
+                    && !funcInfo->byteCodeFunction->IsCoroutine()
                 );
 
                 if (funcInfo->GetHasCachedScope())
diff --git a/lib/Runtime/ByteCode/ByteCodeGenerator.cpp b/lib/Runtime/ByteCode/ByteCodeGenerator.cpp
index 77c52fc8361..1d6c3f1d17e 100644
--- a/lib/Runtime/ByteCode/ByteCodeGenerator.cpp
+++ b/lib/Runtime/ByteCode/ByteCodeGenerator.cpp
@@ -119,10 +119,10 @@ void EndVisitBlock(ParseNodeBlock *pnode, ByteCodeGenerator *byteCodeGenerator)
         Scope *scope = pnode->scope;
         FuncInfo *func = scope->GetFunc();
 
-        if (!byteCodeGenerator->IsInDebugMode() &&
-            scope->HasInnerScopeIndex())
+        if (!(byteCodeGenerator->IsInDebugMode() || func->byteCodeFunction->IsCoroutine())
+            && scope->HasInnerScopeIndex())
         {
-            // In debug mode, don't release the current index, as we're giving each scope a unique index, regardless
+            // In debug mode (or for the generator/async function), don't release the current index, as we're giving each scope a unique index, regardless
             // of nesting.
             Assert(scope->GetInnerScopeIndex() == func->CurrentInnerScopeIndex());
             func->ReleaseInnerScopeIndex();
@@ -155,12 +155,12 @@ void BeginVisitCatch(ParseNode *pnode, ByteCodeGenerator *byteCodeGenerator)
 void EndVisitCatch(ParseNode *pnode, ByteCodeGenerator *byteCodeGenerator)
 {
     Scope *scope = pnode->AsParseNodeCatch()->scope;
+    FuncInfo *func = scope->GetFunc();
 
-    if (scope->HasInnerScopeIndex() && !byteCodeGenerator->IsInDebugMode())
+    if (scope->HasInnerScopeIndex() && !(byteCodeGenerator->IsInDebugMode() || func->byteCodeFunction->IsCoroutine()))
     {
-        // In debug mode, don't release the current index, as we're giving each scope a unique index,
+        // In debug mode (or for the generator/async function), don't release the current index, as we're giving each scope a unique index,
         // regardless of nesting.
-        FuncInfo *func = scope->GetFunc();
 
         Assert(scope->GetInnerScopeIndex() == func->CurrentInnerScopeIndex());
         func->ReleaseInnerScopeIndex();
diff --git a/lib/Runtime/Debug/DebugContext.cpp b/lib/Runtime/Debug/DebugContext.cpp
index 7f9eb30c8a0..35379ddf6de 100644
--- a/lib/Runtime/Debug/DebugContext.cpp
+++ b/lib/Runtime/Debug/DebugContext.cpp
@@ -193,6 +193,11 @@ namespace Js
         Js::TempArenaAllocatorObject *tempAllocator = nullptr;
         JsUtil::List<Js::FunctionInfo *, Recycler>* pFunctionsToRegister = nullptr;
         JsUtil::List<Js::Utf8SourceInfo *, Recycler, false, Js::CopyRemovePolicy, RecyclerPointerComparer>* utf8SourceInfoList = nullptr;
+        typedef JsUtil::BaseDictionary<uint32, RegSlot, ArenaAllocator, PowerOf2SizePolicy> FunctionStartToYieldRegister;
+
+        // This container ensures that for Generator/Async functions the yield register is same between non-debug to debug parse.
+        // Each entry represent a function's start position (each function will have unique start position in a file) and that function yield register
+        FunctionStartToYieldRegister *yieldFunctions = nullptr;
 
         HRESULT hr = S_OK;
         ThreadContext* threadContext = this->scriptContext->GetThreadContext();
@@ -201,6 +206,7 @@ namespace Js
         tempAllocator = threadContext->GetTemporaryAllocator(_u("debuggerAlloc"));
 
         utf8SourceInfoList = JsUtil::List<Js::Utf8SourceInfo *, Recycler, false, Js::CopyRemovePolicy, RecyclerPointerComparer>::New(this->scriptContext->GetRecycler());
+        yieldFunctions = Anew(tempAllocator->GetAllocator(), FunctionStartToYieldRegister, tempAllocator->GetAllocator());
 
         this->MapUTF8SourceInfoUntil([&](Js::Utf8SourceInfo * sourceInfo) -> bool
         {
@@ -276,6 +282,23 @@ namespace Js
                 this->hostDebugContext->SetThreadDescription(sourceInfo->GetSourceContextInfo()->url); // the HRESULT is omitted.
             }
 
+            if (shouldReparseFunctions)
+            {
+                yieldFunctions->Clear();
+                BEGIN_TRANSLATE_OOM_TO_HRESULT_NESTED
+                {
+                    sourceInfo->MapFunction([&](Js::FunctionBody *const pFuncBody)
+                    {
+                        if (pFuncBody->IsCoroutine() && pFuncBody->GetYieldRegister() != Js::Constants::NoRegister)
+                        {
+                            yieldFunctions->Add(pFuncBody->StartInDocument(), pFuncBody->GetYieldRegister());
+                        }
+                    });
+                }
+                END_TRANSLATE_OOM_TO_HRESULT(hr);
+                DEBUGGER_ATTACHDETACH_FATAL_ERROR_IF_FAILED(hr);
+            }
+
             bool fHasDoneSourceRundown = false;
             for (int i = 0; i < pFunctionsToRegister->Count(); i++)
             {
@@ -326,8 +349,17 @@ namespace Js
 
             if (shouldReparseFunctions)
             {
-                sourceInfo->MapFunction([](Js::FunctionBody *const pFuncBody)
+                sourceInfo->MapFunction([&](Js::FunctionBody *const pFuncBody)
                 {
+                    if (pFuncBody->IsCoroutine())
+                    {
+                        RegSlot oldYieldRegister = Constants::NoRegister;
+                        if (yieldFunctions->TryGetValue(pFuncBody->StartInDocument(), &oldYieldRegister))
+                        {
+                            AssertOrFailFast(pFuncBody->GetYieldRegister() == oldYieldRegister);
+                        }
+                    }
+
                     if (pFuncBody->IsFunctionParsed())
                     {
                         pFuncBody->ReinitializeExecutionModeAndLimits();

From b5f8fad1b00087bd0a24cc173c2dfedc4f8aee33 Mon Sep 17 00:00:00 2001
From: Paul Leathers <pleath@microsoft.com>
Date: Wed, 17 Apr 2019 15:22:11 -0700
Subject: [PATCH 10/13] [CVE-2019-0917]

---
 lib/Backend/IRBuilder.cpp          | 4 ++--
 lib/Runtime/Language/ValueType.cpp | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/Backend/IRBuilder.cpp b/lib/Backend/IRBuilder.cpp
index bef540413ba..75ee5c7f245 100644
--- a/lib/Backend/IRBuilder.cpp
+++ b/lib/Backend/IRBuilder.cpp
@@ -1758,7 +1758,7 @@ IRBuilder::BuildReg1(Js::OpCode newOpcode, uint32 offset, Js::RegSlot R0)
         }
 
     case Js::OpCode::NewScObjectSimple:
-        dstValueType = ValueType::GetObject(ObjectType::Object);
+        dstValueType = ValueType::GetObject(ObjectType::UninitializedObject);
         // fall-through
     case Js::OpCode::LdFuncExpr:
         m_func->DisableCanDoInlineArgOpt();
@@ -5050,7 +5050,7 @@ IRBuilder::BuildAuxiliary(Js::OpCode newOpcode, uint32 offset)
             // lower take it from there...
             srcOpnd = IR::IntConstOpnd::New(auxInsn->Offset, TyUint32, m_func);
             dstOpnd = this->BuildDstOpnd(dstRegSlot);
-            dstOpnd->SetValueType(ValueType::GetObject(ObjectType::Object));
+            dstOpnd->SetValueType(ValueType::GetObject(ObjectType::UninitializedObject));
             instr = IR::Instr::New(newOpcode, dstOpnd, srcOpnd, m_func);
 
             // Because we're going to be making decisions based off the value, we have to defer
diff --git a/lib/Runtime/Language/ValueType.cpp b/lib/Runtime/Language/ValueType.cpp
index fb264cbe1e6..b86b7963f34 100644
--- a/lib/Runtime/Language/ValueType.cpp
+++ b/lib/Runtime/Language/ValueType.cpp
@@ -577,7 +577,8 @@ bool ValueType::IsNotArrayOrObjectWithArray() const
 {
     return
         IsNotObject() ||
-        (IsObject() && GetObjectType() != ObjectType::ObjectWithArray && GetObjectType() != ObjectType::Array);
+        (IsObject() && GetObjectType() != ObjectType::ObjectWithArray && GetObjectType() != ObjectType::Array
+         && GetObjectType() != ObjectType::UninitializedObject && GetObjectType() != ObjectType::Object);
 }
 
 bool ValueType::IsNativeArray() const

From 7827e117753052d479fabe19a25cfece88059bca Mon Sep 17 00:00:00 2001
From: Paul Leathers <pleath@microsoft.com>
Date: Wed, 17 Apr 2019 15:42:35 -0700
Subject: [PATCH 11/13] [CVE-2019-0937]

---
 lib/Runtime/ByteCode/ByteCodeEmitter.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
index 5c07982b92b..933a21d385d 100644
--- a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
+++ b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
@@ -4006,6 +4006,11 @@ void ByteCodeGenerator::StartEmitCatch(ParseNodeCatch *pnodeCatch)
                 sym->SetIsGlobalCatch(true);
             }
 
+            if (sym->NeedsScopeObject())
+            {
+                scope->SetIsObject();
+            }
+
             Assert(sym->GetScopeSlot() == Js::Constants::NoProperty);
             if (sym->NeedsSlotAlloc(this, funcInfo))
             {
@@ -4029,6 +4034,11 @@ void ByteCodeGenerator::StartEmitCatch(ParseNodeCatch *pnodeCatch)
             sym->SetIsGlobalCatch(true);
         }
 
+        if (sym->NeedsScopeObject())
+        {
+            scope->SetIsObject();
+        }
+
         if (scope->GetMustInstantiate())
         {
             if (sym->IsInSlot(this, funcInfo))

From 00ff32cb3524f66d9f502d36af7d931544969a33 Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Thu, 25 Apr 2019 11:30:34 -0700
Subject: [PATCH 12/13] update chakracore version to 1.11.9

---
 Build/NuGet/.pack-version      | 2 +-
 lib/Common/ChakraCoreVersion.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Build/NuGet/.pack-version b/Build/NuGet/.pack-version
index 40faed9aa40..361ffc5b4d8 100644
--- a/Build/NuGet/.pack-version
+++ b/Build/NuGet/.pack-version
@@ -1 +1 @@
-1.11.8
+1.11.9
diff --git a/lib/Common/ChakraCoreVersion.h b/lib/Common/ChakraCoreVersion.h
index 0ade5e496a3..b7144c0f96d 100644
--- a/lib/Common/ChakraCoreVersion.h
+++ b/lib/Common/ChakraCoreVersion.h
@@ -17,7 +17,7 @@
 // ChakraCore version number definitions (used in ChakraCore binary metadata)
 #define CHAKRA_CORE_MAJOR_VERSION 1
 #define CHAKRA_CORE_MINOR_VERSION 11
-#define CHAKRA_CORE_PATCH_VERSION 8
+#define CHAKRA_CORE_PATCH_VERSION 9
 #define CHAKRA_CORE_VERSION_RELEASE_QFE 0 // Redundant with PATCH_VERSION. Keep this value set to 0.
 
 // -------------

From 4594e340bc9ca9f857010a68e8b562d65b46eed6 Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Tue, 14 May 2019 11:52:45 -0700
Subject: [PATCH 13/13] fix UT failure

---
 lib/Backend/GlobOptArrays.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Backend/GlobOptArrays.cpp b/lib/Backend/GlobOptArrays.cpp
index 9ac28c59c12..4b88ed9a808 100644
--- a/lib/Backend/GlobOptArrays.cpp
+++ b/lib/Backend/GlobOptArrays.cpp
@@ -1740,7 +1740,7 @@ void GlobOpt::ArraySrcOpt::Optimize()
             {
                 UpdateValue(nullptr, nullptr, nullptr);
             }
-            else if (globOpt->IsOperationThatLikelyKillsJsArraysWithNoMissingValues(instr) && baseValueInfo->HasNoMissingValues())
+            else if (isLikelyJsArray && globOpt->IsOperationThatLikelyKillsJsArraysWithNoMissingValues(instr) && baseValueInfo->HasNoMissingValues())
             {
                 globOpt->ChangeValueType(nullptr, baseValue, baseValueInfo->Type().SetHasNoMissingValues(false), true);
             }",
"url": "https://github.com/chakra-core/ChakraCore/commit/d797e3f00e34c12c8c0ae52f56344325439dccd7.patch"
}
] | null |
CVE-2015-10127
|
PlusCaptcha Plugin cross site scripting
|
A vulnerability was found in PlusCaptcha Plugin up to 2.0.6 on WordPress and classified as problematic. Affected by this issue is some unknown functionality. The manipulation leads to cross site scripting. The attack may be launched remotely. Upgrading to version 2.0.14 is able to address this issue. The patch is identified as 1274afc635170daafd38306487b6bb8a01f78ecd. It is recommended to upgrade the affected component. VDB-248954 is the identifier assigned to this vulnerability.
|
[
{
"commit_message": "[PATCH] Solver XSS git-svn-id: https://plugins.svn.wordpress.org/pluscaptcha/trunk@1094241 b8457f37-d9ea-0310-8a92-e5e31aec5664 PlusCaptcha.php | 14 +++- external/comment-form-inline-errors.php | 4 +- library/admin.php | 90 +++++++++++++------------ library/public.php | 20 ++++-- library/shortcode-and-others.php | 74 ++++++++++---------- readme.txt | 8 ++- template/admin-options-contactform.php | 2 +- template/admin-options.php | 14 +++- template/admin-register.php | 15 +++++ 9 files changed, 151 insertions(+), 90 deletions(-)",
"patch_text_b64": "From 1274afc635170daafd38306487b6bb8a01f78ecd Mon Sep 17 00:00:00 2001
From: PlusCaptcha <PlusCaptcha@b8457f37-d9ea-0310-8a92-e5e31aec5664>
Date: Thu, 19 Feb 2015 12:22:01 +0000
Subject: [PATCH] Solver XSS

git-svn-id: https://plugins.svn.wordpress.org/pluscaptcha/trunk@1094241 b8457f37-d9ea-0310-8a92-e5e31aec5664
---
 PlusCaptcha.php                         | 14 +++-
 external/comment-form-inline-errors.php |  4 +-
 library/admin.php                       | 90 +++++++++++++------------
 library/public.php                      | 20 ++++--
 library/shortcode-and-others.php        | 74 ++++++++++----------
 readme.txt                              |  8 ++-
 template/admin-options-contactform.php  |  2 +-
 template/admin-options.php              | 14 +++-
 template/admin-register.php             | 15 +++++
 9 files changed, 151 insertions(+), 90 deletions(-)

diff --git a/PlusCaptcha.php b/PlusCaptcha.php
index a62698f..7cbe660 100644
--- a/PlusCaptcha.php
+++ b/PlusCaptcha.php
@@ -3,7 +3,7 @@
 Plugin Name: PlusCaptcha
 Plugin URI: http://www.pluscaptcha.com/
 Description: The Easiest Captcha to Setup and Execute, with Auto-Setup Feature! Forget ugly and complicated captchas! Unique! <strong>TRUSTED BY +27 THOUSAND OF WEBSITES, BLOGS, E-COMMERCE AND GOVERNMENT SITES AROUND WORLD WIDE!</strong> Free Full Service with <strong>24/7 emergency support</strong> ( <a href="mailto:emergency@pluscaptcha.com">emergency@pluscaptcha.com</a> ) plus, with continuously updates and support! Questions? <a href="http://www.pluscaptcha.com/contacto">contact us!</a>
-Version: 2.0.6
+Version: 2.0.14
 Author: PlusCaptcha
 Author URI: http://www.pluscaptcha.com/
 License: GNU GPL2
@@ -29,6 +29,18 @@
 		- Denis, CEO PlusCaptcha
 */
 
+if (!function_exists('tags')) {
+	# Clean
+	# Limpiar data
+	function tags($tags){  
+		$tags = strip_tags($tags);  
+		$tags = stripslashes($tags);  
+		$tags = htmlentities($tags);
+		$tags = addslashes($tags);
+		return trim($tags);  
+	}
+}
+
 /* Ocultar errores */
 require_once(ABSPATH . 'wp-settings.php');
 error_reporting(0);
diff --git a/external/comment-form-inline-errors.php b/external/comment-form-inline-errors.php
index 0281798..2ac2ba6 100644
--- a/external/comment-form-inline-errors.php
+++ b/external/comment-form-inline-errors.php
@@ -47,7 +47,7 @@ function getWpDieHandler($handler){ return array($this, 'handleWpError'); }
 
         function handleWpError($message, $title='', $args=array())
         {
-            if(!is_admin() && !empty($_POST['comment_post_ID']) && is_numeric($_POST['comment_post_ID'])){
+            if(!is_admin() && tags(!empty($_POST['comment_post_ID'])) && tags(is_numeric($_POST['comment_post_ID']))){
                 $_SESSION['formError'] = $message;
                 $denied = array('submit', 'comment_post_ID', 'comment_parent');
                 foreach($_POST as $key => $value){
@@ -56,7 +56,7 @@ function handleWpError($message, $title='', $args=array())
                     }
                 }
                 session_write_close();
-                wp_safe_redirect(get_permalink($_POST['comment_post_ID']) . '#formError', 302);
+                wp_safe_redirect(get_permalink(tags($_POST['comment_post_ID'])) . '#formError', 302);
                 exit;
             } else {
                 _default_wp_die_handler($message, $title, $args);
diff --git a/library/admin.php b/library/admin.php
index 54f9b09..fdeb7cd 100644
--- a/library/admin.php
+++ b/library/admin.php
@@ -1,14 +1,16 @@
 <?php
 
-# Clean
-# Limpiar data
-function tags($tags){  
-	$tags = strip_tags($tags);  
-	$tags = stripslashes($tags);  
-	$tags = htmlentities($tags);
-	$tags = addslashes($tags);
-	return trim($tags);  
-} 
+if (!function_exists('tags')) {
+	# Clean
+	# Limpiar data
+	function tags($tags){  
+		$tags = strip_tags($tags);  
+		$tags = stripslashes($tags);  
+		$tags = htmlentities($tags);
+		$tags = addslashes($tags);
+		return trim($tags);  
+	}
+}
 
 tags($_REQUEST);
 tags($_POST);
@@ -108,7 +110,7 @@ function PlusCaptcha_register_form() {
   //var_export($_POST);
   // See if the user has posted us some information
   // If they did, this hidden field will be set to 'Y'
-  if ((isset($_POST[$hidden_field_name])) && ($_POST[$hidden_field_name] == 'Y')) {
+  if ((tags(isset($_POST[$hidden_field_name]))) && (tags($_POST[$hidden_field_name]) == 'Y')) {
     $result = json_decode(submit_register_form($_POST), true);
     if ($result['error']) {
       if (!empty($result['html'])) {
@@ -116,7 +118,7 @@ function PlusCaptcha_register_form() {
       }
     } else {
       update_option('uuid_key_speci_to_generate_captchas', $result['app_id']);
-	  update_option('PlusCaptcha_feedback_quemejoraria', $_POST["PlusCaptcha_feedback_quemejoraria"]);
+	  update_option('PlusCaptcha_feedback_quemejoraria', tags($_POST["PlusCaptcha_feedback_quemejoraria"]));
       //update_option('PlusCaptcha_key', $result['key']);
       //update_option('PlusCaptcha_secret', $result['secret']);
 
@@ -136,8 +138,8 @@ function PlusCaptcha_register_form() {
 	$form_html = "NONE";
   }
   // Fill Register Form fields
-  $website = json_encode(empty($_POST['website']) ? "http://{$_SERVER['SERVER_NAME']}/" : $_POST['website']);
-  $email = json_encode($_POST['email']);
+  $website = json_encode(tags(empty($_POST['website'])) ? "http://{".tags($_SERVER['SERVER_NAME'])."}/" : tags($_POST['website']));
+  $email = json_encode(tags($_POST['email']));
   
   //jQuery('<div><input type="text" class="field" name="dynamic[]" value="' + i + '" /></div>').fadeIn('slow').appendTo('.inputs');
   $form_html .= "<script type=\"text/javascript\" language=\"javascript\">\n";
@@ -148,20 +150,20 @@ function PlusCaptcha_register_form() {
   $form_html .= "    jQuery('input[name=website]').val($website);\n";
   $form_html .= "    jQuery('input[name=email]').val($email);\n";
 
-  if (isset($_POST['language'])) {
-    $language = (int) $_POST['language'];
+  if (tags(isset($_POST['language']))) {
+    $language = (int) tags($_POST['language']);
     $form_html .= "    jQuery('select[name=language]').val($language);\n";
   }
-  if (isset($_POST['category'])) {
-    $category = (int) $_POST['category'];
+  if (tags(isset($_POST['category']))) {
+    $category = (int) tags($_POST['category']);
     $form_html .= "    jQuery('select[name=category]').val($category);\n";
   }
-  if (isset($_POST['site_category'])) {
-    $site_category = (int) $_POST['site_category'];
+  if (tags(isset($_POST['site_category']))) {
+    $site_category = (int) tags($_POST['site_category']);
     $form_html .= "    jQuery('select[name=site_category]').val($site_category);\n";
   }
-  if (isset($_POST['gender'])) {
-    $gender = (int) $_POST['gender'];
+  if (tags(isset($_POST['gender']))) {
+    $gender = (int) tags($_POST['gender']);
     $form_html .= "    jQuery('select[name=gender]').val($gender);\n";
   }
   $form_html .= "</script>\n";
@@ -209,12 +211,12 @@ function sweetcatpcha_main_settings($ignore_post = false) {
 
   // See if the user has posted us some information
   // If they did, this hidden field will be set to 'Y'
-  if ((!$ignore_post) && (isset($_POST[$hidden_field_name])) && ($_POST[$hidden_field_name] == 'Y')) {
+  if ((!$ignore_post) && (tags(isset($_POST[$hidden_field_name]))) && (tags($_POST[$hidden_field_name]) == 'Y')) {
     $rs = TRUE;
 
     // Read their posted value
     foreach ($PlusCaptcha_options as $opt_name => $v) {
-      $opt_val = isset($_POST[$opt_name]) ? $_POST[$opt_name] : null;
+      $opt_val = tags(isset($_POST[$opt_name])) ? tags($_POST[$opt_name]) : null;
 
       // Save the posted value in the database
       update_option($opt_name, $opt_val);
@@ -286,10 +288,10 @@ function plscptf_settings_save() {
   $userslogin = $wpdb->get_col("SELECT user_login FROM  $wpdb->users ", 0);
   $plscptf_options_submit = array();
   // Save data for settings page
-  $plscptf_options_submit['plscptf_user_email'] = $_REQUEST['plscptf_user_email'];
-  $plscptf_options_submit['plscptf_custom_email'] = $_REQUEST['plscptf_custom_email'];
-  $plscptf_options_submit['plscptf_select_email'] = $_REQUEST['plscptf_select_email'];
-  $plscptf_options_submit['plscptf_additions_options'] = isset($_REQUEST['plscptf_additions_options']) ? $_REQUEST['plscptf_additions_options'] : 0;
+  $plscptf_options_submit['plscptf_user_email'] = tags($_REQUEST['plscptf_user_email']);
+  $plscptf_options_submit['plscptf_custom_email'] = tags($_REQUEST['plscptf_custom_email']);
+  $plscptf_options_submit['plscptf_select_email'] = tags($_REQUEST['plscptf_select_email']);
+  $plscptf_options_submit['plscptf_additions_options'] = tags(isset($_REQUEST['plscptf_additions_options'])) ? tags($_REQUEST['plscptf_additions_options']) : 0;
   if ($plscptf_options_submit['plscptf_additions_options'] == 0) {
     $plscptf_options_submit['plscptf_send_copy'] = 0;
     $plscptf_options_submit['plscptf_from_field'] = get_bloginfo('name');
@@ -308,16 +310,16 @@ function plscptf_settings_save() {
     $plscptf_options_submit['plscptf_thank_text'] = __("Thank you for contacting us.", 'PlusCaptcha');
     $plscptf_options_submit['plscptf_redirect_url'] = '';
   } else {
-    $plscptf_options_submit['plscptf_send_copy'] = isset($_REQUEST['plscptf_send_copy']) ? $_REQUEST['plscptf_send_copy'] : 0;
-    $plscptf_options_submit['plscptf_mail_method'] = $_REQUEST['plscptf_mail_method'];
-    $plscptf_options_submit['plscptf_from_field'] = $_REQUEST['plscptf_from_field'];
-    $plscptf_options_submit['plscptf_display_add_info'] = isset($_REQUEST['plscptf_display_add_info']) ? 1 : 0;
-    $plscptf_options_submit['plscptf_change_label'] = isset($_REQUEST['plscptf_change_label']) ? 1 : 0;
+    $plscptf_options_submit['plscptf_send_copy'] = tags(isset($_REQUEST['plscptf_send_copy'])) ? tags($_REQUEST['plscptf_send_copy']) : 0;
+    $plscptf_options_submit['plscptf_mail_method'] = tags($_REQUEST['plscptf_mail_method']);
+    $plscptf_options_submit['plscptf_from_field'] = tags($_REQUEST['plscptf_from_field']);
+    $plscptf_options_submit['plscptf_display_add_info'] = tags(isset($_REQUEST['plscptf_display_add_info'])) ? 1 : 0;
+    $plscptf_options_submit['plscptf_change_label'] = tags(isset($_REQUEST['plscptf_change_label'])) ? 1 : 0;
     if ($plscptf_options_submit['plscptf_display_add_info'] == 1) {
-      $plscptf_options_submit['plscptf_display_sent_from'] = isset($_REQUEST['plscptf_display_sent_from']) ? 1 : 0;
-      $plscptf_options_submit['plscptf_display_date_time'] = isset($_REQUEST['plscptf_display_date_time']) ? 1 : 0;
-      $plscptf_options_submit['plscptf_display_coming_from'] = isset($_REQUEST['plscptf_display_coming_from']) ? 1 : 0;
-      $plscptf_options_submit['plscptf_display_user_agent'] = isset($_REQUEST['plscptf_display_user_agent']) ? 1 : 0;
+      $plscptf_options_submit['plscptf_display_sent_from'] = tags(isset($_REQUEST['plscptf_display_sent_from'])) ? 1 : 0;
+      $plscptf_options_submit['plscptf_display_date_time'] = tags(isset($_REQUEST['plscptf_display_date_time'])) ? 1 : 0;
+      $plscptf_options_submit['plscptf_display_coming_from'] = tags(isset($_REQUEST['plscptf_display_coming_from'])) ? 1 : 0;
+      $plscptf_options_submit['plscptf_display_user_agent'] = tags(isset($_REQUEST['plscptf_display_user_agent'])) ? 1 : 0;
     } else {
       $plscptf_options_submit['plscptf_display_sent_from'] = 1;
       $plscptf_options_submit['plscptf_display_date_time'] = 1;
@@ -325,19 +327,19 @@ function plscptf_settings_save() {
       $plscptf_options_submit['plscptf_display_user_agent'] = 1;
     }
     if ($plscptf_options_submit['plscptf_change_label'] == 1) {
-      $plscptf_options_submit['plscptf_name_label'] = isset($_REQUEST['plscptf_name_label']) ? $_REQUEST['plscptf_name_label'] : $plscptf_options_submit['plscptf_name_label'];
-      $plscptf_options_submit['plscptf_email_label'] = isset($_REQUEST['plscptf_email_label']) ? $_REQUEST['plscptf_email_label'] : $plscptf_options_submit['plscptf_email_label'];
-      $plscptf_options_submit['plscptf_subject_label'] = isset($_REQUEST['plscptf_subject_label']) ? $_REQUEST['plscptf_subject_label'] : $plscptf_options_submit['plscptf_subject_label'];
-      $plscptf_options_submit['plscptf_message_label'] = isset($_REQUEST['plscptf_message_label']) ? $_REQUEST['plscptf_message_label'] : $plscptf_options_submit['plscptf_message_label'];
+      $plscptf_options_submit['plscptf_name_label'] = tags(isset($_REQUEST['plscptf_name_label'])) ? tags($_REQUEST['plscptf_name_label']) : $plscptf_options_submit['plscptf_name_label'];
+      $plscptf_options_submit['plscptf_email_label'] = tags(isset($_REQUEST['plscptf_email_label'])) ? tags($_REQUEST['plscptf_email_label']) : $plscptf_options_submit['plscptf_email_label'];
+      $plscptf_options_submit['plscptf_subject_label'] = tags(isset($_REQUEST['plscptf_subject_label'])) ? tags($_REQUEST['plscptf_subject_label']) : $plscptf_options_submit['plscptf_subject_label'];
+      $plscptf_options_submit['plscptf_message_label'] = tags(isset($_REQUEST['plscptf_message_label'])) ? tags($_REQUEST['plscptf_message_label']) : $plscptf_options_submit['plscptf_message_label'];
     } else {
       $plscptf_options_submit['plscptf_name_label'] = __("Name:", 'PlusCaptcha');
       $plscptf_options_submit['plscptf_email_label'] = __("E-Mail Address:", 'PlusCaptcha');
       $plscptf_options_submit['plscptf_subject_label'] = __("Subject:", 'PlusCaptcha');
       $plscptf_options_submit['plscptf_message_label'] = __("Message:", 'PlusCaptcha');
     }
-    $plscptf_options_submit['plscptf_action_after_send'] = $_REQUEST['plscptf_action_after_send'];
-    $plscptf_options_submit['plscptf_thank_text'] = $_REQUEST['plscptf_thank_text'];
-    $plscptf_options_submit['plscptf_redirect_url'] = $_REQUEST['plscptf_redirect_url'];
+    $plscptf_options_submit['plscptf_action_after_send'] = tags($_REQUEST['plscptf_action_after_send']);
+    $plscptf_options_submit['plscptf_thank_text'] = tags($_REQUEST['plscptf_thank_text']);
+    $plscptf_options_submit['plscptf_redirect_url'] = tags($_REQUEST['plscptf_redirect_url']);
   }
   $plscptf_options = array_merge($plscptf_options, $plscptf_options_submit);
   if ($plscptf_options_submit['plscptf_action_after_send'] == 0
@@ -357,7 +359,7 @@ function plscptf_settings_save() {
       $error .=__("Such user does not exist. Settings not saved.", 'PlusCaptcha');
     }
   } else {
-    if ( isset($_REQUEST['PlusCaptcha_form_contact']) ) {
+    if ( tags(isset($_REQUEST['PlusCaptcha_form_contact'])) ) {
       if ($plscptf_options_submit['plscptf_custom_email'] != "" && preg_match("/^((?:[a-z0-9]+(?:[a-z0-9\-_\.]+)?@[a-z0-9]+(?:[a-z0-9\-\.]+)?\.[a-z]{2,5})[, ]*)+$/i", trim($plscptf_options_submit['plscptf_custom_email']))) {
         update_option('PlusCaptcha_form_contact_options', $plscptf_options, '', 'yes');
       $message = __("Options saved.", 'PlusCaptcha');
diff --git a/library/public.php b/library/public.php
index 9e185e0..bb5ad14 100644
--- a/library/public.php
+++ b/library/public.php
@@ -1,13 +1,25 @@
 <?php
 
+if (!function_exists('tags')) {
+	# Clean
+	# Limpiar data
+	function tags($tags){  
+		$tags = strip_tags($tags);  
+		$tags = stripslashes($tags);  
+		$tags = htmlentities($tags);
+		$tags = addslashes($tags);
+		return trim($tags);  
+	}
+}
+
 /**
  * Get PlusCaptcha values from POST data
  * @return array
  */
 function PlusCaptcha_get_values() {
 	return array(
-		'sckey'		=> ( isset( $_POST[ 'sckey' ] ) ? $_POST[ 'sckey' ] : '' ),
-		'scvalue'	=> ( isset( $_POST[ 'scvalue' ] ) ? $_POST[ 'scvalue' ] : '' )
+		'sckey'		=> ( tags( isset( $_POST[ 'sckey' ]) ) ? tags($_POST[ 'sckey' ]) : '' ),
+		'scvalue'	=> ( tags( isset( $_POST[ 'scvalue' ]) ) ? tags($_POST[ 'scvalue' ]) : '' )
 	);
 }
 
@@ -260,7 +272,7 @@ function PlusCaptcha_registration_form() {
 function PlusCaptcha_authenticate($user) {
 	global $PlusCaptcha_instance;
 	//$scValues = PlusCaptcha_get_values();
-	if ( !empty( $_POST ) && get_result(simpleSessionGet("contacto", "")) == false ) {
+	if (  tags( !empty( $_POST ) ) && get_result(simpleSessionGet("contacto", "")) == false ) {
 		$user = new WP_Error( 'captcha_wrong', '<strong>' . __( 'ERROR', 'PlusCaptcha' ) . '</strong>: ' . __( PlusCaptcha_ERROR_MESSAGE, 'PlusCaptcha' ) );
 	}else{
 		//$_SESSION["passport"] = false;
@@ -353,7 +365,7 @@ function PlusCaptcha_signup_extra_fields($errors) {
  */
 function PlusCaptcha_wpmu_validate_user_signup($errors) {
 	global $PlusCaptcha_instance;
-	if ( $_POST['stage'] == 'validate-user-signup' ) {
+	if ( tags($_POST['stage']) == 'validate-user-signup' ) {
 		//$scValues = PlusCaptcha_get_values();
 		if ( get_result(simpleSessionGet("contacto", "")) == false ) {
 			$errors['errors']->add( 'captcha_wrong', '<strong>' . __( 'ERROR', 'PlusCaptcha' ) . '</strong>: ' . __(PlusCaptcha_ERROR_MESSAGE, 'PlusCaptcha' ) );
diff --git a/library/shortcode-and-others.php b/library/shortcode-and-others.php
index 793bb02..43f8482 100644
--- a/library/shortcode-and-others.php
+++ b/library/shortcode-and-others.php
@@ -1,14 +1,16 @@
 <?php
 
-# Clean
-# Limpiar data
-function tags($tags){  
-	$tags = strip_tags($tags);  
-	$tags = stripslashes($tags);  
-	$tags = htmlentities($tags);
-	$tags = addslashes($tags);
-	return trim($tags);  
-} 
+if (!function_exists('tags')) {
+	# Clean
+	# Limpiar data
+	function tags($tags){  
+		$tags = strip_tags($tags);  
+		$tags = stripslashes($tags);  
+		$tags = htmlentities($tags);
+		$tags = addslashes($tags);
+		return trim($tags);  
+	}
+}
 
 tags($_REQUEST);
 tags($_POST);
@@ -22,13 +24,13 @@ function plscptf_display_form() {
     $plscptf_options = get_option('PlusCaptcha_form_contact_options');
     $content = "";
 
-    $page_url = ( isset($_SERVER["HTTPS"]) && $_SERVER["HTTPS"] == "on" ? "https://" : "http://" ) . $_SERVER["SERVER_NAME"] . $_SERVER["REQUEST_URI"];
+    $page_url = ( tags(isset($_SERVER["HTTPS"])) && tags($_SERVER["HTTPS"]) == "on" ? "https://" : "http://" ) . tags($_SERVER["SERVER_NAME"]) . tags($_SERVER["REQUEST_URI"]);
     // If contact form submited
-    $name = isset($_REQUEST['plscptf_contact_name']) ? $_REQUEST['plscptf_contact_name'] : "";
-    $email = isset($_REQUEST['plscptf_contact_email']) ? $_REQUEST['plscptf_contact_email'] : "";
-    $subject = isset($_REQUEST['plscptf_contact_subject']) ? $_REQUEST['plscptf_contact_subject'] : "";
-    $message = isset($_REQUEST['plscptf_contact_message']) ? $_REQUEST['plscptf_contact_message'] : "";
-    $send_copy = isset($_REQUEST['plscptf_contact_send_copy']) ? $_REQUEST['plscptf_contact_send_copy'] : "";
+    $name = tags(isset($_REQUEST['plscptf_contact_name'])) ? tags($_REQUEST['plscptf_contact_name']) : "";
+    $email = tags(isset($_REQUEST['plscptf_contact_email'])) ? tags($_REQUEST['plscptf_contact_email']) : "";
+    $subject = tags(isset($_REQUEST['plscptf_contact_subject'])) ? tags($_REQUEST['plscptf_contact_subject']) : "";
+    $message = tags(isset($_REQUEST['plscptf_contact_message'])) ? tags($_REQUEST['plscptf_contact_message']) : "";
+    $send_copy = tags(isset($_REQUEST['plscptf_contact_send_copy'])) ? tags($_REQUEST['plscptf_contact_send_copy']) : "";
     // If it is good
     if (true === $result) {
       $_SESSION['plscptf_send_mail'] = true;
@@ -116,7 +118,7 @@ function plscptf_check_and_send() {
     //die ('plscptf_check_and_send'); 
     global $result;
     $plscptf_options = get_option('PlusCaptcha_form_contact_options');
-    if (isset($_REQUEST['plscptf_contact_action'])) {
+    if (tags(isset($_REQUEST['plscptf_contact_action']))) {
       // Check all input data
       $result = plscptf_check_form();
     }
@@ -147,13 +149,13 @@ function plscptf_check_form() {
     $error_message['error_message'] = __("Message text required.", 'PlusCaptcha');
     $error_message['error_form'] = __("Please correct your input data below and try again.", 'PlusCaptcha');
     // Check information
-    if ("" != $_REQUEST['plscptf_contact_name'])
+    if ("" != tags($_REQUEST['plscptf_contact_name']))
       unset($error_message['error_name']);
-    if ("" != $_REQUEST['plscptf_contact_email'] && preg_match("/^(?:[a-z0-9]+(?:[a-z0-9\-_\.]+)?@[a-z0-9]+(?:[a-z0-9\-\.]+)?\.[a-z]{2,5})$/i", trim($_REQUEST['plscptf_contact_email'])))
+    if ("" != tags($_REQUEST['plscptf_contact_email']) && preg_match("/^(?:[a-z0-9]+(?:[a-z0-9\-_\.]+)?@[a-z0-9]+(?:[a-z0-9\-\.]+)?\.[a-z]{2,5})$/i", tags(trim($_REQUEST['plscptf_contact_email']))))
       unset($error_message['error_email']);
-    if ("" != $_REQUEST['plscptf_contact_subject'])
+    if ("" != tags($_REQUEST['plscptf_contact_subject']))
       unset($error_message['error_subject']);
-    if ("" != $_REQUEST['plscptf_contact_message'])
+    if ("" != tags($_REQUEST['plscptf_contact_message']))
       unset($error_message['error_message']);
     
     PlusCaptcha_validate_contact_form($error_message);
@@ -191,7 +193,7 @@ function plscptf_send_mail() {
     }
     if ("" != $to) {
       // subject
-      $subject = $_REQUEST['plscptf_contact_subject'];
+      $subject = tags($_REQUEST['plscptf_contact_subject']);
       $user_info_string = '';
       $userdomain = '';
       $form_action_url = '';
@@ -199,13 +201,13 @@ function plscptf_send_mail() {
       $headers = "";
 
       if (getenv('HTTPS') == 'on') {
-        $form_action_url = 'https://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
+        $form_action_url = 'https://' . tags($_SERVER['HTTP_HOST']) . tags($_SERVER['REQUEST_URI']);
       } else {
-        $form_action_url = 'http://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
+        $form_action_url = 'http://' . tags($_SERVER['HTTP_HOST']) . tags($_SERVER['REQUEST_URI']);
       }
 
       if ($plscptf_options['plscptf_display_add_info'] == 1) {
-        $userdomain = gethostbyaddr($_SERVER['REMOTE_ADDR']);
+        $userdomain = gethostbyaddr(tags($_SERVER['REMOTE_ADDR']));
         if ($plscptf_options['plscptf_display_add_info'] == 1 ||
                 $plscptf_options['plscptf_display_sent_from'] == 1 ||
                 $plscptf_options['plscptf_display_coming_from'] == 1 ||
@@ -216,7 +218,7 @@ function plscptf_send_mail() {
         }
         if ($plscptf_options['plscptf_display_sent_from'] == 1) {
           $user_info_string .= '<tr>
-							<td>' . __('Sent from (ip address)', 'PlusCaptcha') . ':</td><td>' . $_SERVER['REMOTE_ADDR'] . " ( " . $userdomain . " )" . '</td>
+							<td>' . __('Sent from (ip address)', 'PlusCaptcha') . ':</td><td>' . tags($_SERVER['REMOTE_ADDR']) . " ( " . $userdomain . " )" . '</td>
 						</tr>';
         }
         if ($plscptf_options['plscptf_display_date_time'] == 1) {
@@ -231,7 +233,7 @@ function plscptf_send_mail() {
         }
         if ($plscptf_options['plscptf_display_user_agent'] == 1) {
           $user_info_string .= '<tr>
-							<td>' . __('Using (user agent)', 'PlusCaptcha') . ':</td><td>' . plscptf_clean_input($_SERVER['HTTP_USER_AGENT']) . '</td>
+							<td>' . __('Using (user agent)', 'PlusCaptcha') . ':</td><td>' . plscptf_clean_input(tags($_SERVER['HTTP_USER_AGENT'])) . '</td>
 						</tr>';
         }
       }
@@ -244,16 +246,16 @@ function plscptf_send_mail() {
 			<body>
 				<table>
 					<tr>
-						<td width="160">' . __("Name", 'PlusCaptcha') . '</td><td>' . $_REQUEST['plscptf_contact_name'] . '</td>
+						<td width="160">' . __("Name", 'PlusCaptcha') . '</td><td>' . tags($_REQUEST['plscptf_contact_name']) . '</td>
 					</tr>
 					<tr>
-						<td>' . __("Email", 'PlusCaptcha') . '</td><td>' . $_REQUEST['plscptf_contact_email'] . '</td>
+						<td>' . __("Email", 'PlusCaptcha') . '</td><td>' . tags($_REQUEST['plscptf_contact_email']) . '</td>
 					</tr>
 					<tr>
-						<td>' . __("Subject", 'PlusCaptcha') . '</td><td>' . $_REQUEST['plscptf_contact_subject'] . '</td>
+						<td>' . __("Subject", 'PlusCaptcha') . '</td><td>' . tags($_REQUEST['plscptf_contact_subject']) . '</td>
 					</tr>
 					<tr>
-						<td>' . __("Message", 'PlusCaptcha') . '</td><td>' . $_REQUEST['plscptf_contact_message'] . '</td>
+						<td>' . __("Message", 'PlusCaptcha') . '</td><td>' . tags($_REQUEST['plscptf_contact_message']) . '</td>
 					</tr>
 					<tr>
 						<td>' . __("Site", 'PlusCaptcha') . '</td><td>' . get_bloginfo("url") . '</td>
@@ -272,9 +274,9 @@ function plscptf_send_mail() {
         $headers .= 'Content-type: text/html; charset=utf-8' . "\r\n";
 
         // Additional headers
-        $headers .= 'From: ' . $_REQUEST['plscptf_contact_email'] . "\r\n";
-        if (isset($_REQUEST['plscptf_contact_send_copy']) && $_REQUEST['plscptf_contact_send_copy'] == 1)
-          wp_mail($_REQUEST['plscptf_contact_email'], stripslashes($subject), stripslashes($message), $headers, $attachments);
+        $headers .= 'From: ' . tags($_REQUEST['plscptf_contact_email']) . "\r\n";
+        if (tags(isset($_REQUEST['plscptf_contact_send_copy'])) && tags($_REQUEST['plscptf_contact_send_copy']) == 1)
+          wp_mail(tags($_REQUEST['plscptf_contact_email']), stripslashes($subject), stripslashes($message), $headers, $attachments);
 
         // Mail it
         return wp_mail($to, stripslashes($subject), stripslashes($message), $headers, $attachments);
@@ -285,9 +287,9 @@ function plscptf_send_mail() {
         $headers .= 'Content-type: text/html; charset=utf-8' . "\r\n";
 
         // Additional headers
-        $headers .= 'From: ' . $_REQUEST['plscptf_contact_email'] . "\r\n";
-        if (isset($_REQUEST['plscptf_contact_send_copy']) && $_REQUEST['plscptf_contact_send_copy'] == 1)
-          @mail($_REQUEST['plscptf_contact_email'], stripslashes($subject), stripslashes($message), $headers);
+        $headers .= 'From: ' . tags($_REQUEST['plscptf_contact_email']) . "\r\n";
+        if (tags(isset($_REQUEST['plscptf_contact_send_copy'])) && tags($_REQUEST['plscptf_contact_send_copy']) == 1)
+          @mail(tags($_REQUEST['plscptf_contact_email']), stripslashes($subject), stripslashes($message), $headers);
 
         return @mail($to, stripslashes($subject), stripslashes($message), $headers);
       }
diff --git a/readme.txt b/readme.txt
index 9133e61..fbcfa63 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,6 +1,6 @@
 === PlusCaptcha ===
 Contributors: PlusCaptcha
-Version: 2.0.6
+Version: 2.0.14
 Tags: pluscaptcha, captcha, antispam, comment, catcha, registration, match captcha, lost password, login, spam, images captcha, capcha, captha, ecology, ecoplus, plus, buddypress, contact form 7, sweetcaptcha, text captcha, multilingual, register, admin, ajax, image, images, keycaptcha, plugin, post, akismet, wpmu, re captcha, recaptcha, wordpress captcha, picture captcha
 Requires at least: 3.0.0
 Tested up to: 4.0.0
@@ -133,6 +133,9 @@ At this point, **your account was created automatically (NEW FEATURE!) and you d
 
 == Changelog ==
 
+= 2.0.10 =
+* Cross-site scripting (XSS) loged user side fixed. Thanks to Carlo Pelliccioni @ Hacktive Security
+
 = 2.0.6 =
 * Fixed security things reported by security.szurek.pl, Thanks!
 
@@ -184,6 +187,9 @@ Credits: Mistakes reported to emergency@pluscaptcha.com (Thank to Claude @ Norwo
 
 == Upgrade Notice ==
 
+= 2.0.10 =
+* Cross-site scripting (XSS) loged user side fixed. Thanks to Carlo Pelliccioni @ Hacktive Security
+
 = 2.0.6 =
 * Fixed security things reported by security.szurek.pl, Thanks!
 
diff --git a/template/admin-options-contactform.php b/template/admin-options-contactform.php
index db70ebe..0556c58 100644
--- a/template/admin-options-contactform.php
+++ b/template/admin-options-contactform.php
@@ -1,5 +1,5 @@
 <!-- Additional options in admin PlusCaptcha Settings -->
-<?php 
+<?php
 global $error, $wpdb; 
 $userslogin = $wpdb->get_col("SELECT user_login FROM  $wpdb->users ", 0);
 ?>
diff --git a/template/admin-options.php b/template/admin-options.php
index 5f68a9b..744e78b 100644
--- a/template/admin-options.php
+++ b/template/admin-options.php
@@ -1,5 +1,17 @@
 <?php
 
+if (!function_exists('tags')) {
+	# Clean
+	# Limpiar data
+	function tags($tags){  
+		$tags = strip_tags($tags);  
+		$tags = stripslashes($tags);  
+		$tags = htmlentities($tags);
+		$tags = addslashes($tags);
+		return trim($tags);  
+	}
+}
+
 $status = @fgets(@fopen("http://www.pluscaptcha.com/status/", 'r'), 4096);
 
 /**
@@ -10,7 +22,7 @@
 {
 	// Enviar feedback
 	$url = 'http://www.pluscaptcha.com/api/wp_log/feedback?'
-		.'quemejorar='.substr(str_replace(".","[dot]",urlencode($_POST["PlusCaptcha_feedback_quemejoraria"])),0,299).
+		.'quemejorar='.substr(str_replace(".","[dot]",urlencode(tags($_POST["PlusCaptcha_feedback_quemejoraria"]))),0,299).
 		'&uuid='.get_option( 'uuid_api_wp_feedback' ).'';
 		@fgets(@fopen($url, 'r'), 4096);
 	// Guardar Feedback en forma local
diff --git a/template/admin-register.php b/template/admin-register.php
index 7e3f74f..195bc1c 100644
--- a/template/admin-register.php
+++ b/template/admin-register.php
@@ -1,3 +1,18 @@
+<?php
+
+if (!function_exists('tags')) {
+	# Clean
+	# Limpiar data
+	function tags($tags){  
+		$tags = strip_tags($tags);  
+		$tags = stripslashes($tags);  
+		$tags = htmlentities($tags);
+		$tags = addslashes($tags);
+		return trim($tags);  
+	}
+}
+
+?>
 <style type="text/css">
 #register_message {
 	margin-bottom: 10px;",
"url": "https://github.com/wp-plugins/pluscaptcha/commit/1274afc635170daafd38306487b6bb8a01f78ecd.patch"
}
] |
CWE-79 Cross Site Scripting
|
CVE-2015-4715
|
The fetch function in OAuth/Curl.php in Dropbox-PHP, as used in ownCloud Server before 6.0.8, 7.x before 7.0.6, and 8.x before 8.0.4 when an external Dropbox storage has been mounted, allows remote administrators of Dropbox.com to read arbitrary files via an @ (at sign) character in unspecified POST values.
|
[
{
"commit_message": "[PATCH] Revert custom patch that can cause problems apps/files_external/3rdparty/Dropbox/OAuth/Curl.php | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSBiZjBmMWE1MDkyNmE3NWEyNmE0MmEzZGE0ZDYyZTg0YTQ4OWVlNzdhIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBSZXNjaGtlIDxsdWthc0Bvd25jbG91ZC5jb20+CkRhdGU6IFR1ZSwgNyBBcHIgMjAxNSAxNToxMjoxMCArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIFJldmVydCBjdXN0b20gcGF0Y2ggdGhhdCBjYW4gY2F1c2UgcHJvYmxlbXMKCi0tLQogYXBwcy9maWxlc19leHRlcm5hbC8zcmRwYXJ0eS9Ecm9wYm94L09BdXRoL0N1cmwucGhwIHwgMTAgKysrKysrKystLQogMSBmaWxlIGNoYW5nZWQsIDggaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9hcHBzL2ZpbGVzX2V4dGVybmFsLzNyZHBhcnR5L0Ryb3Bib3gvT0F1dGgvQ3VybC5waHAgYi9hcHBzL2ZpbGVzX2V4dGVybmFsLzNyZHBhcnR5L0Ryb3Bib3gvT0F1dGgvQ3VybC5waHAKaW5kZXggYjc1YjI3YmIzNjM3Li5jZmEzM2VkMGUxYWYgMTAwNjQ0Ci0tLSBhL2FwcHMvZmlsZXNfZXh0ZXJuYWwvM3JkcGFydHkvRHJvcGJveC9PQXV0aC9DdXJsLnBocAorKysgYi9hcHBzL2ZpbGVzX2V4dGVybmFsLzNyZHBhcnR5L0Ryb3Bib3gvT0F1dGgvQ3VybC5waHAKQEAgLTcyLDggKzcyLDE0IEBAIHB1YmxpYyBmdW5jdGlvbiBmZXRjaCgkdXJpLCAkYXJndW1lbnRzID0gYXJyYXkoKSwgJG1ldGhvZCA9ICdHRVQnLCAkaHR0cEhlYWRlcnMKIAkJaWYgKHN0cnRvdXBwZXIoJG1ldGhvZCkgPT0gJ1BPU1QnKSB7CiAJCQljdXJsX3NldG9wdCgkY2gsIENVUkxPUFRfVVJMLCAkdXJpKTsKIAkJCWN1cmxfc2V0b3B0KCRjaCwgQ1VSTE9QVF9QT1NULCB0cnVlKTsKLS8vIAkJCWlmIChpc19hcnJheSgkYXJndW1lbnRzKSkKLS8vIAkJCQkkYXJndW1lbnRzPWh0dHBfYnVpbGRfcXVlcnkoJGFyZ3VtZW50cyk7CisKKyAJCQkvL2lmIChpc19hcnJheSgkYXJndW1lbnRzKSkKKyAJCQkvLwkkYXJndW1lbnRzPWh0dHBfYnVpbGRfcXVlcnkoJGFyZ3VtZW50cyk7CisgCQkJZm9yZWFjaCAoJGFyZ3VtZW50cyBhcyAka2V5ID0+ICR2YWx1ZSkgeworIAkJCQlpZigkdmFsdWVbMF0gPT09ICdAJykgeworCQkJCQlleGl0KCk7CisJCQkJfQorCQkJfQogCQkJY3VybF9zZXRvcHQoJGNoLCBDVVJMT1BUX1BPU1RGSUVMRFMsICRhcmd1bWVudHMpOwogLy8gCQkJJGh0dHBIZWFkZXJzWydDb250ZW50LUxlbmd0aCddPXN0cmxlbigkYXJndW1lbnRzKTsKIAkJfSBlbHNlIHs=",
"url": "https://github.com/owncloud/core/commit/bf0f1a50926a75a26a42a3da4d62e84a489ee77a.patch"
}
] |
n/a
|
|
GHSA-5w4j-f78p-4wh9
|
Libcontainer is affected by capabilities elevation similar to GHSA-f3fp-gc8g-vw66
| null |
[
{
"commit_message": "[PATCH] Merge commit from fork * fix the way we set capapbilities on tenant container Signed-off-by: Yashodhan Joshi <[email protected]> * add tests and extract a function Signed-off-by: Yashodhan Joshi <[email protected]> * fix: format and typo fix Signed-off-by: Yashodhan Joshi <[email protected]> Signed-off-by: Yashodhan Joshi <[email protected]> .../src/container/tenant_builder.rs | 309 +++++++++++++----- 1 file changed, 231 insertions(+), 78 deletions(-)",
"patch_text_b64": "From 747e342d2026fbf3a395db3e2a491ebef00082f1 Mon Sep 17 00:00:00 2001
From: Yashodhan <54112038+YJDoc2@users.noreply.github.com>
Date: Fri, 21 Mar 2025 17:43:41 +0530
Subject: [PATCH] Merge commit from fork

* fix the way we set capapbilities on tenant container

Signed-off-by: Yashodhan Joshi <yjdoc2@gmail.com>

* add tests and extract a function

Signed-off-by: Yashodhan Joshi <yjdoc2@gmail.com>

* fix: format and typo fix

Signed-off-by: Yashodhan Joshi <yjdoc2@gmail.com>

---------

Signed-off-by: Yashodhan Joshi <yjdoc2@gmail.com>
---
 .../src/container/tenant_builder.rs           | 309 +++++++++++++-----
 1 file changed, 231 insertions(+), 78 deletions(-)

diff --git a/crates/libcontainer/src/container/tenant_builder.rs b/crates/libcontainer/src/container/tenant_builder.rs
index 845c1af3d0..7413f1312a 100644
--- a/crates/libcontainer/src/container/tenant_builder.rs
+++ b/crates/libcontainer/src/container/tenant_builder.rs
@@ -46,6 +46,81 @@ pub struct TenantContainerBuilder {
     as_sibling: bool,
 }
 
+/// This is a helper function to get capabilities for tenant container, based on
+/// additional capabilities provided by user and capabilities of existing container
+/// extracted into separate function for easier testing
+fn get_capabilities(
+    additional: &[String],
+    spec: &Spec,
+) -> Result<LinuxCapabilities, LibcontainerError> {
+    let mut caps: Vec<Capability> = Vec::with_capacity(additional.len());
+    for cap in additional {
+        caps.push(Capability::from_str(cap)?);
+    }
+    let caps: SpecCapabilities = caps.iter().map(|c| SpecCapability::from_cap(*c)).collect();
+
+    if let Some(spec_caps) = spec
+        .process()
+        .as_ref()
+        .ok_or(MissingSpecError::Process)?
+        .capabilities()
+    {
+        let mut capabilities_builder = LinuxCapabilitiesBuilder::default();
+
+        let bounding: SpecCapabilities = match spec_caps.bounding() {
+            Some(bounding) => bounding.union(&caps).copied().collect(),
+            None => SpecCapabilities::new().union(&caps).copied().collect(),
+        };
+        capabilities_builder = capabilities_builder.bounding(bounding);
+
+        let effective: SpecCapabilities = match spec_caps.effective() {
+            Some(effective) => effective.union(&caps).copied().collect(),
+            None => SpecCapabilities::new().union(&caps).copied().collect(),
+        };
+        capabilities_builder = capabilities_builder.effective(effective);
+
+        let permitted: SpecCapabilities = match spec_caps.permitted() {
+            Some(permitted) => permitted.union(&caps).copied().collect(),
+            None => SpecCapabilities::new().union(&caps).copied().collect(),
+        };
+        capabilities_builder = capabilities_builder.permitted(permitted);
+
+        // ambient capabilities are only useful when inherent capabilities
+        // are set. Hence we check and set accordingly. Inherent capabilities
+        // are never set from user as that can lead to vulnerability like
+        // https://github.com/advisories/GHSA-f3fp-gc8g-vw66
+        // Hence, we follow runc's code and set things similarly.
+        let caps = if let Some(inheritable) = spec_caps.inheritable() {
+            let ambient: SpecCapabilities = match spec_caps.ambient() {
+                Some(ambient) => ambient.union(&caps).copied().collect(),
+                None => SpecCapabilities::new().union(&caps).copied().collect(),
+            };
+            capabilities_builder = capabilities_builder.ambient(ambient);
+            capabilities_builder = capabilities_builder.inheritable(inheritable.clone());
+            capabilities_builder.build()?
+        } else {
+            let mut caps = capabilities_builder.build()?;
+            // oci-spec-rs sets these to some default caps, so we reset them here
+            caps.set_inheritable(None);
+            caps.set_ambient(None);
+            caps
+        };
+
+        return Ok(caps);
+    }
+
+    // If there are no caps in original container's spec,
+    // we simply set given caps , excluding the inherent and ambient
+    let mut caps = LinuxCapabilitiesBuilder::default()
+        .bounding(caps.clone())
+        .effective(caps.clone())
+        .permitted(caps.clone())
+        .build()?;
+    caps.set_inheritable(None);
+    caps.set_ambient(None);
+    Ok(caps)
+}
+
 impl TenantContainerBuilder {
     /// Generates the base configuration for a process that will join
     /// an existing container sandbox from which configuration methods
@@ -334,9 +409,8 @@ impl TenantContainerBuilder {
                 process_builder = process_builder.no_new_privileges(no_new_priv);
             }
 
-            if let Some(caps) = self.get_capabilities(spec)? {
-                process_builder = process_builder.capabilities(caps);
-            }
+            let capabilities = get_capabilities(&self.capabilities, spec)?;
+            process_builder = process_builder.capabilities(capabilities);
 
             process_builder.build()?
         };
@@ -405,81 +479,6 @@ impl TenantContainerBuilder {
         self.no_new_privs
     }
 
-    fn get_capabilities(
-        &self,
-        spec: &Spec,
-    ) -> Result<Option<LinuxCapabilities>, LibcontainerError> {
-        if !self.capabilities.is_empty() {
-            let mut caps: Vec<Capability> = Vec::with_capacity(self.capabilities.len());
-            for cap in &self.capabilities {
-                caps.push(Capability::from_str(cap)?);
-            }
-
-            let caps: SpecCapabilities =
-                caps.iter().map(|c| SpecCapability::from_cap(*c)).collect();
-
-            if let Some(spec_caps) = spec
-                .process()
-                .as_ref()
-                .ok_or(MissingSpecError::Process)?
-                .capabilities()
-            {
-                let mut capabilities_builder = LinuxCapabilitiesBuilder::default();
-                capabilities_builder = match spec_caps.ambient() {
-                    Some(ambient) => {
-                        let ambient: SpecCapabilities = ambient.union(&caps).copied().collect();
-                        capabilities_builder.ambient(ambient)
-                    }
-                    None => capabilities_builder,
-                };
-                capabilities_builder = match spec_caps.bounding() {
-                    Some(bounding) => {
-                        let bounding: SpecCapabilities = bounding.union(&caps).copied().collect();
-                        capabilities_builder.bounding(bounding)
-                    }
-                    None => capabilities_builder,
-                };
-                capabilities_builder = match spec_caps.effective() {
-                    Some(effective) => {
-                        let effective: SpecCapabilities = effective.union(&caps).copied().collect();
-                        capabilities_builder.effective(effective)
-                    }
-                    None => capabilities_builder,
-                };
-                capabilities_builder = match spec_caps.inheritable() {
-                    Some(inheritable) => {
-                        let inheritable: SpecCapabilities =
-                            inheritable.union(&caps).copied().collect();
-                        capabilities_builder.inheritable(inheritable)
-                    }
-                    None => capabilities_builder,
-                };
-                capabilities_builder = match spec_caps.permitted() {
-                    Some(permitted) => {
-                        let permitted: SpecCapabilities = permitted.union(&caps).copied().collect();
-                        capabilities_builder.permitted(permitted)
-                    }
-                    None => capabilities_builder,
-                };
-
-                let c = capabilities_builder.build()?;
-                return Ok(Some(c));
-            }
-
-            return Ok(Some(
-                LinuxCapabilitiesBuilder::default()
-                    .bounding(caps.clone())
-                    .effective(caps.clone())
-                    .inheritable(caps.clone())
-                    .permitted(caps.clone())
-                    .ambient(caps)
-                    .build()?,
-            ));
-        }
-
-        Ok(None)
-    }
-
     fn get_namespaces(
         &self,
         init_namespaces: HashMap<OsString, Namespace>,
@@ -537,3 +536,157 @@ impl TenantContainerBuilder {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+
+    use caps::Capability as Cap;
+    use oci_spec::runtime::{
+        Capabilities, Capability as SpecCap, LinuxCapabilities, ProcessBuilder, Spec, SpecBuilder,
+    };
+
+    use super::{get_capabilities, LibcontainerError};
+    use crate::capabilities::CapabilityExt;
+
+    fn get_spec(caps: LinuxCapabilities) -> Spec {
+        SpecBuilder::default()
+            .process(
+                ProcessBuilder::default()
+                    .capabilities(caps)
+                    .build()
+                    .unwrap(),
+            )
+            .build()
+            .unwrap()
+    }
+
+    fn cap_to_string(caps: &[Cap]) -> Vec<String> {
+        caps.iter().map(|c| c.to_string()).collect()
+    }
+
+    fn caps_to_spec_set(caps: &[Cap]) -> Capabilities {
+        caps.iter().map(|c| SpecCap::from_cap(*c)).collect()
+    }
+
+    fn empty_caps() -> LinuxCapabilities {
+        let mut t = LinuxCapabilities::default();
+        t.set_effective(None)
+            .set_bounding(None)
+            .set_permitted(None)
+            .set_inheritable(None)
+            .set_ambient(None);
+        t
+    }
+
+    // if there are no existing capabilities, then tenant can only
+    // set effective, bounding and permitted caps ; not inheritable or ambient
+    #[test]
+    fn test_capabilities_no_existing() -> Result<(), LibcontainerError> {
+        let spec = get_spec(empty_caps());
+
+        let extra_caps = &[Cap::CAP_SYS_ADMIN, Cap::CAP_NET_ADMIN, Cap::CAP_AUDIT_READ];
+
+        let additional = cap_to_string(extra_caps);
+        let caps = get_capabilities(&additional, &spec)?;
+
+        let expected_caps = empty_caps()
+            .set_effective(Some(caps_to_spec_set(extra_caps)))
+            .set_bounding(Some(caps_to_spec_set(extra_caps)))
+            .set_permitted(Some(caps_to_spec_set(extra_caps)))
+            .clone();
+
+        assert_eq!(caps, expected_caps);
+        Ok(())
+    }
+
+    // If there are existing capabilities, but not inherent, then tenant should union
+    // existing and provided caps only for effective, bounding and permitted,
+    // inherent and ambient should be explicitly None
+    #[test]
+    fn test_capabilities_with_existing() -> Result<(), LibcontainerError> {
+        let existing_caps = &[Cap::CAP_SYS_ADMIN, Cap::CAP_BPF, Cap::CAP_MKNOD];
+
+        let existing = LinuxCapabilities::default()
+            .set_effective(Some(caps_to_spec_set(existing_caps)))
+            .set_bounding(Some(caps_to_spec_set(existing_caps)))
+            .set_permitted(Some(caps_to_spec_set(existing_caps)))
+            .set_inheritable(None)
+            .set_ambient(None)
+            .clone();
+
+        let spec = get_spec(existing);
+
+        let extra_caps = &[Cap::CAP_SYS_ADMIN, Cap::CAP_NET_ADMIN, Cap::CAP_AUDIT_READ];
+
+        let additional = cap_to_string(extra_caps);
+        let caps = get_capabilities(&additional, &spec)?;
+
+        let mut combined_caps = existing_caps.to_vec();
+        combined_caps.extend(extra_caps);
+        let expected_caps = empty_caps()
+            .set_effective(Some(caps_to_spec_set(&combined_caps)))
+            .set_bounding(Some(caps_to_spec_set(&combined_caps)))
+            .set_permitted(Some(caps_to_spec_set(&combined_caps)))
+            .clone();
+
+        assert_eq!(caps, expected_caps);
+        Ok(())
+    }
+
+    // we check that if inherent capabilities are present, ambient are set correctly
+    #[test]
+    fn test_capabilities_with_existing_inherent() -> Result<(), LibcontainerError> {
+        let existing_caps = &[Cap::CAP_SYS_ADMIN, Cap::CAP_BPF, Cap::CAP_MKNOD];
+        let extra_caps = &[Cap::CAP_SYS_ADMIN, Cap::CAP_NET_ADMIN, Cap::CAP_AUDIT_READ];
+
+        let mut combined_caps = existing_caps.to_vec();
+        combined_caps.extend(extra_caps);
+
+        // case 1 :  when inheritable are there, but no ambient
+
+        let existing = LinuxCapabilities::default()
+            .set_effective(Some(caps_to_spec_set(existing_caps)))
+            .set_bounding(Some(caps_to_spec_set(existing_caps)))
+            .set_permitted(Some(caps_to_spec_set(existing_caps)))
+            .set_inheritable(Some(caps_to_spec_set(existing_caps)))
+            .set_ambient(None)
+            .clone();
+        let spec = get_spec(existing);
+        let additional = cap_to_string(extra_caps);
+        let caps = get_capabilities(&additional, &spec)?;
+        let expected_caps = empty_caps()
+            .set_effective(Some(caps_to_spec_set(&combined_caps)))
+            .set_bounding(Some(caps_to_spec_set(&combined_caps)))
+            .set_permitted(Some(caps_to_spec_set(&combined_caps)))
+            // inheritable must not change
+            .set_inheritable(Some(caps_to_spec_set(existing_caps)))
+            // as there were no existing ambient, only extra will be set
+            .set_ambient(Some(caps_to_spec_set(extra_caps)))
+            .clone();
+        assert_eq!(caps, expected_caps);
+
+        // case 2 :  when inheritable and ambient both are present
+
+        let existing = LinuxCapabilities::default()
+            .set_effective(Some(caps_to_spec_set(existing_caps)))
+            .set_bounding(Some(caps_to_spec_set(existing_caps)))
+            .set_permitted(Some(caps_to_spec_set(existing_caps)))
+            .set_inheritable(Some(caps_to_spec_set(existing_caps)))
+            .set_ambient(Some(caps_to_spec_set(existing_caps)))
+            .clone();
+        let spec = get_spec(existing);
+        let additional = cap_to_string(extra_caps);
+        let caps = get_capabilities(&additional, &spec)?;
+        let expected_caps = empty_caps()
+            .set_effective(Some(caps_to_spec_set(&combined_caps)))
+            .set_bounding(Some(caps_to_spec_set(&combined_caps)))
+            .set_permitted(Some(caps_to_spec_set(&combined_caps)))
+            // inheritable must not change
+            .set_inheritable(Some(caps_to_spec_set(existing_caps)))
+            .set_ambient(Some(caps_to_spec_set(&combined_caps)))
+            .clone();
+        assert_eq!(caps, expected_caps);
+
+        Ok(())
+    }
+}",
"url": "https://github.com/youki-dev/youki/commit/747e342d2026fbf3a395db3e2a491ebef00082f1.patch"
}
] | null |
CVE-2025-32969
|
org.xwiki.platform:xwiki-platform-rest-server allows SQL injection in query endpoint of REST API
|
XWiki is a generic wiki platform. In versions starting from 1.8 and prior to 15.10.16, 16.4.6, and 16.10.1, it is possible for a remote unauthenticated user to escape from the HQL execution context and perform a blind SQL injection to execute arbitrary SQL statements on the database backend, including when "Prevent unregistered users from viewing pages, regardless of the page rights" and "Prevent unregistered users from editing pages, regardless of the page rights" options are enabled. Depending on the used database backend, the attacker may be able to not only obtain confidential information such as password hashes from the database, but also execute UPDATE/INSERT/DELETE queries. This issue has been patched in versions 16.10.1, 16.4.6 and 15.10.16. There is no known workaround, other than upgrading XWiki.
|
[
{
"commit_message": "[PATCH] XWIKI-22718, XWIKI-22691: Improve query validation .../hibernate/query/HqlQueryExecutor.java | 36 +++++++++++++------ .../hibernate/query/HqlQueryUtilsTest.java | 2 ++ .../hibernate/query/HqlQueryExecutorTest.java | 11 +++--- .../search/AbstractDatabaseSearchSource.java | 1 + 4 files changed, 35 insertions(+), 15 deletions(-)",
"patch_text_b64": "From 5c11a874bd24a581f534d283186e209bbccd8113 Mon Sep 17 00:00:00 2001
From: Thomas Mortagne <thomas.mortagne@gmail.com>
Date: Fri, 6 Dec 2024 18:28:07 +0100
Subject: [PATCH] XWIKI-22718, XWIKI-22691: Improve query validation

---
 .../hibernate/query/HqlQueryExecutor.java     | 36 +++++++++++++------
 .../hibernate/query/HqlQueryUtilsTest.java    |  2 ++
 .../hibernate/query/HqlQueryExecutorTest.java | 11 +++---
 .../search/AbstractDatabaseSearchSource.java  |  1 +
 4 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/store/hibernate/query/HqlQueryExecutor.java b/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/store/hibernate/query/HqlQueryExecutor.java
index b769c0522ea5..e1a9a7a40e97 100644
--- a/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/store/hibernate/query/HqlQueryExecutor.java
+++ b/xwiki-platform-core/xwiki-platform-oldcore/src/main/java/com/xpn/xwiki/store/hibernate/query/HqlQueryExecutor.java
@@ -131,12 +131,23 @@ private Set<String> getAllowedNamedQueries()
      */
     protected static boolean isSafeSelect(String statementString)
     {
-        return HqlQueryUtils.isShortFormStatement(statementString) || HqlQueryUtils.isSafe(statementString);
+        // An empty statement is safe
+        if (statementString.isEmpty()) {
+            return true;
+        }
+
+        // HqlQueryUtils#isSafe only works with complete statements
+        String completeStatement = toCompleteShortForm(statementString);
+
+        // Parse and validate the statement
+        return HqlQueryUtils.isSafe(completeStatement);
     }
 
     protected void checkAllowed(final Query query) throws QueryException
     {
-        if (query instanceof SecureQuery && ((SecureQuery) query).isCurrentAuthorChecked()) {
+        // Check if the query needs to be validated according to the current author
+        if (query instanceof SecureQuery secureQuery && secureQuery.isCurrentAuthorChecked()) {
+            // Not need to check the details if current author has programming right
             if (!this.authorization.hasAccess(Right.PROGRAM)) {
                 if (query.isNamed() && !getAllowedNamedQueries().contains(query.getStatement())) {
                     throw new QueryException("Named queries requires programming right", query, null);
@@ -152,15 +163,15 @@ protected void checkAllowed(final Query query) throws QueryException
     @Override
     public <T> List<T> execute(final Query query) throws QueryException
     {
-        // Make sure the query is allowed in the current context
-        checkAllowed(query);
-
         String oldDatabase = getContext().getWikiId();
         try {
             if (query.getWiki() != null) {
                 getContext().setWikiId(query.getWiki());
             }
 
+            // Make sure the query is allowed. Make sure to do it in the target context.
+            checkAllowed(query);
+
             // Filter the query
             Query filteredQuery = filterQuery(query);
 
@@ -333,13 +344,18 @@ private boolean hasQueryParametersType(Query query)
      */
     protected String completeShortFormStatement(String statement)
     {
-        String lcStatement = statement.toLowerCase().trim();
-        if (lcStatement.isEmpty() || lcStatement.startsWith(",") || lcStatement.startsWith("where ")
-            || lcStatement.startsWith("order by ")) {
-            return "select doc.fullName from XWikiDocument doc " + statement.trim();
+        return toCompleteShortForm(statement);
+    }
+
+    private static String toCompleteShortForm(String statement)
+    {
+        String filteredStatement = statement;
+
+        if (statement.isEmpty() || HqlQueryUtils.isShortFormStatement(statement)) {
+            filteredStatement = "select doc.fullName from XWikiDocument doc " + statement.trim();
         }
 
-        return statement;
+        return filteredStatement;
     }
 
     private <T> org.hibernate.query.Query<T> createNamedHibernateQuery(Session session, Query query)
diff --git a/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/internal/store/hibernate/query/HqlQueryUtilsTest.java b/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/internal/store/hibernate/query/HqlQueryUtilsTest.java
index 750ddb1ed321..0e7c5228e009 100644
--- a/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/internal/store/hibernate/query/HqlQueryUtilsTest.java
+++ b/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/internal/store/hibernate/query/HqlQueryUtilsTest.java
@@ -63,6 +63,8 @@ public void isSafe()
             .isSafe("select doc.name, ot.field from XWikiDocument doc, XWikiSpace space, OtherTable as ot"));
         assertFalse(HqlQueryUtils.isSafe("select count(*) from OtherTable"));
         assertFalse(HqlQueryUtils.isSafe("select count(other.*) from OtherTable other"));
+        assertFalse(HqlQueryUtils.isSafe("select doc.fullName from XWikiDocument doc union all select name from OtherTable"));
+        assertFalse(HqlQueryUtils.isSafe("select doc.fullName from XWikiDocument doc where 1<>'1\\'' union select name from OtherTable #'"));
     }
 
     @Test
diff --git a/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/store/hibernate/query/HqlQueryExecutorTest.java b/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/store/hibernate/query/HqlQueryExecutorTest.java
index 088c67b47f2e..e7ab62b32e8c 100644
--- a/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/store/hibernate/query/HqlQueryExecutorTest.java
+++ b/xwiki-platform-core/xwiki-platform-oldcore/src/test/java/com/xpn/xwiki/store/hibernate/query/HqlQueryExecutorTest.java
@@ -220,7 +220,7 @@ public void setNamedParameterArray()
     {
         org.hibernate.query.Query query = mock(org.hibernate.query.Query.class);
         String name = "bar";
-        Integer[] value = new Integer[] { 1, 2, 3 };
+        Integer[] value = new Integer[] {1, 2, 3};
         this.executor.setNamedParameter(query, name, value);
 
         verify(query).setParameterList(name, value);
@@ -403,7 +403,7 @@ public void executeWhenNotAllowedSelect() throws Exception
             assertEquals(
                 "The query requires programming right."
                     + " Query statement = [select notallowed.name from NotAllowedTable notallowed]",
-                expected.getMessage());
+                expected.getCause().getMessage());
         }
     }
 
@@ -415,7 +415,7 @@ public void executeDeleteWithoutProgrammingRight() throws Exception
             fail("Should have thrown an exception here");
         } catch (QueryException expected) {
             assertEquals("The query requires programming right. Query statement = [delete from XWikiDocument as doc]",
-                expected.getMessage());
+                expected.getCause().getMessage());
         }
     }
 
@@ -426,7 +426,8 @@ public void executeNamedQueryWithoutProgrammingRight() throws Exception
             executeNamed("somename", false);
             fail("Should have thrown an exception here");
         } catch (QueryException expected) {
-            assertEquals("Named queries requires programming right. Named query = [somename]", expected.getMessage());
+            assertEquals("Named queries requires programming right. Named query = [somename]",
+                expected.getCause().getMessage());
         }
     }
 
@@ -439,7 +440,7 @@ public void executeUpdateWithoutProgrammingRight() throws Exception
         } catch (QueryException expected) {
             assertEquals(
                 "The query requires programming right. Query statement = [update XWikiDocument set name='name']",
-                expected.getMessage());
+                expected.getCause().getMessage());
         }
     }
 }
diff --git a/xwiki-platform-core/xwiki-platform-rest/xwiki-platform-rest-server/src/main/java/org/xwiki/rest/internal/resources/search/AbstractDatabaseSearchSource.java b/xwiki-platform-core/xwiki-platform-rest/xwiki-platform-rest-server/src/main/java/org/xwiki/rest/internal/resources/search/AbstractDatabaseSearchSource.java
index bad59c5b5c88..447c9dfc6fbf 100644
--- a/xwiki-platform-core/xwiki-platform-rest/xwiki-platform-rest-server/src/main/java/org/xwiki/rest/internal/resources/search/AbstractDatabaseSearchSource.java
+++ b/xwiki-platform-core/xwiki-platform-rest/xwiki-platform-rest-server/src/main/java/org/xwiki/rest/internal/resources/search/AbstractDatabaseSearchSource.java
@@ -63,6 +63,7 @@ public abstract class AbstractDatabaseSearchSource extends AbstractSearchSource
     protected Provider<XWikiContext> xcontextProvider;
 
     @Inject
+    @Named("secure")
     protected QueryManager queryManager;
 
     @Inject",
"url": "https://github.com/xwiki/xwiki-platform/commit/5c11a874bd24a581f534d283186e209bbccd8113.patch"
}
] |
CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')
|
GHSA-2xpp-rgp2-5r6f
| null |
[
{
"commit_message": "[PATCH] update controller/generalization_controller.go | 2 +- controller/sys_dict_controller.go | 14 ++++++- controller/sys_menu_controller.go | 12 +++++- controller/sys_table_controller.go | 53 ++++++++++++++++++++++--- controller/sys_user_controller.go | 12 +++++- 5 files changed, 82 insertions(+), 11 deletions(-)",
"patch_text_b64": "From 146359646a5a90cb09156dbd0013b7df77f2aa6c Mon Sep 17 00:00:00 2001
From: master-nan <305062463@qq.com>
Date: Wed, 28 Aug 2024 14:41:15 +0800
Subject: [PATCH] update

---
 controller/generalization_controller.go |  2 +-
 controller/sys_dict_controller.go       | 14 ++++++-
 controller/sys_menu_controller.go       | 12 +++++-
 controller/sys_table_controller.go      | 53 ++++++++++++++++++++++---
 controller/sys_user_controller.go       | 12 +++++-
 5 files changed, 82 insertions(+), 11 deletions(-)

diff --git a/controller/generalization_controller.go b/controller/generalization_controller.go
index 05df0b1..ed46c47 100644
--- a/controller/generalization_controller.go
+++ b/controller/generalization_controller.go
@@ -27,9 +27,9 @@ func NewGeneralizationController(generalizationService *service.GeneralizationSe
 }
 
 func (gc *GeneralizationController) Query(ctx *gin.Context) {
-	id, err := strconv.Atoi(ctx.Param("id"))
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
+	id, err := strconv.Atoi(ctx.Param("id"))
 	if err != nil {
 		_ = ctx.Error(err)
 		return
diff --git a/controller/sys_dict_controller.go b/controller/sys_dict_controller.go
index 4eff6a7..66a4012 100644
--- a/controller/sys_dict_controller.go
+++ b/controller/sys_dict_controller.go
@@ -66,7 +66,7 @@ func (t *DictController) GetSysDictById(ctx *gin.Context) {
 func (t *DictController) GetSysDictByCode(ctx *gin.Context) {
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
-	code := ctx.Param("code")
+	code := utils.SanitizeInput(ctx.Param("code"))
 	data, err := t.sysDictService.GetSysDictByCode(code)
 	if err != nil {
 		e := &response.AdminError{
@@ -248,9 +248,19 @@ func (t *DictController) CreateSysDictItem(ctx *gin.Context) {
 func (t *DictController) UpdateSysDictItem(ctx *gin.Context) {
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
+	id, err := strconv.Atoi(ctx.Param("id"))
+	if err != nil {
+		e := &response.AdminError{
+			ErrorCode:    http.StatusBadRequest,
+			ErrorMessage: err.Error(),
+		}
+		_ = ctx.Error(e)
+		return
+	}
 	translator, _ := t.translators["zh"]
 	var data request.DictItemUpdateReq
-	err := utils.ValidatorBody[request.DictItemUpdateReq](ctx, &data, translator)
+	data.Id = id
+	err = utils.ValidatorBody[request.DictItemUpdateReq](ctx, &data, translator)
 	if err != nil {
 		_ = ctx.Error(err)
 		return
diff --git a/controller/sys_menu_controller.go b/controller/sys_menu_controller.go
index 0550707..07d1232 100644
--- a/controller/sys_menu_controller.go
+++ b/controller/sys_menu_controller.go
@@ -67,9 +67,19 @@ func (m *MenuController) CreateMenu(ctx *gin.Context) {
 func (m *MenuController) UpdateMenu(ctx *gin.Context) {
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
+	id, err := strconv.Atoi(ctx.Param("id"))
+	if err != nil {
+		e := &response.AdminError{
+			ErrorCode:    http.StatusBadRequest,
+			ErrorMessage: err.Error(),
+		}
+		_ = ctx.Error(e)
+		return
+	}
 	var data request.MenuUpdateReq
+	data.Id = id
 	translator, _ := m.translators["zh"]
-	err := utils.ValidatorBody[request.MenuUpdateReq](ctx, &data, translator)
+	err = utils.ValidatorBody[request.MenuUpdateReq](ctx, &data, translator)
 	if err != nil {
 		_ = ctx.Error(err)
 		return
diff --git a/controller/sys_table_controller.go b/controller/sys_table_controller.go
index cd68b6a..bb43570 100644
--- a/controller/sys_table_controller.go
+++ b/controller/sys_table_controller.go
@@ -8,6 +8,7 @@ package controller
 import (
 	"github.com/gin-gonic/gin"
 	ut "github.com/go-playground/universal-translator"
+	"net/http"
 	"strconv"
 	"sweet-cms/form/request"
 	"sweet-cms/form/response"
@@ -47,7 +48,7 @@ func (t *TableController) GetTableByID(ctx *gin.Context) {
 func (t *TableController) GetTableByCode(ctx *gin.Context) {
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
-	code := ctx.Param("code")
+	code := utils.SanitizeInput(ctx.Param("code"))
 	data, err := t.sysTableService.GetTableByTableCode(code)
 	if err != nil {
 		_ = ctx.Error(err)
@@ -97,9 +98,19 @@ func (t *TableController) CreateTable(ctx *gin.Context) {
 func (t *TableController) UpdateTable(ctx *gin.Context) {
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
+	id, err := strconv.Atoi(ctx.Param("id"))
+	if err != nil {
+		e := &response.AdminError{
+			ErrorCode:    http.StatusBadRequest,
+			ErrorMessage: err.Error(),
+		}
+		_ = ctx.Error(e)
+		return
+	}
 	var data request.TableUpdateReq
+	data.Id = id
 	translator, _ := t.translators["zh"]
-	err := utils.ValidatorBody[request.TableUpdateReq](ctx, &data, translator)
+	err = utils.ValidatorBody[request.TableUpdateReq](ctx, &data, translator)
 	if err != nil {
 		_ = ctx.Error(err)
 		return
@@ -184,9 +195,19 @@ func (t *TableController) CreateTableField(ctx *gin.Context) {
 func (t *TableController) UpdateTableField(ctx *gin.Context) {
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
+	id, err := strconv.Atoi(ctx.Param("id"))
+	if err != nil {
+		e := &response.AdminError{
+			ErrorCode:    http.StatusBadRequest,
+			ErrorMessage: err.Error(),
+		}
+		_ = ctx.Error(e)
+		return
+	}
 	var data request.TableFieldUpdateReq
+	data.Id = id
 	translator, _ := t.translators["zh"]
-	err := utils.ValidatorBody[request.TableFieldUpdateReq](ctx, &data, translator)
+	err = utils.ValidatorBody[request.TableFieldUpdateReq](ctx, &data, translator)
 	if err != nil {
 		_ = ctx.Error(err)
 		return
@@ -271,9 +292,19 @@ func (t *TableController) CreateTableRelation(ctx *gin.Context) {
 func (t *TableController) UpdateTableRelation(ctx *gin.Context) {
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
+	id, err := strconv.Atoi(ctx.Param("id"))
+	if err != nil {
+		e := &response.AdminError{
+			ErrorCode:    http.StatusBadRequest,
+			ErrorMessage: err.Error(),
+		}
+		_ = ctx.Error(e)
+		return
+	}
 	var data request.TableRelationUpdateReq
+	data.Id = id
 	translator, _ := t.translators["zh"]
-	err := utils.ValidatorBody[request.TableRelationUpdateReq](ctx, &data, translator)
+	err = utils.ValidatorBody[request.TableRelationUpdateReq](ctx, &data, translator)
 	if err != nil {
 		_ = ctx.Error(err)
 		return
@@ -357,9 +388,19 @@ func (t *TableController) CreateTableIndex(ctx *gin.Context) {
 func (t *TableController) UpdateTableIndex(ctx *gin.Context) {
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
+	id, err := strconv.Atoi(ctx.Param("id"))
+	if err != nil {
+		e := &response.AdminError{
+			ErrorCode:    http.StatusBadRequest,
+			ErrorMessage: err.Error(),
+		}
+		_ = ctx.Error(e)
+		return
+	}
 	var data request.TableIndexUpdateReq
+	data.Id = id
 	translator, _ := t.translators["zh"]
-	err := utils.ValidatorBody[request.TableIndexUpdateReq](ctx, &data, translator)
+	err = utils.ValidatorBody[request.TableIndexUpdateReq](ctx, &data, translator)
 	if err != nil {
 		_ = ctx.Error(err)
 		return
@@ -407,7 +448,7 @@ func (t *TableController) DeleteTableIndexByTableId(ctx *gin.Context) {
 func (t *TableController) InitTable(ctx *gin.Context) {
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
-	code := ctx.Param("code")
+	code := utils.SanitizeInput(ctx.Param("code"))
 	err := t.sysTableService.InitTable(ctx, code)
 	if err != nil {
 		_ = ctx.Error(err)
diff --git a/controller/sys_user_controller.go b/controller/sys_user_controller.go
index 9a3a784..85ebfd1 100644
--- a/controller/sys_user_controller.go
+++ b/controller/sys_user_controller.go
@@ -99,9 +99,19 @@ func (u *UserController) CreateUser(ctx *gin.Context) {
 func (u *UserController) UpdateUser(ctx *gin.Context) {
 	resp := response.NewResponse()
 	ctx.Set("response", resp)
+	id, err := strconv.Atoi(ctx.Param("id"))
+	if err != nil {
+		e := &response.AdminError{
+			ErrorCode:    http.StatusBadRequest,
+			ErrorMessage: err.Error(),
+		}
+		_ = ctx.Error(e)
+		return
+	}
 	var data request.UserUpdateReq
+	data.Id = id
 	translator, _ := u.translators["zh"]
-	err := utils.ValidatorBody[request.UserUpdateReq](ctx, &data, translator)
+	err = utils.ValidatorBody[request.UserUpdateReq](ctx, &data, translator)
 	err = u.sysUserService.Update(ctx, data)
 	if err != nil {
 		_ = ctx.Error(err)",
"url": "https://github.com/master-nan/sweet-cms/commit/146359646a5a90cb09156dbd0013b7df77f2aa6c.patch"
}
] | null |
|
CVE-2020-15203
|
Denial of Service in Tensorflow
|
In Tensorflow before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, by controlling the `fill` argument of tf.strings.as_string, a malicious attacker is able to trigger a format string vulnerability due to the way the internal format use in a `printf` call is constructed. This may result in segmentation fault. The issue is patched in commit 33be22c65d86256e6826666662e40dbdfe70ee83, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
|
[
{
"commit_message": "[PATCH] Prevent format string vulnerability in `tf.strings.as_string`. The `printf` format specifier only allows `#`, `0`, `-`, `+` and space as flag characters. Others are interpreted as width/precision/length modifier or conversion specifiers. If a character does not fit into any of these sets `printf` just displays it. Also add a test suite for `tf.strings.as_string`. Also fix the issue where the flag character was used only if width was specified. PiperOrigin-RevId: 332553548 Change-Id: Ie57cf2a7c14d1a36097642794c14329db669bbba tensorflow/core/kernels/BUILD | 18 ++ tensorflow/core/kernels/as_string_op.cc | 19 +- tensorflow/core/kernels/as_string_op_test.cc | 245 +++++++++++++++++++ 3 files changed, 281 insertions(+), 1 deletion(-) create mode 100644 tensorflow/core/kernels/as_string_op_test.cc",
"patch_text_b64": "From 33be22c65d86256e6826666662e40dbdfe70ee83 Mon Sep 17 00:00:00 2001
From: Mihai Maruseac <mihaimaruseac@google.com>
Date: Fri, 18 Sep 2020 16:54:17 -0700
Subject: [PATCH] Prevent format string vulnerability in
 `tf.strings.as_string`.

The `printf` format specifier only allows `#`, `0`, `-`, `+` and space as flag characters. Others are interpreted as width/precision/length modifier or conversion specifiers. If a character does not fit into any of these sets `printf` just displays it.

Also add a test suite for `tf.strings.as_string`. Also fix the issue where the flag character was used only if width was specified.

PiperOrigin-RevId: 332553548
Change-Id: Ie57cf2a7c14d1a36097642794c14329db669bbba
---
 tensorflow/core/kernels/BUILD                |  18 ++
 tensorflow/core/kernels/as_string_op.cc      |  19 +-
 tensorflow/core/kernels/as_string_op_test.cc | 245 +++++++++++++++++++
 3 files changed, 281 insertions(+), 1 deletion(-)
 create mode 100644 tensorflow/core/kernels/as_string_op_test.cc

diff --git a/tensorflow/core/kernels/BUILD b/tensorflow/core/kernels/BUILD
index a5781701599866..9671c5a621eedc 100644
--- a/tensorflow/core/kernels/BUILD
+++ b/tensorflow/core/kernels/BUILD
@@ -5228,6 +5228,24 @@ tf_kernel_library(
     deps = STRING_DEPS,
 )
 
+tf_cc_test(
+    name = "as_string_op_test",
+    size = "small",
+    srcs = ["as_string_op_test.cc"],
+    deps = [
+        ":as_string_op",
+        ":ops_testutil",
+        ":ops_util",
+        "//tensorflow/core:core_cpu",
+        "//tensorflow/core:framework",
+        "//tensorflow/core:lib",
+        "//tensorflow/core:protos_all_cc",
+        "//tensorflow/core:test",
+        "//tensorflow/core:test_main",
+        "//tensorflow/core:testlib",
+    ],
+)
+
 tf_kernel_library(
     name = "unicode_ops",
     prefix = "unicode_ops",
diff --git a/tensorflow/core/kernels/as_string_op.cc b/tensorflow/core/kernels/as_string_op.cc
index 8341909fbc8409..b9af976a654d99 100644
--- a/tensorflow/core/kernels/as_string_op.cc
+++ b/tensorflow/core/kernels/as_string_op.cc
@@ -65,9 +65,26 @@ class AsStringOp : public OpKernel {
     OP_REQUIRES(ctx, !(scientific && shortest),
                 errors::InvalidArgument(
                     "Cannot select both scientific and shortest notation"));
+
     format_ = "%";
+    if (!fill_string.empty()) {
+      switch (fill_string[0]) {
+        case ' ':
+        case '+':
+        case '-':
+        case '0':
+        case '#':
+          strings::Appendf(&format_, "%s", fill_string.c_str());
+          break;
+        default:
+          bool fill_not_supported = true;
+          OP_REQUIRES(ctx, !fill_not_supported,
+                      errors::InvalidArgument("Fill argument not supported: \"",
+                                              fill_string, "\""));
+      }
+    }
     if (width > -1) {
-      strings::Appendf(&format_, "%s%d", fill_string.c_str(), width);
+      strings::Appendf(&format_, "%d", width);
     }
     if (precision > -1) {
       strings::Appendf(&format_, ".%d", precision);
diff --git a/tensorflow/core/kernels/as_string_op_test.cc b/tensorflow/core/kernels/as_string_op_test.cc
new file mode 100644
index 00000000000000..dff78e25e72025
--- /dev/null
+++ b/tensorflow/core/kernels/as_string_op_test.cc
@@ -0,0 +1,245 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed 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.
+==============================================================================*/
+
+#include "tensorflow/core/framework/fake_input.h"
+#include "tensorflow/core/framework/node_def_builder.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_testutil.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/kernels/ops_testutil.h"
+#include "tensorflow/core/kernels/ops_util.h"
+#include "tensorflow/core/lib/core/status_test_util.h"
+
+namespace tensorflow {
+namespace {
+
+class AsStringGraphTest : public OpsTestBase {
+ protected:
+  Status Init(DataType input_type, const string& fill = "", int width = -1,
+              int precision = -1, bool scientific = false,
+              bool shortest = false) {
+    TF_CHECK_OK(NodeDefBuilder("op", "AsString")
+                    .Input(FakeInput(input_type))
+                    .Attr("fill", fill)
+                    .Attr("precision", precision)
+                    .Attr("scientific", scientific)
+                    .Attr("shortest", shortest)
+                    .Attr("width", width)
+                    .Finalize(node_def()));
+    return InitOp();
+  }
+};
+
+TEST_F(AsStringGraphTest, Int8) {
+  TF_ASSERT_OK(Init(DT_INT8));
+
+  AddInputFromArray<int8>(TensorShape({3}), {-42, 0, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({3}));
+  test::FillValues<tstring>(&expected, {"-42", "0", "42"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, Int64) {
+  TF_ASSERT_OK(Init(DT_INT64));
+
+  AddInputFromArray<int64>(TensorShape({3}), {-42, 0, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({3}));
+  test::FillValues<tstring>(&expected, {"-42", "0", "42"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, FloatDefault) {
+  TF_ASSERT_OK(Init(DT_FLOAT));
+
+  AddInputFromArray<float>(TensorShape({4}), {-42, 0, 3.14159, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({4}));
+  test::FillValues<tstring>(
+      &expected, {"-42.000000", "0.000000", "3.141590", "42.000000"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, FloatScientific) {
+  TF_ASSERT_OK(Init(DT_FLOAT, /*fill=*/"", /*width=*/-1, /*precision=*/-1,
+                    /*scientific=*/true));
+
+  AddInputFromArray<float>(TensorShape({4}), {-42, 0, 3.14159, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({4}));
+  test::FillValues<tstring>(&expected, {"-4.200000e+01", "0.000000e+00",
+                                        "3.141590e+00", "4.200000e+01"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, FloatShortest) {
+  TF_ASSERT_OK(Init(DT_FLOAT, /*fill=*/"", /*width=*/-1, /*precision=*/-1,
+                    /*scientific=*/false, /*shortest=*/true));
+
+  AddInputFromArray<float>(TensorShape({4}), {-42, 0, 3.14159, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({4}));
+  test::FillValues<tstring>(&expected, {"-42", "0", "3.14159", "42"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, FloatPrecisionOnly) {
+  TF_ASSERT_OK(Init(DT_FLOAT, /*fill=*/"", /*width=*/-1, /*precision=*/2));
+
+  AddInputFromArray<float>(TensorShape({4}), {-42, 0, 3.14159, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({4}));
+  test::FillValues<tstring>(&expected, {"-42.00", "0.00", "3.14", "42.00"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, FloatWidthOnly) {
+  TF_ASSERT_OK(Init(DT_FLOAT, /*fill=*/"", /*width=*/5));
+
+  AddInputFromArray<float>(TensorShape({4}), {-42, 0, 3.14159, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({4}));
+  test::FillValues<tstring>(
+      &expected, {"-42.000000", "0.000000", "3.141590", "42.000000"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, Float_5_2_Format) {
+  TF_ASSERT_OK(Init(DT_FLOAT, /*fill=*/"", /*width=*/5, /*precision=*/2));
+
+  AddInputFromArray<float>(TensorShape({4}), {-42, 0, 3.14159, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({4}));
+  test::FillValues<tstring>(&expected, {"-42.00", " 0.00", " 3.14", "42.00"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, Complex) {
+  TF_ASSERT_OK(Init(DT_COMPLEX64, /*fill=*/"", /*width=*/5, /*precision=*/2));
+
+  AddInputFromArray<complex64>(TensorShape({3}), {{-4, 2}, {0}, {3.14159, -1}});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({3}));
+  test::FillValues<tstring>(
+      &expected, {"(-4.00, 2.00)", "( 0.00, 0.00)", "( 3.14,-1.00)"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, Bool) {
+  TF_ASSERT_OK(Init(DT_BOOL));
+
+  AddInputFromArray<bool>(TensorShape({2}), {true, false});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({2}));
+  test::FillValues<tstring>(&expected, {"true", "false"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, String) {
+  Status s = Init(DT_STRING);
+  ASSERT_EQ(error::INVALID_ARGUMENT, s.code());
+  ASSERT_TRUE(absl::StrContains(
+      s.error_message(),
+      "Value for attr 'T' of string is not in the list of allowed values"));
+}
+
+TEST_F(AsStringGraphTest, OnlyOneOfScientificAndShortest) {
+  Status s = Init(DT_FLOAT, /*fill=*/"", /*width=*/-1, /*precision=*/-1,
+                  /*scientific=*/true, /*shortest=*/true);
+  ASSERT_EQ(error::INVALID_ARGUMENT, s.code());
+  ASSERT_TRUE(
+      absl::StrContains(s.error_message(),
+                        "Cannot select both scientific and shortest notation"));
+}
+
+TEST_F(AsStringGraphTest, NoShortestForNonFloat) {
+  Status s = Init(DT_INT32, /*fill=*/"", /*width=*/-1, /*precision=*/-1,
+                  /*scientific=*/false, /*shortest=*/true);
+  ASSERT_EQ(error::INVALID_ARGUMENT, s.code());
+  ASSERT_TRUE(absl::StrContains(
+      s.error_message(),
+      "scientific and shortest format not supported for datatype"));
+}
+
+TEST_F(AsStringGraphTest, NoScientificForNonFloat) {
+  Status s = Init(DT_INT32, /*fill=*/"", /*width=*/-1, /*precision=*/-1,
+                  /*scientific=*/true);
+  ASSERT_EQ(error::INVALID_ARGUMENT, s.code());
+  ASSERT_TRUE(absl::StrContains(
+      s.error_message(),
+      "scientific and shortest format not supported for datatype"));
+}
+
+TEST_F(AsStringGraphTest, NoPrecisionForNonFloat) {
+  Status s = Init(DT_INT32, /*fill=*/"", /*width=*/-1, /*precision=*/5);
+  ASSERT_EQ(error::INVALID_ARGUMENT, s.code());
+  ASSERT_TRUE(absl::StrContains(s.error_message(),
+                                "precision not supported for datatype"));
+}
+
+TEST_F(AsStringGraphTest, LongFill) {
+  Status s = Init(DT_INT32, /*fill=*/"asdf");
+  ASSERT_EQ(error::INVALID_ARGUMENT, s.code());
+  ASSERT_TRUE(absl::StrContains(s.error_message(),
+                                "Fill string must be one or fewer characters"));
+}
+
+TEST_F(AsStringGraphTest, FillWithZero) {
+  TF_ASSERT_OK(Init(DT_INT64, /*fill=*/"0", /*width=*/4));
+
+  AddInputFromArray<int64>(TensorShape({3}), {-42, 0, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({3}));
+  test::FillValues<tstring>(&expected, {"-042", "0000", "0042"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, FillWithSpace) {
+  TF_ASSERT_OK(Init(DT_INT64, /*fill=*/" ", /*width=*/4));
+
+  AddInputFromArray<int64>(TensorShape({3}), {-42, 0, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({3}));
+  test::FillValues<tstring>(&expected, {" -42", "   0", "  42"});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, FillWithChar1) {
+  TF_ASSERT_OK(Init(DT_INT64, /*fill=*/"-", /*width=*/4));
+
+  AddInputFromArray<int64>(TensorShape({3}), {-42, 0, 42});
+  TF_ASSERT_OK(RunOpKernel());
+  Tensor expected(allocator(), DT_STRING, TensorShape({3}));
+  test::FillValues<tstring>(&expected, {"-42 ", "0   ", "42  "});
+  test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
+}
+
+TEST_F(AsStringGraphTest, FillWithChar3) {
+  Status s = Init(DT_INT32, /*fill=*/"s");
+  ASSERT_EQ(error::INVALID_ARGUMENT, s.code());
+  ASSERT_TRUE(
+      absl::StrContains(s.error_message(), "Fill argument not supported"));
+}
+
+TEST_F(AsStringGraphTest, FillWithChar4) {
+  Status s = Init(DT_INT32, /*fill=*/"n");
+  ASSERT_EQ(error::INVALID_ARGUMENT, s.code());
+  ASSERT_TRUE(
+      absl::StrContains(s.error_message(), "Fill argument not supported"));
+}
+
+}  // end namespace
+}  // end namespace tensorflow",
"url": "https://github.com/tensorflow/tensorflow/commit/33be22c65d86256e6826666662e40dbdfe70ee83.patch"
}
] |
{"CWE-20":"Improper Input Validation"}
|
CVE-2021-46876
|
An issue was discovered in eZ Publish Ibexa Kernel before 7.5.15.1. The /user/sessions endpoint can be abused to determine account existence.
|
[
{
"commit_message": "[PATCH] Merge pull request from GHSA-gmrf-99gw-vvwj Co-authored-by: Bartek Wajda <[email protected]> .../Resources/config/default_settings.yml | 4 ++++ .../Resources/config/security.yml | 2 ++ .../Server/Controller/SessionController.php | 2 +- .../Server/Security/RestAuthenticator.php | 22 ++++++++++++++++++- 4 files changed, 28 insertions(+), 2 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/ezsystems/ezpublish-kernel/commit/b496f073c3f03707d3531a6941dc098b84e3cbed.patch"
}
] |
n/a
|
|
CVE-2026-22705
|
RustCrypto: Signatures has timing side-channel in ML-DSA decomposition
|
RustCrypto: Signatures offers support for digital signatures, which provide authentication of data using public-key cryptography. Prior to version 0.1.0-rc.2, a timing side-channel was discovered in the Decompose algorithm which is used during ML-DSA signing to generate hints for the signature. This issue has been patched in version 0.1.0-rc.2.
|
[
{
"commit_message": "[PATCH] ml-dsa: use Barrett reduction instead of integer division to prevent side-channels (#1144) ml-dsa/src/algebra.rs | 52 ++++++++++++++++++++++- ml-dsa/src/ntt.rs | 99 ++++++++++++++++++++++++++++++------------- 2 files changed, 119 insertions(+), 32 deletions(-)",
"patch_text_b64": "From 035d9eef98486ecd00a8bf418c7817eb14dd6558 Mon Sep 17 00:00:00 2001
From: Scott Arciszewski <147527775+tob-scott-a@users.noreply.github.com>
Date: Fri, 9 Jan 2026 14:06:07 -0500
Subject: [PATCH] ml-dsa: use Barrett reduction instead of integer division to
 prevent side-channels (#1144)

---
 ml-dsa/src/algebra.rs | 52 ++++++++++++++++++++++-
 ml-dsa/src/ntt.rs     | 99 ++++++++++++++++++++++++++++++-------------
 2 files changed, 119 insertions(+), 32 deletions(-)

diff --git a/ml-dsa/src/algebra.rs b/ml-dsa/src/algebra.rs
index 559b68a9..0742c534 100644
--- a/ml-dsa/src/algebra.rs
+++ b/ml-dsa/src/algebra.rs
@@ -54,8 +54,55 @@ pub(crate) trait Decompose {
     fn decompose<TwoGamma2: Unsigned>(self) -> (Elem, Elem);
 }
 
+/// Constant-time division by a compile-time constant divisor.
+///
+/// This trait provides a constant-time alternative to the hardware division
+/// instruction, which has variable timing based on operand values.
+/// Uses Barrett reduction to compute `x / M` where M is a compile-time constant.
+pub(crate) trait ConstantTimeDiv: Unsigned {
+    /// Bit shift for Barrett reduction, chosen to provide sufficient precision
+    const CT_DIV_SHIFT: usize;
+    /// Precomputed multiplier: ceil(2^SHIFT / M)
+    const CT_DIV_MULTIPLIER: u64;
+
+    /// Perform constant-time division of x by `Self::U32`
+    /// Requires: x < Q (the field modulus, ~2^23)
+    #[allow(clippy::inline_always)] // Required for constant-time guarantees in crypto code
+    #[inline(always)]
+    fn ct_div(x: u32) -> u32 {
+        // Barrett reduction: q = (x * MULTIPLIER) >> SHIFT
+        // This gives us floor(x / M) for x < 2^SHIFT / MULTIPLIER * M
+        let x64 = u64::from(x);
+        let quotient = (x64 * Self::CT_DIV_MULTIPLIER) >> Self::CT_DIV_SHIFT;
+        // SAFETY: quotient is guaranteed to fit in u32 because:
+        // - x < Q (~2^23), so quotient = x / M < x < 2^23 < 2^32
+        #[allow(clippy::cast_possible_truncation, clippy::as_conversions)]
+        let result = quotient as u32;
+        result
+    }
+}
+
+impl<M> ConstantTimeDiv for M
+where
+    M: Unsigned,
+{
+    // Use a shift that provides enough precision for the ML-DSA field (Q ~ 2^23)
+    // We need SHIFT > log2(Q) + log2(M) to ensure accuracy
+    // With Q < 2^24 and M < 2^20, SHIFT = 48 is sufficient
+    const CT_DIV_SHIFT: usize = 48;
+
+    // Precompute the multiplier at compile time
+    // We add (M-1) before dividing to get ceiling division, ensuring we never underestimate
+    #[allow(clippy::integer_division_remainder_used)]
+    const CT_DIV_MULTIPLIER: u64 = (1u64 << Self::CT_DIV_SHIFT).div_ceil(M::U64);
+}
+
 impl Decompose for Elem {
     // Algorithm 36 Decompose
+    //
+    // This implementation uses constant-time division to avoid timing side-channels.
+    // The original algorithm used hardware division which has variable timing based
+    // on operand values, potentially leaking secret information during signing.
     fn decompose<TwoGamma2: Unsigned>(self) -> (Elem, Elem) {
         let r_plus = self.clone();
         let r0 = r_plus.mod_plus_minus::<TwoGamma2>();
@@ -63,8 +110,9 @@ impl Decompose for Elem {
         if r_plus - r0 == Elem::new(BaseField::Q - 1) {
             (Elem::new(0), r0 - Elem::new(1))
         } else {
-            let mut r1 = r_plus - r0;
-            r1.0 /= TwoGamma2::U32;
+            let diff = r_plus - r0;
+            // Use constant-time division instead of hardware division
+            let r1 = Elem::new(TwoGamma2::ct_div(diff.0));
             (r1, r0)
         }
     }
diff --git a/ml-dsa/src/ntt.rs b/ml-dsa/src/ntt.rs
index a0b07149..da63bb1d 100644
--- a/ml-dsa/src/ntt.rs
+++ b/ml-dsa/src/ntt.rs
@@ -50,28 +50,46 @@ pub(crate) trait Ntt {
     fn ntt(&self) -> Self::Output;
 }
 
+/// Constant-time NTT butterfly layer.
+///
+/// Uses const generics to ensure loop bounds are compile-time constants,
+/// avoiding UDIV instructions from runtime `step_by` calculations.
+#[allow(clippy::inline_always)] // Required for constant-time guarantees in crypto code
+#[inline(always)]
+fn ntt_layer<const LEN: usize, const ITERATIONS: usize>(w: &mut [Elem; 256], m: &mut usize) {
+    for i in 0..ITERATIONS {
+        let start = i * 2 * LEN;
+        *m += 1;
+        let z = ZETA_POW_BITREV[*m];
+        for j in start..(start + LEN) {
+            let t = z * w[j + LEN];
+            w[j + LEN] = w[j] - t;
+            w[j] = w[j] + t;
+        }
+    }
+}
+
 impl Ntt for Polynomial {
     type Output = NttPolynomial;
 
     // Algorithm 41 NTT
+    //
+    // This implementation uses const-generic helper functions to ensure all loop
+    // bounds are compile-time constants, avoiding potential UDIV instructions.
     fn ntt(&self) -> Self::Output {
-        let mut w = self.0.clone();
-
+        let mut w: [Elem; 256] = self.0.clone().into();
         let mut m = 0;
-        for len in [128, 64, 32, 16, 8, 4, 2, 1] {
-            for start in (0..256).step_by(2 * len) {
-                m += 1;
-                let z = ZETA_POW_BITREV[m];
-
-                for j in start..(start + len) {
-                    let t = z * w[j + len];
-                    w[j + len] = w[j] - t;
-                    w[j] = w[j] + t;
-                }
-            }
-        }
 
-        NttPolynomial::new(w)
+        ntt_layer::<128, 1>(&mut w, &mut m);
+        ntt_layer::<64, 2>(&mut w, &mut m);
+        ntt_layer::<32, 4>(&mut w, &mut m);
+        ntt_layer::<16, 8>(&mut w, &mut m);
+        ntt_layer::<8, 16>(&mut w, &mut m);
+        ntt_layer::<4, 32>(&mut w, &mut m);
+        ntt_layer::<2, 64>(&mut w, &mut m);
+        ntt_layer::<1, 128>(&mut w, &mut m);
+
+        NttPolynomial::new(w.into())
     }
 }
 
@@ -89,30 +107,51 @@ pub(crate) trait NttInverse {
     fn ntt_inverse(&self) -> Self::Output;
 }
 
+/// Constant-time inverse NTT butterfly layer.
+///
+/// Uses const generics to ensure loop bounds are compile-time constants,
+/// avoiding UDIV instructions from runtime `step_by` calculations.
+#[allow(clippy::inline_always)] // Required for constant-time guarantees in crypto code
+#[inline(always)]
+fn ntt_inverse_layer<const LEN: usize, const ITERATIONS: usize>(
+    w: &mut [Elem; 256],
+    m: &mut usize,
+) {
+    for i in 0..ITERATIONS {
+        let start = i * 2 * LEN;
+        *m -= 1;
+        let z = -ZETA_POW_BITREV[*m];
+        for j in start..(start + LEN) {
+            let t = w[j];
+            w[j] = t + w[j + LEN];
+            w[j + LEN] = z * (t - w[j + LEN]);
+        }
+    }
+}
+
 impl NttInverse for NttPolynomial {
     type Output = Polynomial;
 
     // Algorithm 42 NTT^{−1}
+    //
+    // This implementation uses const-generic helper functions to ensure all loop
+    // bounds are compile-time constants, avoiding potential UDIV instructions.
     fn ntt_inverse(&self) -> Self::Output {
         const INVERSE_256: Elem = Elem::new(8_347_681);
 
-        let mut w = self.0.clone();
-
+        let mut w: [Elem; 256] = self.0.clone().into();
         let mut m = 256;
-        for len in [1, 2, 4, 8, 16, 32, 64, 128] {
-            for start in (0..256).step_by(2 * len) {
-                m -= 1;
-                let z = -ZETA_POW_BITREV[m];
-
-                for j in start..(start + len) {
-                    let t = w[j];
-                    w[j] = t + w[j + len];
-                    w[j + len] = z * (t - w[j + len]);
-                }
-            }
-        }
 
-        INVERSE_256 * &Polynomial::new(w)
+        ntt_inverse_layer::<1, 128>(&mut w, &mut m);
+        ntt_inverse_layer::<2, 64>(&mut w, &mut m);
+        ntt_inverse_layer::<4, 32>(&mut w, &mut m);
+        ntt_inverse_layer::<8, 16>(&mut w, &mut m);
+        ntt_inverse_layer::<16, 8>(&mut w, &mut m);
+        ntt_inverse_layer::<32, 4>(&mut w, &mut m);
+        ntt_inverse_layer::<64, 2>(&mut w, &mut m);
+        ntt_inverse_layer::<128, 1>(&mut w, &mut m);
+
+        INVERSE_256 * &Polynomial::new(w.into())
     }
 }",
"url": "https://github.com/RustCrypto/signatures/commit/035d9eef98486ecd00a8bf418c7817eb14dd6558.patch"
}
] |
CWE-1240: Use of a Cryptographic Primitive with a Risky Implementation
|
CVE-2022-39387
|
XWiki OIDC Authenticator vulnerable to OpenID login bypass due to improper authentication
|
XWiki OIDC has various tools to manipulate OpenID Connect protocol in XWiki. Prior to version 1.29.1, even if a wiki has an OpenID provider configured through its xwiki.properties, it is possible to provide a third party provider its details through request parameters. One can then bypass the XWiki authentication altogether by specifying its own provider through the oidc.endpoint.* request parameters (or by using an XWiki-based OpenID provider with oidc.xwikiprovider. With the same approach, one could also provide a specific group mapping through oidc.groups.mapping that would make his user automatically part of the XWikiAdminGroup. This issue has been patched, please upgrade to 1.29.1. There is no workaround, an upgrade of the authenticator is required.
|
[
{
"commit_message": "[PATCH] OIDC-118: Fix bad handling of request parameters .../internal/OIDCClientConfiguration.java | 42 +++++++++------ .../internal/OIDCClientConfigurationTest.java | 52 +++++++++++++++++++ 2 files changed, 79 insertions(+), 15 deletions(-)",
"patch_text_b64": "From 0247af1417925b9734ab106ad7cd934ee870ac89 Mon Sep 17 00:00:00 2001
From: Thomas Mortagne <thomas.mortagne@gmail.com>
Date: Thu, 27 Jan 2022 15:16:30 +0100
Subject: [PATCH] OIDC-118: Fix bad handling of request parameters

---
 .../internal/OIDCClientConfiguration.java     | 42 +++++++++------
 .../internal/OIDCClientConfigurationTest.java | 52 +++++++++++++++++++
 2 files changed, 79 insertions(+), 15 deletions(-)

diff --git a/oidc-authenticator/src/main/java/org/xwiki/contrib/oidc/auth/internal/OIDCClientConfiguration.java b/oidc-authenticator/src/main/java/org/xwiki/contrib/oidc/auth/internal/OIDCClientConfiguration.java
index 8fba1dc9..417ee204 100644
--- a/oidc-authenticator/src/main/java/org/xwiki/contrib/oidc/auth/internal/OIDCClientConfiguration.java
+++ b/oidc-authenticator/src/main/java/org/xwiki/contrib/oidc/auth/internal/OIDCClientConfiguration.java
@@ -37,11 +37,11 @@
 import javax.servlet.http.HttpSession;
 
 import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.SetUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.joda.time.LocalDateTime;
 import org.slf4j.Logger;
 import org.xwiki.component.annotation.Component;
-import org.xwiki.configuration.ConfigurationSource;
 import org.xwiki.container.Container;
 import org.xwiki.container.Request;
 import org.xwiki.container.Session;
@@ -234,6 +234,8 @@ public Map<String, Set<String>> getProviderMapping()
 
     private static final String XWIKI_GROUP_PREFIX = "XWiki.";
 
+    private static final Set<String> SAFE_PROPERTIES = SetUtils.hashSet(PROP_SKIPPED);
+
     @Inject
     private InstanceIdManager instance;
 
@@ -249,10 +251,6 @@ public Map<String, Set<String>> getProviderMapping()
     @Inject
     private Logger logger;
 
-    @Inject
-    // TODO: store configuration in custom objects
-    private ConfigurationSource configuration;
-
     private HttpSession getHttpSession()
     {
         Session session = this.container.getSession();
@@ -335,10 +333,12 @@ public Map<String, String> getMap(String key)
     @Override
     protected <T> T getProperty(String key, Class<T> valueClass)
     {
-        // Get property from request
-        String requestValue = getRequestParameter(key);
-        if (requestValue != null) {
-            return this.converter.convert(valueClass, requestValue);
+        if (SAFE_PROPERTIES.contains(key)) {
+            // Get property from request
+            String requestValue = getRequestParameter(key);
+            if (requestValue != null) {
+                return this.converter.convert(valueClass, requestValue);
+            }
         }
 
         // Get property from session
@@ -354,10 +354,12 @@ protected <T> T getProperty(String key, Class<T> valueClass)
     @Override
     protected <T> T getProperty(String key, T def)
     {
-        // Get property from request
-        String requestValue = getRequestParameter(key);
-        if (requestValue != null) {
-            return this.converter.convert(def.getClass(), requestValue);
+        if (SAFE_PROPERTIES.contains(key)) {
+            // Get property from request
+            String requestValue = getRequestParameter(key);
+            if (requestValue != null) {
+                return this.converter.convert(def.getClass(), requestValue);
+            }
         }
 
         // Get property from session
@@ -426,9 +428,19 @@ private Endpoint getEndPoint(String hint) throws URISyntaxException
             uri = new URI(uriString);
         }
 
-        // If we still don't have any endpoint URI, return null
+        // If we still don't have any endpoint URI, try the request
         if (uri == null) {
-            return null;
+            uriString = getRequestParameter(PROPPREFIX_ENDPOINT + hint);
+            if (uriString == null) {
+                String provider = getRequestParameter(PROP_XWIKIPROVIDER);
+                if (provider == null) {
+                    return null;
+                }
+
+                uri = this.manager.createEndPointURI(provider, hint);
+            } else {
+                uri = new URI(uriString);
+            }
         }
 
         // Find custom headers
diff --git a/oidc-authenticator/src/test/java/org/xwiki/contrib/oidc/auth/internal/OIDCClientConfigurationTest.java b/oidc-authenticator/src/test/java/org/xwiki/contrib/oidc/auth/internal/OIDCClientConfigurationTest.java
index e4bccbde..dea5711e 100644
--- a/oidc-authenticator/src/test/java/org/xwiki/contrib/oidc/auth/internal/OIDCClientConfigurationTest.java
+++ b/oidc-authenticator/src/test/java/org/xwiki/contrib/oidc/auth/internal/OIDCClientConfigurationTest.java
@@ -19,8 +19,10 @@
  */
 package org.xwiki.contrib.oidc.auth.internal;
 
+import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.net.URL;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -28,11 +30,19 @@
 
 import org.junit.jupiter.api.Test;
 import org.xwiki.configuration.ConfigurationSource;
+import org.xwiki.container.Container;
+import org.xwiki.container.servlet.ServletRequest;
+import org.xwiki.contrib.oidc.provider.internal.OIDCManager;
+import org.xwiki.contrib.oidc.provider.internal.endpoint.TokenOIDCEndpoint;
+import org.xwiki.properties.ConverterManager;
 import org.xwiki.test.junit5.mockito.ComponentTest;
 import org.xwiki.test.junit5.mockito.InjectMockComponents;
 import org.xwiki.test.junit5.mockito.MockComponent;
 
+import com.xpn.xwiki.web.XWikiServletRequestStub;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.when;
@@ -51,6 +61,15 @@ class OIDCClientConfigurationTest
     @MockComponent
     private ConfigurationSource sourceConfiguration;
 
+    @MockComponent
+    private Container container;
+
+    @MockComponent
+    private OIDCManager manager;
+
+    @MockComponent
+    private ConverterManager converterManager;
+
     @Test
     void getUserInfoOIDCEndpoint() throws URISyntaxException
     {
@@ -78,6 +97,39 @@ void getUserInfoOIDCEndpoint() throws URISyntaxException
 
         assertEquals(uri, endpoint.getURI());
         assertEquals(headers, endpoint.getHeaders());
+    }
+
+    @Test
+    void getPropertyOrder() throws MalformedURLException, URISyntaxException
+    {
+        String provider = "http://urlprovider";
+        URI urlauthorization = new URI("http://urlauthorization");
+
+        XWikiServletRequestStub requestStub = new XWikiServletRequestStub(new URL("http://url"), null);
+
+        when(this.container.getRequest()).thenReturn(new ServletRequest(requestStub));
+        when(this.sourceConfiguration.getProperty(OIDCClientConfiguration.PROP_SKIPPED, false)).thenReturn(false);
+
+        assertFalse(this.configuration.isSkipped());
+        assertNull(this.configuration.getXWikiProvider());
+        assertNull(this.configuration.getAuthorizationOIDCEndpoint());
+        assertNull(this.configuration.getAuthorizationOIDCEndpoint());
+        assertNull(this.configuration.getTokenOIDCEndpoint());
+
+        requestStub.put(OIDCClientConfiguration.PROP_SKIPPED, "true");
+        when(this.converterManager.convert(Boolean.class, "true")).thenReturn(true);
+
+        assertTrue(this.configuration.isSkipped());
+
+        requestStub.put(OIDCClientConfiguration.PROP_GROUPS_ALLOWED, "true");
+
+        assertNull(this.configuration.getAllowedGroups());
+
+        requestStub.put(OIDCClientConfiguration.PROP_XWIKIPROVIDER, provider.toString());
+        requestStub.put(OIDCClientConfiguration.PROP_ENDPOINT_AUTHORIZATION, urlauthorization.toString());
+        when(this.manager.createEndPointURI(provider, TokenOIDCEndpoint.HINT)).thenReturn(new URI(provider));
 
+        assertEquals(urlauthorization, this.configuration.getAuthorizationOIDCEndpoint().getURI());
+        assertEquals(provider, this.configuration.getTokenOIDCEndpoint().getURI().toString());
     }
 }",
"url": "https://github.com/xwiki-contrib/oidc/commit/0247af1417925b9734ab106ad7cd934ee870ac89.patch"
}
] |
CWE-287: Improper Authentication
|
CVE-2024-51498
|
[@imput/cobalt-web] Cross-site Scripting when downloading picker image from malicious instance
|
cobalt is a media downloader that doesn't piss you off. A malicious cobalt instance could serve links with the `javascript:` protocol, resulting in Cross-site Scripting (XSS) when the user tries to download an item from a picker. This issue has been present since commit `66bac03e`, was mitigated in commit `97977efa` (correctly configured web instances were no longer vulnerable) and fully fixed in commit `c4be1d3a` (included in release version 10.2.1). Users are advised to upgrade. Users unable to upgrade should enable a content-security-policy.
|
[
{
"commit_message": "[PATCH] web/dialogs: add picker dialog & clean up small dialog web/i18n/en/a11y/dialog.json | 3 + web/i18n/en/dialog.json | 9 +- .../dialog/DialogBackdropClose.svelte | 18 ++ .../components/dialog/DialogButtons.svelte | 61 +++++ web/src/components/dialog/DialogHolder.svelte | 107 +++++++- web/src/components/dialog/PickerDialog.svelte | 231 ++++++++++++++++++ web/src/components/dialog/PickerItem.svelte | 65 +++++ web/src/components/dialog/SmallDialog.svelte | 176 ++----------- .../save/buttons/DownloadButton.svelte | 93 ++++--- web/src/lib/download.ts | 9 + web/src/lib/types/dialog.ts | 11 +- 11 files changed, 584 insertions(+), 199 deletions(-) create mode 100644 web/i18n/en/a11y/dialog.json create mode 100644 web/src/components/dialog/DialogBackdropClose.svelte create mode 100644 web/src/components/dialog/DialogButtons.svelte create mode 100644 web/src/components/dialog/PickerDialog.svelte create mode 100644 web/src/components/dialog/PickerItem.svelte create mode 100644 web/src/lib/download.ts",
"patch_text_b64": "From 66bac03e3078e4e781d2d3903c05ad66a883a354 Mon Sep 17 00:00:00 2001
From: wukko <me@wukko.me>
Date: Mon, 22 Jul 2024 14:33:43 +0600
Subject: [PATCH] web/dialogs: add picker dialog & clean up small dialog

---
 web/i18n/en/a11y/dialog.json                  |   3 +
 web/i18n/en/dialog.json                       |   9 +-
 .../dialog/DialogBackdropClose.svelte         |  18 ++
 .../components/dialog/DialogButtons.svelte    |  61 +++++
 web/src/components/dialog/DialogHolder.svelte | 107 +++++++-
 web/src/components/dialog/PickerDialog.svelte | 231 ++++++++++++++++++
 web/src/components/dialog/PickerItem.svelte   |  65 +++++
 web/src/components/dialog/SmallDialog.svelte  | 176 ++-----------
 .../save/buttons/DownloadButton.svelte        |  93 ++++---
 web/src/lib/download.ts                       |   9 +
 web/src/lib/types/dialog.ts                   |  11 +-
 11 files changed, 584 insertions(+), 199 deletions(-)
 create mode 100644 web/i18n/en/a11y/dialog.json
 create mode 100644 web/src/components/dialog/DialogBackdropClose.svelte
 create mode 100644 web/src/components/dialog/DialogButtons.svelte
 create mode 100644 web/src/components/dialog/PickerDialog.svelte
 create mode 100644 web/src/components/dialog/PickerItem.svelte
 create mode 100644 web/src/lib/download.ts

diff --git a/web/i18n/en/a11y/dialog.json b/web/i18n/en/a11y/dialog.json
new file mode 100644
index 000000000..451d74cfc
--- /dev/null
+++ b/web/i18n/en/a11y/dialog.json
@@ -0,0 +1,3 @@
+{
+    "picker.item.generic": "media thumbnail"
+}
diff --git a/web/i18n/en/dialog.json b/web/i18n/en/dialog.json
index b57fae5b6..bfe30bec2 100644
--- a/web/i18n/en/dialog.json
+++ b/web/i18n/en/dialog.json
@@ -2,7 +2,14 @@
     "button.gotit": "got it",
     "button.cancel": "cancel",
     "button.reset": "reset",
+    "button.done": "done",
+    "button.downloadAudio": "download audio",
 
     "reset.title": "reset all settings?",
-    "reset.body": "are you sure you want to reset all settings? this action is immediate and irreversible."
+    "reset.body": "are you sure you want to reset all settings? this action is immediate and irreversible.",
+
+    "picker.title": "select what to save",
+    "picker.description.desktop": "click an item to save it. images can also be saved via the right click menu.",
+    "picker.description.phone": "press an item to save it. images can also be saved with a long press.",
+    "picker.description.ios": "press an item to save it with a shortcut. images can also be saved with a long press."
 }
diff --git a/web/src/components/dialog/DialogBackdropClose.svelte b/web/src/components/dialog/DialogBackdropClose.svelte
new file mode 100644
index 000000000..7c290533d
--- /dev/null
+++ b/web/src/components/dialog/DialogBackdropClose.svelte
@@ -0,0 +1,18 @@
+<script lang="ts">
+    export let closeFunc: () => void;
+</script>
+
+<div
+    id="dialog-backdrop-close"
+    aria-hidden="true"
+    on:click={() => closeFunc()}
+></div>
+
+<style>
+    #dialog-backdrop-close {
+        position: inherit;
+        height: 100%;
+        width: 100%;
+        z-index: -1;
+    }
+</style>
diff --git a/web/src/components/dialog/DialogButtons.svelte b/web/src/components/dialog/DialogButtons.svelte
new file mode 100644
index 000000000..5f086a78c
--- /dev/null
+++ b/web/src/components/dialog/DialogButtons.svelte
@@ -0,0 +1,61 @@
+<script lang="ts">
+    import type { DialogButton } from "$lib/types/dialog";
+
+    export let buttons: DialogButton[];
+    export let closeFunc: () => void;
+</script>
+
+<div class="popup-buttons">
+    {#each buttons as button}
+        <button
+            class="button popup-button {button.color}"
+            class:active={button.main}
+            on:click={async () => {
+                await button.action();
+                closeFunc();
+            }}
+        >
+            {button.text}
+        </button>
+    {/each}
+</div>
+
+<style>
+    .popup-buttons {
+        display: flex;
+        flex-direction: row;
+        width: 100%;
+        gap: calc(var(--padding) / 2);
+        overflow: scroll;
+        border-radius: var(--border-radius);
+        min-height: 40px;
+    }
+
+    .popup-button {
+        width: 100%;
+        height: 40px;
+    }
+
+    .popup-button.red {
+        background-color: var(--red);
+        color: var(--white);
+    }
+
+    .popup-button:not(.active) {
+        background-color: var(--button-elevated);
+    }
+
+    .popup-button:not(.active):active {
+        background-color: var(--button-elevated-hover);
+    }
+
+    .popup-button:not(:focus-visible) {
+        box-shadow: none;
+    }
+
+    @media (hover: hover) {
+        .popup-button:not(.active):hover {
+            background-color: var(--button-elevated-hover);
+        }
+    }
+</style>
diff --git a/web/src/components/dialog/DialogHolder.svelte b/web/src/components/dialog/DialogHolder.svelte
index 7a9550fe5..61503fcda 100644
--- a/web/src/components/dialog/DialogHolder.svelte
+++ b/web/src/components/dialog/DialogHolder.svelte
@@ -1,7 +1,9 @@
 <script lang="ts">
-    import SmallDialog from "$components/dialog/SmallDialog.svelte";
     import dialogs from "$lib/dialogs";
 
+    import SmallDialog from "$components/dialog/SmallDialog.svelte";
+    import PickerDialog from "$components/dialog/PickerDialog.svelte";
+
     $: backdropVisible = $dialogs.length > 0;
 </script>
 
@@ -18,11 +20,56 @@
                 buttons={dialog.buttons}
             />
         {/if}
+
+        {#if dialog.type === "picker"}
+            <PickerDialog
+                id={dialog.id}
+                items={dialog.items}
+                buttons={dialog.buttons}
+            />
+        {/if}
     {/each}
     <div id="dialog-backdrop" class:visible={backdropVisible}></div>
 </div>
 
 <style>
+    :global(dialog) {
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+        background: none;
+
+        max-height: 100%;
+        max-width: 100%;
+        height: 100%;
+        width: 100%;
+        margin: 0;
+        padding: 0;
+        border: none;
+        pointer-events: all;
+
+        inset-inline-start: unset;
+        inset-inline-end: unset;
+
+        overflow: hidden;
+    }
+
+    :global(dialog:modal) {
+        inset-block-start: 0;
+        inset-block-end: 0;
+    }
+
+    :global(dialog:modal::backdrop) {
+        display: none;
+    }
+
+    @media screen and (max-width: 535px) {
+        :global(dialog) {
+            justify-content: end;
+        }
+    }
+
     #dialog-holder {
         position: absolute;
         padding-top: env(safe-area-inset-bottom);
@@ -60,4 +107,62 @@
         backdrop-filter: none !important;
         -webkit-backdrop-filter: none !important;
     }
+
+    :global(.open .dialog-body) {
+        animation: modal-in 0.35s;
+    }
+
+    :global(.closing .dialog-body) {
+        animation: modal-out 0.15s;
+        opacity: 0;
+    }
+
+    @media screen and (max-width: 535px) {
+        :global(.open .dialog-body) {
+            animation: modal-in-mobile 0.4s;
+        }
+    }
+
+    @keyframes modal-in {
+        from {
+            transform: scale(0.8);
+            opacity: 0;
+        }
+        30% {
+            opacity: 1;
+        }
+        50% {
+            transform: scale(1.005);
+        }
+        100% {
+            transform: scale(1);
+        }
+    }
+
+    @keyframes modal-out {
+        from {
+            opacity: 1;
+        }
+        to {
+            opacity: 0;
+            transform: scale(0.9);
+            visibility: hidden;
+        }
+    }
+
+    @keyframes modal-in-mobile {
+        from {
+            transform: translateY(200px);
+            opacity: 0;
+        }
+        30% {
+            opacity: 1;
+        }
+        50% {
+            transform: translateY(-5px);
+        }
+        100% {
+            transform: translateY(0px);
+        }
+    }
 </style>
diff --git a/web/src/components/dialog/PickerDialog.svelte b/web/src/components/dialog/PickerDialog.svelte
new file mode 100644
index 000000000..5c5c0d61e
--- /dev/null
+++ b/web/src/components/dialog/PickerDialog.svelte
@@ -0,0 +1,231 @@
+<script lang="ts">
+    import { tick } from "svelte";
+    import { device } from "$lib/device";
+    import { killDialog } from "$lib/dialogs";
+    import { t } from "$lib/i18n/translations";
+
+    import type { Optional } from "$lib/types/generic";
+    import type { DialogButton } from "$lib/types/dialog";
+    import type { DialogPickerItem } from "$lib/types/dialog";
+
+    import PickerItem from "$components/dialog/PickerItem.svelte";
+    import DialogButtons from "$components/dialog/DialogButtons.svelte";
+    import DialogBackdropClose from "$components/dialog/DialogBackdropClose.svelte";
+
+    import IconBoxMultiple from "@tabler/icons-svelte/IconBoxMultiple.svelte";
+
+    export let id: string;
+    export let items: Optional<DialogPickerItem[]>;
+    export let buttons: Optional<DialogButton[]>;
+
+    let dialogDescription = "dialog.picker.description.";
+
+    if (device.is.iOS) {
+        dialogDescription += "ios";
+    } else if (device.is.mobile) {
+        dialogDescription += "mobile";
+    } else {
+        dialogDescription += "desktop";
+    }
+
+    let dialogParent: HTMLDialogElement;
+
+    let closing = false;
+    let open = false;
+
+    const close = () => {
+        if (dialogParent) {
+            closing = true;
+            open = false;
+            setTimeout(() => {
+                dialogParent.close();
+                killDialog();
+            }, 150);
+        }
+    };
+
+    $: if (dialogParent) {
+        dialogParent.showModal();
+        tick().then(() => {
+            open = true;
+        });
+    }
+</script>
+
+<dialog
+    id="dialog-{id}"
+    bind:this={dialogParent}
+    class:closing
+    class:open
+    class:three-columns={items && items.length <= 3}
+>
+    <div class="dialog-body picker-dialog">
+        <div class="popup-header">
+            <div class="popup-title-container">
+                <IconBoxMultiple />
+                <h2 class="popup-title" tabindex="-1">
+                    {$t("dialog.picker.title")}
+                </h2>
+            </div>
+            <div class="subtext popup-description">
+                {$t(dialogDescription)}
+            </div>
+        </div>
+        <div class="picker-body">
+            {#if items}
+                {#each items as item}
+                    <PickerItem {item} />
+                {/each}
+            {/if}
+        </div>
+        {#if buttons}
+            <DialogButtons {buttons} closeFunc={close} />
+        {/if}
+    </div>
+
+    <DialogBackdropClose closeFunc={close} />
+</dialog>
+
+<style>
+    .picker-dialog {
+        --dialog-padding: 18px;
+        --picker-item-size: 120px;
+
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        gap: var(--padding);
+        max-height: calc(
+            90% - env(safe-area-inset-bottom) - env(safe-area-inset-top)
+        );
+
+        width: auto;
+        background: var(--popup-bg);
+        box-shadow:
+            0 0 0 2px var(--popup-stroke) inset,
+            0 0 60px 10px var(--popup-bg);
+        padding: var(--dialog-padding);
+        position: relative;
+        will-change: transform;
+
+        border-radius: 29px;
+    }
+
+    .popup-header {
+        display: flex;
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 3px;
+        max-width: calc(var(--picker-item-size) * 4);
+    }
+
+    .popup-title-container {
+        display: flex;
+        flex-direction: row;
+        align-items: center;
+        gap: calc(var(--padding) / 2);
+        color: var(--secondary);
+    }
+
+    .popup-title-container :global(svg) {
+        height: 21px;
+        width: 21px;
+    }
+
+    .popup-title {
+        font-size: 18px;
+        line-height: 1.1;
+    }
+
+    .popup-description {
+        font-size: 13px;
+        padding: 0;
+    }
+
+    .popup-title:focus-visible {
+        box-shadow: none !important;
+    }
+
+    .picker-body {
+        overflow-y: scroll;
+        display: grid;
+        justify-items: center;
+        grid-template-columns: 1fr 1fr 1fr 1fr;
+    }
+
+    .three-columns .picker-body {
+        grid-template-columns: 1fr 1fr 1fr;
+    }
+
+    .three-columns .popup-header {
+        max-width: calc(var(--picker-item-size) * 3);
+    }
+
+    :global(.picker-item) {
+        width: var(--picker-item-size);
+        height: var(--picker-item-size);
+    }
+
+    @media screen and (max-width: 535px) {
+        .picker-dialog {
+            margin-bottom: calc(
+                var(--dialog-padding) + env(safe-area-inset-bottom)
+            );
+            box-shadow: 0 0 0 2px var(--popup-stroke) inset;
+        }
+
+        .picker-body {
+            grid-template-columns: 1fr 1fr 1fr;
+        }
+
+        .popup-header {
+            max-width: calc(var(--picker-item-size) * 3);
+        }
+    }
+
+    @media screen and (max-width: 400px) {
+        .picker-dialog {
+            --picker-item-size: 115px;
+        }
+    }
+
+    @media screen and (max-width: 380px) {
+        .picker-dialog {
+            --picker-item-size: 110px;
+        }
+    }
+
+    @media screen and (max-width: 365px) {
+        .picker-dialog {
+            --picker-item-size: 105px;
+        }
+    }
+
+    @media screen and (max-width: 350px) {
+        .picker-dialog {
+            --picker-item-size: 100px;
+        }
+    }
+
+    @media screen and (max-width: 335px) {
+        .picker-body,
+        .three-columns .picker-body {
+            grid-template-columns: 1fr 1fr;
+        }
+
+        .popup-header {
+            max-width: calc(var(--picker-item-size) * 3);
+        }
+    }
+
+    @media screen and (max-width: 255px) {
+        .picker-dialog {
+            --picker-item-size: 120px;
+        }
+
+        .picker-body,
+        .three-columns .picker-body {
+            grid-template-columns: 1fr;
+        }
+    }
+</style>
diff --git a/web/src/components/dialog/PickerItem.svelte b/web/src/components/dialog/PickerItem.svelte
new file mode 100644
index 000000000..b56abcc98
--- /dev/null
+++ b/web/src/components/dialog/PickerItem.svelte
@@ -0,0 +1,65 @@
+<script lang="ts">
+    import { t } from "$lib/i18n/translations";
+
+    import { downloadFile } from "$lib/download";
+    import type { DialogPickerItem } from "$lib/types/dialog";
+
+    import Skeleton from "$components/misc/Skeleton.svelte";
+
+    export let item: DialogPickerItem;
+
+    let imageLoaded = false;
+</script>
+
+<button
+    class="picker-item"
+    on:click={() => {
+        downloadFile(item.url);
+    }}
+>
+    <img
+        class="picker-image"
+        src={item.thumb ? item.thumb : item.url}
+        class:loading={!imageLoaded}
+        on:load={() => (imageLoaded = true)}
+        alt={$t("a11y.dialog.picker.item.generic")}
+        height="100"
+        width="100"
+    />
+    <Skeleton class="picker-image" hidden={imageLoaded} />
+</button>
+
+<style>
+    .picker-item {
+        background: none;
+        padding: 2px;
+        box-shadow: none;
+        border-radius: calc(var(--border-radius) / 2 + 2px);
+    }
+
+    :global(.picker-image) {
+        display: block;
+        width: 100%;
+        height: 100%;
+
+        aspect-ratio: 1/1;
+        pointer-events: all;
+
+        object-fit: cover;
+        border-radius: calc(var(--border-radius) / 2);
+    }
+
+    .picker-image.loading {
+        display: none;
+    }
+
+    .picker-item:active .picker-image {
+        opacity: 0.8;
+    }
+
+    @media (hover: hover) {
+        .picker-item:hover .picker-image {
+            opacity: 0.8;
+        }
+    }
+</style>
diff --git a/web/src/components/dialog/SmallDialog.svelte b/web/src/components/dialog/SmallDialog.svelte
index 3a4cdddfd..b2951d627 100644
--- a/web/src/components/dialog/SmallDialog.svelte
+++ b/web/src/components/dialog/SmallDialog.svelte
@@ -1,12 +1,14 @@
 <script lang="ts">
     import { tick } from "svelte";
-
     import { killDialog } from "$lib/dialogs";
-    import type { DialogButton, SmallDialogIcons } from "$lib/types/dialog";
-    import type { MeowbaltEmotions } from "$lib/types/meowbalt";
+
     import type { Optional } from "$lib/types/generic";
+    import type { MeowbaltEmotions } from "$lib/types/meowbalt";
+    import type { DialogButton, SmallDialogIcons } from "$lib/types/dialog";
 
     import Meowbalt from "$components/misc/Meowbalt.svelte";
+    import DialogButtons from "$components/dialog/DialogButtons.svelte";
+    import DialogBackdropClose from "$components/dialog/DialogBackdropClose.svelte";
 
     import IconAlertTriangle from "@tabler/icons-svelte/IconAlertTriangle.svelte";
 
@@ -16,7 +18,7 @@
     export let title: string = "";
     export let bodyText: string = "";
     export let bodySubText: string = "";
-    export let buttons: DialogButton[];
+    export let buttons: Optional<DialogButton[]>;
 
     let dialogParent: HTMLDialogElement;
 
@@ -58,7 +60,7 @@
                         </div>
                     {/if}
                     {#if title}
-                        <h2 id="popup-title" tabindex="-1">{title}</h2>
+                        <h2 class="popup-title" tabindex="-1">{title}</h2>
                     {/if}
                 </div>
             {/if}
@@ -69,57 +71,15 @@
                 <div class="subtext">{bodySubText}</div>
             {/if}
         </div>
-        <div class="popup-buttons">
-            {#each buttons as button}
-                <button
-                    class="button popup-button {button.color}"
-                    class:active={button.main}
-                    on:click={async () => {
-                        await button.action();
-                        close();
-                    }}
-                >
-                    {button.text}
-                </button>
-            {/each}
-        </div>
+        {#if buttons}
+            <DialogButtons {buttons} closeFunc={close} />
+        {/if}
     </div>
 
-    <div id="dialog-backdrop-close" aria-hidden="true" on:click={() => close()}></div>
+    <DialogBackdropClose closeFunc={close} />
 </dialog>
 
 <style>
-    dialog {
-        display: flex;
-        flex-direction: column;
-        justify-content: center;
-        align-items: center;
-        background: none;
-
-        max-height: 100%;
-        max-width: 100%;
-        height: 100%;
-        width: 100%;
-        margin: 0;
-        padding: 0;
-        border: none;
-        pointer-events: all;
-
-        inset-inline-start: unset;
-        inset-inline-end: unset;
-
-        overflow: hidden;
-    }
-
-    dialog:modal {
-        inset-block-start: 0;
-        inset-block-end: 0;
-    }
-
-    dialog:modal::backdrop {
-        display: none;
-    }
-
     .small-dialog,
     .popup-body {
         display: flex;
@@ -132,34 +92,25 @@
     }
 
     .small-dialog {
-        --small-dialog-padding: 18px;
+        --dialog-padding: 18px;
 
         align-items: center;
         text-align: center;
         max-width: 340px;
         width: calc(
-            100% - var(--padding) * 2 - var(--small-dialog-padding) * 2
+            100% - var(--padding) * 2 - var(--dialog-padding) * 2
         );
         background: var(--popup-bg);
         box-shadow:
             0 0 0 2px var(--popup-stroke) inset,
             0 0 60px 10px var(--popup-bg);
-        padding: var(--small-dialog-padding);
+        padding: var(--dialog-padding);
         margin: var(--padding);
         border-radius: 29px;
         position: relative;
         will-change: transform;
     }
 
-    .open .small-dialog {
-        animation: modal-in 0.35s;
-    }
-
-    .closing .small-dialog {
-        animation: modal-out 0.15s;
-        opacity: 0;
-    }
-
     .small-dialog.meowbalt-visible {
         padding-top: calc(var(--padding) * 4);
     }
@@ -169,7 +120,7 @@
         top: -120px;
     }
 
-    .popup-header h2 {
+    .popup-title {
         color: var(--secondary);
         font-size: 19px;
     }
@@ -191,109 +142,14 @@
     }
 
     .body-text:focus-visible,
-    h2:focus-visible {
+    .popup-title:focus-visible {
         box-shadow: none !important;
     }
 
-    .popup-buttons {
-        display: flex;
-        flex-direction: row;
-        width: 100%;
-        gap: calc(var(--padding) / 2);
-        overflow: scroll;
-        border-radius: var(--border-radius);
-    }
-
-    .popup-button {
-        width: 100%;
-        height: 40px;
-    }
-
-    .popup-button.red {
-        background-color: var(--red);
-        color: var(--white);
-    }
-
-    .popup-button:not(.active) {
-        background-color: var(--button-elevated);
-    }
-
-    .popup-button:not(.active):active {
-        background-color: var(--button-elevated-hover);
-    }
-
-    .popup-button:not(:focus-visible) {
-        box-shadow: none;
-    }
-
-    @media (hover: hover) {
-        .popup-button:not(.active):hover {
-            background-color: var(--button-elevated-hover);
-        }
-    }
-
-    #dialog-backdrop-close {
-        position: inherit;
-        height: 100%;
-        width: 100%;
-        z-index: -1;
-    }
-
-    @keyframes modal-in {
-        from {
-            transform: scale(0.8);
-            opacity: 0;
-        }
-        30% {
-            opacity: 1;
-        }
-        50% {
-            transform: scale(1.005);
-        }
-        100% {
-            transform: scale(1);
-        }
-    }
-
-    @keyframes modal-out {
-        from {
-            opacity: 1;
-        }
-        to {
-            opacity: 0;
-            transform: scale(0.9);
-            visibility: hidden;
-        }
-    }
-
     @media screen and (max-width: 535px) {
-        dialog {
-            justify-content: end;
-        }
-
         .small-dialog {
             margin-bottom: calc(var(--padding) + env(safe-area-inset-bottom));
             box-shadow: 0 0 0 2px var(--popup-stroke) inset;
         }
-
-        .open .small-dialog {
-            animation: modal-in-mobile 0.4s;
-        }
-
-        @keyframes modal-in-mobile {
-            from {
-                transform: translateY(200px);
-                opacity: 0;
-            }
-            30% {
-                opacity: 1;
-            }
-            50% {
-                transform: translateY(-5px);
-            }
-            100% {
-                transform: translateY(0px);
-            }
-        }
     }
 </style>
diff --git a/web/src/components/save/buttons/DownloadButton.svelte b/web/src/components/save/buttons/DownloadButton.svelte
index 55657ddf5..fe5f26a0c 100644
--- a/web/src/components/save/buttons/DownloadButton.svelte
+++ b/web/src/components/save/buttons/DownloadButton.svelte
@@ -2,49 +2,50 @@
     import "@fontsource-variable/noto-sans-mono";
 
     import API from "$lib/api";
-    import { device } from "$lib/device";
-
     import { t } from "$lib/i18n/translations";
-
     import { createDialog } from "$lib/dialogs";
+    import { downloadFile } from "$lib/download";
+
     import type { DialogInfo } from "$lib/types/dialog";
 
     export let url: string;
     export let isDisabled = false;
 
     $: buttonText = ">>";
-    $: buttonAltText = $t('a11y.save.download');
+    $: buttonAltText = $t("a11y.save.download");
     $: isDisabled = false;
 
     let defaultErrorPopup: DialogInfo = {
         id: "save-error",
         type: "small",
         meowbalt: "error",
-        buttons: [{
-            text: $t("dialog.button.gotit"),
-            main: true,
-            action: () => {},
-        }]
-    }
+        buttons: [
+            {
+                text: $t("dialog.button.gotit"),
+                main: true,
+                action: () => {},
+            },
+        ],
+    };
 
     const changeDownloadButton = (state: string) => {
         isDisabled = true;
         switch (state) {
             case "think":
                 buttonText = "...";
-                buttonAltText = $t('a11y.save.downloadThink');
+                buttonAltText = $t("a11y.save.downloadThink");
                 break;
             case "check":
                 buttonText = "..?";
-                buttonAltText = $t('a11y.save.downloadCheck');
+                buttonAltText = $t("a11y.save.downloadCheck");
                 break;
             case "done":
                 buttonText = ">>>";
-                buttonAltText = $t('a11y.save.downloadDone');
+                buttonAltText = $t("a11y.save.downloadDone");
                 break;
             case "error":
                 buttonText = "!!";
-                buttonAltText = $t('a11y.save.downloadError');
+                buttonAltText = $t("a11y.save.downloadError");
                 break;
         }
     };
@@ -53,18 +54,10 @@
         setTimeout(() => {
             buttonText = ">>";
             isDisabled = false;
-            buttonAltText = $t('a11y.save.download');
+            buttonAltText = $t("a11y.save.download");
         }, 2500);
     };
 
-    const downloadFile = (url: string) => {
-        if (device.is.iOS) {
-            return navigator?.share({ url }).catch(() => {});
-        } else {
-            return window.open(url, "_blank");
-        }
-    };
-
     // alerts are temporary, we don't have an error popup yet >_<
     export const download = async (link: string) => {
         changeDownloadButton("think");
@@ -76,9 +69,9 @@
             restoreDownloadButton();
 
             return createDialog({
-                ...defaultErrorPopup as DialogInfo,
-                bodyText: "couldn't access the api"
-            })
+                ...(defaultErrorPopup as DialogInfo),
+                bodyText: "couldn't access the api",
+            });
         }
 
         if (response.status === "error" || response.status === "rate-limit") {
@@ -86,9 +79,9 @@
             restoreDownloadButton();
 
             return createDialog({
-                ...defaultErrorPopup as DialogInfo,
-                bodyText: response.text
-            })
+                ...(defaultErrorPopup as DialogInfo),
+                bodyText: response.text,
+            });
         }
 
         if (response.status === "redirect") {
@@ -113,19 +106,49 @@
                 restoreDownloadButton();
 
                 return createDialog({
-                    ...defaultErrorPopup as DialogInfo,
-                    bodyText: "couldn't probe the stream"
-                })
+                    ...(defaultErrorPopup as DialogInfo),
+                    bodyText: "couldn't probe the stream",
+                });
             }
         }
 
+        if (response.status === "picker") {
+            restoreDownloadButton();
+
+            let pickerButtons = [
+                {
+                    text: $t("dialog.button.done"),
+                    main: true,
+                    action: () => {},
+                },
+            ];
+
+            if (response.audio) {
+                const pickerAudio = response.audio;
+                pickerButtons.unshift({
+                    text: $t("dialog.button.downloadAudio"),
+                    main: false,
+                    action: () => {
+                        downloadFile(pickerAudio);
+                    },
+                });
+            }
+
+            return createDialog({
+                id: "download-picker",
+                type: "picker",
+                items: response.picker,
+                buttons: pickerButtons,
+            });
+        }
+
         changeDownloadButton("error");
         restoreDownloadButton();
 
         return createDialog({
-            ...defaultErrorPopup as DialogInfo,
-            bodyText: "unknown/unsupported status"
-        })
+            ...(defaultErrorPopup as DialogInfo),
+            bodyText: "unknown/unsupported status",
+        });
     };
 </script>
 
diff --git a/web/src/lib/download.ts b/web/src/lib/download.ts
new file mode 100644
index 000000000..e08320efc
--- /dev/null
+++ b/web/src/lib/download.ts
@@ -0,0 +1,9 @@
+import { device } from "$lib/device";
+
+export const downloadFile = (url: string) => {
+    if (device.is.iOS) {
+        return navigator?.share({ url }).catch(() => {});
+    } else {
+        return window.open(url, "_blank");
+    }
+};
diff --git a/web/src/lib/types/dialog.ts b/web/src/lib/types/dialog.ts
index 6630fd6fb..f6d2439d6 100644
--- a/web/src/lib/types/dialog.ts
+++ b/web/src/lib/types/dialog.ts
@@ -9,13 +9,20 @@ export type DialogButton = {
 
 export type SmallDialogIcons = "warn-red";
 
+export type DialogPickerItem = {
+    type?: 'photo' | 'video',
+    url: string,
+    thumb?: string,
+}
+
 export type DialogInfo = {
     id: string,
-    type: "small",
+    type: "small" | "picker",
     meowbalt?: MeowbaltEmotions,
     icon?: SmallDialogIcons,
     title?: string,
     bodyText?: string,
     bodySubText?: string,
-    buttons: DialogButton[],
+    buttons?: DialogButton[],
+    items?: DialogPickerItem[],
 }",
"url": "https://github.com/imputnet/cobalt/commit/66bac03e3078e4e781d2d3903c05ad66a883a354.patch"
},
{
"commit_message": "[PATCH] web: generate `_headers` & add `Content-Security-Policy` header web/src/routes/_headers/+server.ts | 28 ++++++++++++++++++++++++++++ web/static/_headers | 3 --- 2 files changed, 28 insertions(+), 3 deletions(-) create mode 100644 web/src/routes/_headers/+server.ts delete mode 100644 web/static/_headers",
"patch_text_b64": "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",
"url": "https://github.com/imputnet/cobalt/commit/97977efabd92375f270d1818f38de3b0682c2f19.patch"
},
{
"commit_message": "[PATCH] web/download: don't try to open non-https links web/src/lib/download.ts | 4 ++++ 1 file changed, 4 insertions(+)",
"patch_text_b64": "RnJvbSBjNGJlMWQzYTM3YjBkZWI2YjYwODdlYzdhODE1MjYyYWM5NDJkYWYxIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBqaiA8bG9nQHJpc2V1cC5uZXQ+CkRhdGU6IFdlZCwgMzAgT2N0IDIwMjQgMTM6MTc6MzggKzAwMDAKU3ViamVjdDogW1BBVENIXSB3ZWIvZG93bmxvYWQ6IGRvbid0IHRyeSB0byBvcGVuIG5vbi1odHRwcyBsaW5rcwoKLS0tCiB3ZWIvc3JjL2xpYi9kb3dubG9hZC50cyB8IDQgKysrKwogMSBmaWxlIGNoYW5nZWQsIDQgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL3dlYi9zcmMvbGliL2Rvd25sb2FkLnRzIGIvd2ViL3NyYy9saWIvZG93bmxvYWQudHMKaW5kZXggOWNmYmY2MzBiLi43YTEyNmE5MmYgMTAwNjQ0Ci0tLSBhL3dlYi9zcmMvbGliL2Rvd25sb2FkLnRzCisrKyBiL3dlYi9zcmMvbGliL2Rvd25sb2FkLnRzCkBAIC01Niw2ICs1NiwxMCBAQCBleHBvcnQgY29uc3Qgc2hhcmVGaWxlID0gYXN5bmMgKGZpbGU6IEZpbGUpID0+IHsKIH0KIAogZXhwb3J0IGNvbnN0IG9wZW5VUkwgPSAodXJsOiBzdHJpbmcpID0+IHsKKyAgICBpZiAoIVsnaHR0cDonLCAnaHR0cHM6J10uaW5jbHVkZXMobmV3IFVSTCh1cmwpLnByb3RvY29sKSkgeworICAgICAgICByZXR1cm4gYWxlcnQoJ2Vycm9yOiBpbnZhbGlkIHVybCEnKTsKKyAgICB9CisKICAgICBjb25zdCBvcGVuID0gd2luZG93Lm9wZW4odXJsLCAiX2JsYW5rIik7CiAKICAgICAvKiBpZiBuZXcgdGFiIGdvdCBibG9ja2VkIGJ5IHVzZXIgYWdlbnQsIHNob3cgYSBzYXZpbmcgZGlhbG9nICov",
"url": "https://github.com/imputnet/cobalt/commit/c4be1d3a37b0deb6b6087ec7a815262ac942daf1.patch"
}
] |
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
GHSA-2vv7-7crh-jr74
| null |
[
{
"commit_message": "[PATCH] ALSA: control: Fix replacing user controls There are two issues with the current implementation for replacing user controls. The first is that the code does not check if the control is actually a user control and neither does it check if the control is owned by the process that tries to remove it. That allows userspace applications to remove arbitrary controls, which can cause a user after free if a for example a driver does not expect a control to be removed from under its feed. The second issue is that on one hand when a control is replaced the user_ctl_count limit is not checked and on the other hand the user_ctl_count is increased (even though the number of user controls does not change). This allows userspace, once the user_ctl_count limit as been reached, to repeatedly replace a control until user_ctl_count overflows. Once that happens new controls can be added effectively bypassing the user_ctl_count limit. Both issues can be fixed by instead of open-coding the removal of the control that is to be replaced to use snd_ctl_remove_user_ctl(). This function does proper permission checks as well as decrements user_ctl_count after the control has been removed. Note that by using snd_ctl_remove_user_ctl() the check which returns -EBUSY at beginning of the function if the control already exists is removed. This is not a problem though since the check is quite useless, because the lock that is protecting the control list is released between the check and before adding the new control to the list, which means that it is possible that a different control with the same settings is added to the list after the check. Luckily there is another check that is done while holding the lock in snd_ctl_add(), so we'll rely on that to make sure that the same control is not added twice. Signed-off-by: Lars-Peter Clausen <[email protected]> Acked-by: Jaroslav Kysela <[email protected]> Cc: <[email protected]> Signed-off-by: Takashi Iwai <[email protected]> sound/core/control.c | 25 +++++++++---------------- 1 file changed, 9 insertions(+), 16 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/torvalds/linux/commit/82262a46627bebb0febcc26664746c25cef08563.patch"
}
] | null |
|
GHSA-r78q-qgx6-64pp
|
Memory usage graphs accessible to anyone with Overall/Read
| null |
[
{
"commit_message": "[PATCH] [SECURITY-1650] core/src/main/java/hudson/diagnosis/MemoryUsageMonitor.java | 2 ++ 1 file changed, 2 insertions(+)",
"patch_text_b64": "RnJvbSA3ZDQ0ODM2ZmFkMGY0OTM0MWFlMmE2MWRlMDZkYmI1NTYwMTRhMmRmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5pZWwgQmVjayA8ZGFuaWVsLWJlY2tAdXNlcnMubm9yZXBseS5naXRodWIuY29tPgpEYXRlOiBUdWUsIDE0IEphbiAyMDIwIDEyOjA4OjUwICswMTAwClN1YmplY3Q6IFtQQVRDSF0gW1NFQ1VSSVRZLTE2NTBdCgotLS0KIGNvcmUvc3JjL21haW4vamF2YS9odWRzb24vZGlhZ25vc2lzL01lbW9yeVVzYWdlTW9uaXRvci5qYXZhIHwgMiArKwogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2NvcmUvc3JjL21haW4vamF2YS9odWRzb24vZGlhZ25vc2lzL01lbW9yeVVzYWdlTW9uaXRvci5qYXZhIGIvY29yZS9zcmMvbWFpbi9qYXZhL2h1ZHNvbi9kaWFnbm9zaXMvTWVtb3J5VXNhZ2VNb25pdG9yLmphdmEKaW5kZXggMWJhNjQ4ZWIzOGZlLi5hOTUzY2MzNmEyMTQgMTAwNjQ0Ci0tLSBhL2NvcmUvc3JjL21haW4vamF2YS9odWRzb24vZGlhZ25vc2lzL01lbW9yeVVzYWdlTW9uaXRvci5qYXZhCisrKyBiL2NvcmUvc3JjL21haW4vamF2YS9odWRzb24vZGlhZ25vc2lzL01lbW9yeVVzYWdlTW9uaXRvci5qYXZhCkBAIC0zOSw2ICszOSw3IEBACiBpbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKIGltcG9ydCBqYXZhLmlvLklPRXhjZXB0aW9uOwogCitpbXBvcnQgamVua2lucy5tb2RlbC5KZW5raW5zOwogaW1wb3J0IG9yZy5qZW5raW5zY2kuU3ltYm9sOwogaW1wb3J0IG9yZy5rb2hzdWtlLnN0YXBsZXIuUXVlcnlQYXJhbWV0ZXI7CiAKQEAgLTEwMiw2ICsxMDMsNyBAQCBwcml2YXRlIHZvaWQgdXBkYXRlKCkgewogICAgICAgICAgKiBHZW5lcmF0ZXMgdGhlIG1lbW9yeSB1c2FnZSBzdGF0aXN0aWNzIGdyYXBoLgogICAgICAgICAgKi8KICAgICAgICAgcHVibGljIFRyZW5kQ2hhcnQgZG9HcmFwaChAUXVlcnlQYXJhbWV0ZXIgU3RyaW5nIHR5cGUpIHRocm93cyBJT0V4Y2VwdGlvbiB7CisgICAgICAgICAgICBKZW5raW5zLmdldCgpLmNoZWNrUGVybWlzc2lvbihKZW5raW5zLkFETUlOSVNURVIpOwogICAgICAgICAgICAgcmV0dXJuIE11bHRpU3RhZ2VUaW1lU2VyaWVzLmNyZWF0ZVRyZW5kQ2hhcnQoVGltZVNjYWxlLnBhcnNlKHR5cGUpLHVzZWQsbWF4KTsKICAgICAgICAgfQogICAgIH0=",
"url": "https://github.com/jenkinsci/jenkins/commit/7d44836fad0f49341ae2a61de06dbb556014a2df.patch"
}
] | null |
CVE-2023-42465
|
Sudo before 1.9.15 might allow row hammer attacks (for authentication bypass or privilege escalation) because application logic sometimes is based on not equaling an error value (instead of equaling a success value), and because the values do not resist flips of a single bit.
|
[
{
"commit_message": "[PATCH] Try to make sudo less vulnerable to ROWHAMMER attacks. We now use ROWHAMMER-resistent values for ALLOW, DENY, AUTH_SUCCESS, AUTH_FAILURE, AUTH_ERROR and AUTH_NONINTERACTIVE. In addition, we explicitly test for expected values instead of using a negated test against an error value. In the parser match functions this means explicitly checking for ALLOW or DENY instead of accepting anything that is not set to UNSPEC. Thanks to Andrew J. Adiletta, M. Caner Tol, Yarkin Doroz, and Berk Sunar, all affiliated with the Vernam Applied Cryptography and Cybersecurity Lab at Worcester Polytechnic Institute, for the report. Paper preprint: https://arxiv.org/abs/2309.02545 plugins/sudoers/auth/passwd.c | 27 ++++++++++------- plugins/sudoers/auth/sudo_auth.c | 51 ++++++++++++++++++++++---------- plugins/sudoers/auth/sudo_auth.h | 12 ++++---- plugins/sudoers/lookup.c | 12 ++++---- plugins/sudoers/match.c | 25 ++++++++-------- plugins/sudoers/parse.h | 23 ++++++++++---- 6 files changed, 96 insertions(+), 54 deletions(-)",
"patch_text_b64": "From 7873f8334c8d31031f8cfa83bd97ac6029309e4f Mon Sep 17 00:00:00 2001
From: "Todd C. Miller" <Todd.Miller@sudo.ws>
Date: Sat, 9 Sep 2023 14:07:04 -0600
Subject: [PATCH] Try to make sudo less vulnerable to ROWHAMMER attacks.

We now use ROWHAMMER-resistent values for ALLOW, DENY, AUTH_SUCCESS,
AUTH_FAILURE, AUTH_ERROR and AUTH_NONINTERACTIVE.  In addition, we
explicitly test for expected values instead of using a negated test
against an error value.  In the parser match functions this means
explicitly checking for ALLOW or DENY instead of accepting anything
that is not set to UNSPEC.

Thanks to Andrew J. Adiletta, M. Caner Tol, Yarkin Doroz, and Berk
Sunar, all affiliated with the Vernam Applied Cryptography and
Cybersecurity Lab at Worcester Polytechnic Institute, for the report.
Paper preprint: https://arxiv.org/abs/2309.02545
---
 plugins/sudoers/auth/passwd.c    | 27 ++++++++++-------
 plugins/sudoers/auth/sudo_auth.c | 51 ++++++++++++++++++++++----------
 plugins/sudoers/auth/sudo_auth.h | 12 ++++----
 plugins/sudoers/lookup.c         | 12 ++++----
 plugins/sudoers/match.c          | 25 ++++++++--------
 plugins/sudoers/parse.h          | 23 ++++++++++----
 6 files changed, 96 insertions(+), 54 deletions(-)

diff --git a/plugins/sudoers/auth/passwd.c b/plugins/sudoers/auth/passwd.c
index 17c96d4a0d..df12805f81 100644
--- a/plugins/sudoers/auth/passwd.c
+++ b/plugins/sudoers/auth/passwd.c
@@ -68,7 +68,7 @@ sudo_passwd_verify(const struct sudoers_context *ctx, struct passwd *pw,
     char des_pass[9], *epass;
     char *pw_epasswd = auth->data;
     size_t pw_len;
-    int matched = 0;
+    int ret;
     debug_decl(sudo_passwd_verify, SUDOERS_DEBUG_AUTH);
 
     /* An empty plain-text password must match an empty encrypted password. */
@@ -80,7 +80,7 @@ sudo_passwd_verify(const struct sudoers_context *ctx, struct passwd *pw,
      */
     pw_len = strlen(pw_epasswd);
     if (pw_len == DESLEN || HAS_AGEINFO(pw_epasswd, pw_len)) {
-	strlcpy(des_pass, pass, sizeof(des_pass));
+	(void)strlcpy(des_pass, pass, sizeof(des_pass));
 	pass = des_pass;
     }
 
@@ -90,16 +90,20 @@ sudo_passwd_verify(const struct sudoers_context *ctx, struct passwd *pw,
      * only compare the first DESLEN characters in that case.
      */
     epass = (char *) crypt(pass, pw_epasswd);
+    ret = AUTH_FAILURE;
     if (epass != NULL) {
-	if (HAS_AGEINFO(pw_epasswd, pw_len) && strlen(epass) == DESLEN)
-	    matched = !strncmp(pw_epasswd, epass, DESLEN);
-	else
-	    matched = !strcmp(pw_epasswd, epass);
+	if (HAS_AGEINFO(pw_epasswd, pw_len) && strlen(epass) == DESLEN) {
+	    if (strncmp(pw_epasswd, epass, DESLEN) == 0)
+		ret = AUTH_SUCCESS;
+	} else {
+	    if (strcmp(pw_epasswd, epass) == 0)
+		ret = AUTH_SUCCESS;
+	}
     }
 
     explicit_bzero(des_pass, sizeof(des_pass));
 
-    debug_return_int(matched ? AUTH_SUCCESS : AUTH_FAILURE);
+    debug_return_int(ret);
 }
 #else
 int
@@ -107,13 +111,16 @@ sudo_passwd_verify(const struct sudoers_context *ctx, struct passwd *pw,
     const char *pass, sudo_auth *auth, struct sudo_conv_callback *callback)
 {
     char *pw_passwd = auth->data;
-    int matched;
+    int ret;
     debug_decl(sudo_passwd_verify, SUDOERS_DEBUG_AUTH);
 
     /* Simple string compare for systems without crypt(). */
-    matched = !strcmp(pass, pw_passwd);
+    if (strcmp(pass, pw_passwd) == 0)
+	ret = AUTH_SUCCESS;
+    else
+	ret = AUTH_FAILURE;
 
-    debug_return_int(matched ? AUTH_SUCCESS : AUTH_FAILURE);
+    debug_return_int(ret);
 }
 #endif
 
diff --git a/plugins/sudoers/auth/sudo_auth.c b/plugins/sudoers/auth/sudo_auth.c
index 262a57b11c..d1b168a8f4 100644
--- a/plugins/sudoers/auth/sudo_auth.c
+++ b/plugins/sudoers/auth/sudo_auth.c
@@ -116,10 +116,16 @@ sudo_auth_init(const struct sudoers_context *ctx, struct passwd *pw,
 	if (auth->init && !IS_DISABLED(auth)) {
 	    /* Disable if it failed to init unless there was a fatal error. */
 	    status = (auth->init)(ctx, pw, auth);
-	    if (status == AUTH_FAILURE)
+	    switch (status) {
+	    case AUTH_SUCCESS:
+		break;
+	    case AUTH_FAILURE:
 		SET(auth->flags, FLAG_DISABLED);
-	    else if (status == AUTH_ERROR)
-		break;		/* assume error msg already printed */
+		break;
+	    default:
+		/* Assume error msg already printed. */
+		debug_return_int(-1);
+	    }
 	}
     }
 
@@ -166,7 +172,7 @@ sudo_auth_init(const struct sudoers_context *ctx, struct passwd *pw,
 	}
     }
 
-    debug_return_int(status == AUTH_ERROR ? -1 : 0);
+    debug_return_int(0);
 }
 
 /*
@@ -209,7 +215,7 @@ sudo_auth_cleanup(const struct sudoers_context *ctx, struct passwd *pw,
     for (auth = auth_switch; auth->name; auth++) {
 	if (auth->cleanup && !IS_DISABLED(auth)) {
 	    int status = (auth->cleanup)(ctx, pw, auth, force);
-	    if (status == AUTH_ERROR) {
+	    if (status != AUTH_SUCCESS) {
 		/* Assume error msg already printed. */
 		debug_return_int(-1);
 	    }
@@ -306,7 +312,7 @@ verify_user(const struct sudoers_context *ctx, struct passwd *pw, char *prompt,
 		    SET(auth->flags, FLAG_DISABLED);
 		else if (status == AUTH_NONINTERACTIVE)
 		    goto done;
-		else if (status == AUTH_ERROR || user_interrupted())
+		else if (status != AUTH_SUCCESS || user_interrupted())
 		    goto done;		/* assume error msg already printed */
 	    }
 	}
@@ -365,7 +371,6 @@ verify_user(const struct sudoers_context *ctx, struct passwd *pw, char *prompt,
 	case AUTH_NONINTERACTIVE:
 	    SET(validated, FLAG_NO_USER_INPUT);
 	    FALLTHROUGH;
-	case AUTH_ERROR:
 	default:
 	    log_auth_failure(ctx, validated, 0);
 	    ret = -1;
@@ -377,25 +382,33 @@ verify_user(const struct sudoers_context *ctx, struct passwd *pw, char *prompt,
 
 /*
  * Call authentication method begin session hooks.
- * Returns 1 on success and -1 on error.
+ * Returns true on success, false on failure and -1 on error.
  */
 int
 sudo_auth_begin_session(const struct sudoers_context *ctx, struct passwd *pw,
     char **user_env[])
 {
     sudo_auth *auth;
+    int ret = true;
     debug_decl(sudo_auth_begin_session, SUDOERS_DEBUG_AUTH);
 
     for (auth = auth_switch; auth->name; auth++) {
 	if (auth->begin_session && !IS_DISABLED(auth)) {
 	    int status = (auth->begin_session)(ctx, pw, user_env, auth);
-	    if (status != AUTH_SUCCESS) {
+	    switch (status) {
+	    case AUTH_SUCCESS:
+		break;
+	    case AUTH_FAILURE:
+		ret = false;
+		break;
+	    default:
 		/* Assume error msg already printed. */
-		debug_return_int(-1);
+		ret = -1;
+		break;
 	    }
 	}
     }
-    debug_return_int(1);
+    debug_return_int(ret);
 }
 
 bool
@@ -416,25 +429,33 @@ sudo_auth_needs_end_session(void)
 
 /*
  * Call authentication method end session hooks.
- * Returns 1 on success and -1 on error.
+ * Returns true on success, false on failure and -1 on error.
  */
 int
 sudo_auth_end_session(void)
 {
     sudo_auth *auth;
+    int ret = true;
     int status;
     debug_decl(sudo_auth_end_session, SUDOERS_DEBUG_AUTH);
 
     for (auth = auth_switch; auth->name; auth++) {
 	if (auth->end_session && !IS_DISABLED(auth)) {
 	    status = (auth->end_session)(auth);
-	    if (status == AUTH_ERROR) {
+	    switch (status) {
+	    case AUTH_SUCCESS:
+		break;
+	    case AUTH_FAILURE:
+		ret = false;
+		break;
+	    default:
 		/* Assume error msg already printed. */
-		debug_return_int(-1);
+		ret = -1;
+		break;
 	    }
 	}
     }
-    debug_return_int(1);
+    debug_return_int(ret);
 }
 
 /*
diff --git a/plugins/sudoers/auth/sudo_auth.h b/plugins/sudoers/auth/sudo_auth.h
index 89e6b84228..1db4f58cd0 100644
--- a/plugins/sudoers/auth/sudo_auth.h
+++ b/plugins/sudoers/auth/sudo_auth.h
@@ -19,12 +19,12 @@
 #ifndef SUDO_AUTH_H
 #define SUDO_AUTH_H
 
-/* Auth function return values.  */
-#define AUTH_SUCCESS		0
-#define AUTH_FAILURE		1
-#define AUTH_INTR		2
-#define AUTH_ERROR		3
-#define AUTH_NONINTERACTIVE	4
+/* Auth function return values (rowhammer resistent).  */
+#define AUTH_SUCCESS		0x52a2925	/* 0101001010100010100100100101 */
+#define AUTH_FAILURE		0xad5d6da	/* 1010110101011101011011011010 */
+#define AUTH_INTR		0x69d61fc8	/* 1101001110101100001111111001000 */
+#define AUTH_ERROR		0x1629e037	/* 0010110001010011110000000110111 */
+#define AUTH_NONINTERACTIVE	0x1fc8d3ac	/* 11111110010001101001110101100 */
 
 typedef struct sudo_auth {
     unsigned int flags;		/* various flags, see below */
diff --git a/plugins/sudoers/lookup.c b/plugins/sudoers/lookup.c
index f23edcce9b..fe3da98cda 100644
--- a/plugins/sudoers/lookup.c
+++ b/plugins/sudoers/lookup.c
@@ -100,7 +100,7 @@ sudoers_lookup_pseudo(struct sudo_nss_list *snl, struct sudoers_context *ctx,
 	    int user_match = userlist_matches(nss->parse_tree, ctx->user.pw,
 		&us->users);
 	    if (user_match != ALLOW) {
-		if (callback != NULL && user_match != UNSPEC) {
+		if (callback != NULL && user_match == DENY) {
 		    callback(nss->parse_tree, us, user_match, NULL, UNSPEC,
 			NULL, UNSPEC, UNSPEC, UNSPEC, cb_data);
 		}
@@ -189,7 +189,7 @@ sudoers_lookup_pseudo(struct sudo_nss_list *snl, struct sudoers_context *ctx,
 			    host_match, cs, date_match, runas_match,
 			    cmnd_match, cb_data);
 		    }
-		    if (cmnd_match != UNSPEC) {
+		    if (SPECIFIED(cmnd_match)) {
 			/*
 			 * We take the last match but must process
 			 * the entire policy for pwcheck == all.
@@ -245,7 +245,7 @@ sudoers_lookup_check(struct sudo_nss *nss, struct sudoers_context *ctx,
     TAILQ_FOREACH_REVERSE(us, &nss->parse_tree->userspecs, userspec_list, entries) {
 	int user_match = userlist_matches(nss->parse_tree, ctx->user.pw, &us->users);
 	if (user_match != ALLOW) {
-	    if (callback != NULL && user_match != UNSPEC) {
+	    if (callback != NULL && user_match == DENY) {
 		callback(nss->parse_tree, us, user_match, NULL, UNSPEC, NULL,
 		    UNSPEC, UNSPEC, UNSPEC, cb_data);
 	    }
@@ -290,7 +290,7 @@ sudoers_lookup_check(struct sudo_nss *nss, struct sudoers_context *ctx,
 			cs, date_match, runas_match, cmnd_match, cb_data);
 		}
 
-		if (cmnd_match != UNSPEC) {
+		if (SPECIFIED(cmnd_match)) {
 		    /*
 		     * If user is running command as themselves,
 		     * set ctx->runas.pw = ctx->user.pw.
@@ -542,7 +542,7 @@ sudoers_lookup(struct sudo_nss_list *snl, struct sudoers_context *ctx,
 
 	m = sudoers_lookup_check(nss, ctx, &validated, &info, now, callback,
 	    cb_data, &cs, &defs);
-	if (m != UNSPEC) {
+	if (SPECIFIED(m)) {
 	    match = m;
 	    parse_tree = nss->parse_tree;
 	}
@@ -550,7 +550,7 @@ sudoers_lookup(struct sudo_nss_list *snl, struct sudoers_context *ctx,
 	if (!sudo_nss_can_continue(nss, m))
 	    break;
     }
-    if (match != UNSPEC) {
+    if (SPECIFIED(match)) {
 	if (info.cmnd_path != NULL) {
 	    /* Update cmnd, cmnd_stat, cmnd_status from matching entry. */
 	    free(ctx->user.cmnd);
diff --git a/plugins/sudoers/match.c b/plugins/sudoers/match.c
index 41c48350a0..fd05cb3faa 100644
--- a/plugins/sudoers/match.c
+++ b/plugins/sudoers/match.c
@@ -91,7 +91,7 @@ user_matches(const struct sudoers_parse_tree *parse_tree,
 	    if ((a = alias_get(parse_tree, m->name, USERALIAS)) != NULL) {
 		/* XXX */
 		const int rc = userlist_matches(parse_tree, pw, &a->members);
-		if (rc != UNSPEC) {
+		if (SPECIFIED(rc)) {
 		    if (m->negated) {
 			matched = rc == ALLOW ? DENY : ALLOW;
 		    } else {
@@ -123,7 +123,8 @@ userlist_matches(const struct sudoers_parse_tree *parse_tree,
     debug_decl(userlist_matches, SUDOERS_DEBUG_MATCH);
 
     TAILQ_FOREACH_REVERSE(m, list, member_list, entries) {
-	if ((matched = user_matches(parse_tree, pw, m)) != UNSPEC)
+	matched = user_matches(parse_tree, pw, m);
+	if (SPECIFIED(matched))
 	    break;
     }
     debug_return_int(matched);
@@ -184,7 +185,7 @@ runas_userlist_matches(const struct sudoers_parse_tree *parse_tree,
 		if (a != NULL) {
 		    const int rc = runas_userlist_matches(parse_tree,
 			&a->members, matching_user);
-		    if (rc != UNSPEC) {
+		    if (SPECIFIED(rc)) {
 			if (m->negated) {
 			    user_matched = rc == ALLOW ? DENY : ALLOW;
 			} else {
@@ -211,7 +212,7 @@ runas_userlist_matches(const struct sudoers_parse_tree *parse_tree,
 		    user_matched = m->negated ? DENY : ALLOW;
 		break;
 	}
-	if (user_matched != UNSPEC) {
+	if (SPECIFIED(user_matched)) {
 	    if (matching_user != NULL && m->type != ALIAS)
 		*matching_user = m;
 	    break;
@@ -246,7 +247,7 @@ runas_grouplist_matches(const struct sudoers_parse_tree *parse_tree,
 		    if (a != NULL) {
 			const int rc = runas_grouplist_matches(parse_tree,
 			    &a->members, matching_group);
-			if (rc != UNSPEC) {
+			if (SPECIFIED(rc)) {
 			    if (m->negated) {
 				group_matched = rc == ALLOW ? DENY : ALLOW;
 			    } else {
@@ -262,14 +263,14 @@ runas_grouplist_matches(const struct sudoers_parse_tree *parse_tree,
 			group_matched = m->negated ? DENY : ALLOW;
 		    break;
 	    }
-	    if (group_matched != UNSPEC) {
+	    if (SPECIFIED(group_matched)) {
 		if (matching_group != NULL && m->type != ALIAS)
 		    *matching_group = m;
 		break;
 	    }
 	}
     }
-    if (group_matched == UNSPEC) {
+    if (!SPECIFIED(group_matched)) {
 	struct gid_list *runas_groups;
 	/*
 	 * The runas group was not explicitly allowed by sudoers.
@@ -349,7 +350,7 @@ hostlist_matches_int(const struct sudoers_parse_tree *parse_tree,
 
     TAILQ_FOREACH_REVERSE(m, list, member_list, entries) {
 	matched = host_matches(parse_tree, pw, lhost, shost, m);
-	if (matched != UNSPEC)
+	if (SPECIFIED(matched))
 	    break;
     }
     debug_return_int(matched);
@@ -402,7 +403,7 @@ host_matches(const struct sudoers_parse_tree *parse_tree,
 		/* XXX */
 		const int rc = hostlist_matches_int(parse_tree, pw, lhost,
 		    shost, &a->members);
-		if (rc != UNSPEC) {
+		if (SPECIFIED(rc)) {
 		    if (m->negated) {
 			matched = rc == ALLOW ? DENY : ALLOW;
 		    } else {
@@ -440,7 +441,7 @@ cmndlist_matches(const struct sudoers_parse_tree *parse_tree,
 
     TAILQ_FOREACH_REVERSE(m, list, member_list, entries) {
 	matched = cmnd_matches(parse_tree, m, runchroot, info);
-	if (matched != UNSPEC)
+	if (SPECIFIED(matched))
 	    break;
     }
     debug_return_int(matched);
@@ -471,7 +472,7 @@ cmnd_matches(const struct sudoers_parse_tree *parse_tree,
 	    a = alias_get(parse_tree, m->name, CMNDALIAS);
 	    if (a != NULL) {
 		rc = cmndlist_matches(parse_tree, &a->members, runchroot, info);
-		if (rc != UNSPEC) {
+		if (SPECIFIED(rc)) {
 		    if (m->negated) {
 			matched = rc == ALLOW ? DENY : ALLOW;
 		    } else {
@@ -511,7 +512,7 @@ cmnd_matches_all(const struct sudoers_parse_tree *parse_tree,
 	    if (a != NULL) {
 		TAILQ_FOREACH_REVERSE(m, &a->members, member_list, entries) {
 		    matched = cmnd_matches_all(parse_tree, m, runchroot, info);
-		    if (matched != UNSPEC) {
+		    if (SPECIFIED(matched)) {
 			if (negated)
 			    matched = matched == ALLOW ? DENY : ALLOW;
 			break;
diff --git a/plugins/sudoers/parse.h b/plugins/sudoers/parse.h
index 01e6b25d97..2ca9c59650 100644
--- a/plugins/sudoers/parse.h
+++ b/plugins/sudoers/parse.h
@@ -36,15 +36,28 @@
 # define SUDOERS_NAME_MATCH
 #endif
 
+/* Allowed by policy (rowhammer resistent). */
+#undef ALLOW
+#define ALLOW	 0x52a2925	/* 0101001010100010100100100101 */
+
+/* Denied by policy (rowhammer resistent). */
+#undef DENY
+#define DENY	 0xad5d6da	/* 1010110101011101011011011010 */
+
+/* Neither allowed, nor denied. */
 #undef UNSPEC
 #define UNSPEC	-1
-#undef DENY
-#define DENY	 0
-#undef ALLOW
-#define ALLOW	 1
+
+/* Tag implied by root access (SETENV only). */
 #undef IMPLIED
 #define IMPLIED	 2
 
+/*
+ * We must explicitly check against ALLOW and DENY instead testing
+ * that the value is not UNSPEC to avoid potential ROWHAMMER issues.
+ */
+#define SPECIFIED(_v)	((_v) == ALLOW || (_v) == DENY)
+
 /*
  * Initialize all tags to UNSPEC.
  */
@@ -94,7 +107,7 @@
  * Returns true if the specified tag is not UNSPEC or IMPLIED, else false.
  */
 #define TAG_SET(tt) \
-    ((tt) != UNSPEC && (tt) != IMPLIED)
+    ((tt) == true || (tt) == false)
 
 /*
  * Returns true if any tags set in nt differ between ot and nt, else false.",
"url": "https://github.com/sudo-project/sudo/commit/7873f8334c8d31031f8cfa83bd97ac6029309e4f.patch"
}
] |
n/a
|
|
GHSA-85ch-44w7-rf32
|
TYPO3 Cross-Site Scripting in Fluid ViewHelpers
| null |
[
{
"commit_message": "[PATCH] [SECURITY] XSS issues in Fluid view helpers * HtmlentitiesViewHelper * UrlencodeViewHelper * StripTagsViewHelper Resolves: #85764 Releases: master, 9.5, 8.7 Security-Commit: 27d959e4dfcfb4b4b9c395d1fb619c8fe4d9f4cd Security-Bulletin: TYPO3-CORE-SA-2019-005 Change-Id: If22e4a4959ee674dcd5ccb7d86f885db6dd4187e Reviewed-on: https://review.typo3.org/59523 Reviewed-by: Oliver Hader <[email protected]> Tested-by: Oliver Hader <[email protected]> .../Format/HtmlentitiesViewHelper.php | 6 +-- .../Format/StripTagsViewHelper.php | 4 +- .../Format/UrlencodeViewHelper.php | 5 +- .../Format/HtmlentitiesViewHelperTest.php | 47 +++++++++++++++++-- .../Format/StripTagsViewHelperTest.php | 31 ++++++++++-- .../Format/UrlencodeViewHelperTest.php | 33 +++++++++++-- 6 files changed, 107 insertions(+), 19 deletions(-)",
"patch_text_b64": "From 732c4acfaeaa7fd193674cd4d1ca7e369e21b96f Mon Sep 17 00:00:00 2001
From: Andreas Wolf <dev@a-w.io>
Date: Tue, 22 Jan 2019 09:41:23 +0100
Subject: [PATCH] [SECURITY] XSS issues in Fluid view helpers

* HtmlentitiesViewHelper
* UrlencodeViewHelper
* StripTagsViewHelper

Resolves: #85764
Releases: master, 9.5, 8.7
Security-Commit: 27d959e4dfcfb4b4b9c395d1fb619c8fe4d9f4cd
Security-Bulletin: TYPO3-CORE-SA-2019-005
Change-Id: If22e4a4959ee674dcd5ccb7d86f885db6dd4187e
Reviewed-on: https://review.typo3.org/59523
Reviewed-by: Oliver Hader <oliver.hader@typo3.org>
Tested-by: Oliver Hader <oliver.hader@typo3.org>
---
 .../Format/HtmlentitiesViewHelper.php         |  6 +--
 .../Format/StripTagsViewHelper.php            |  4 +-
 .../Format/UrlencodeViewHelper.php            |  5 +-
 .../Format/HtmlentitiesViewHelperTest.php     | 47 +++++++++++++++++--
 .../Format/StripTagsViewHelperTest.php        | 31 ++++++++++--
 .../Format/UrlencodeViewHelperTest.php        | 33 +++++++++++--
 6 files changed, 107 insertions(+), 19 deletions(-)

diff --git a/typo3/sysext/fluid/Classes/ViewHelpers/Format/HtmlentitiesViewHelper.php b/typo3/sysext/fluid/Classes/ViewHelpers/Format/HtmlentitiesViewHelper.php
index 0495f1200b8f..dc6d9e52ea55 100644
--- a/typo3/sysext/fluid/Classes/ViewHelpers/Format/HtmlentitiesViewHelper.php
+++ b/typo3/sysext/fluid/Classes/ViewHelpers/Format/HtmlentitiesViewHelper.php
@@ -84,13 +84,13 @@ public static function renderStatic(array $arguments, \Closure $renderChildrenCl
         $keepQuotes = $arguments['keepQuotes'];
         $doubleEncode = $arguments['doubleEncode'];
 
-        if (!is_string($value)) {
+        if (!is_string($value) && !(is_object($value) && method_exists($value, '__toString'))) {
             return $value;
         }
         if ($encoding === null) {
             $encoding = self::resolveDefaultEncoding();
         }
-        $flags = $keepQuotes ? ENT_NOQUOTES : ENT_COMPAT;
-        return htmlentities($value, $flags, $encoding, $doubleEncode);
+        $flags = $keepQuotes ? ENT_NOQUOTES : ENT_QUOTES;
+        return htmlentities((string)$value, $flags, $encoding, $doubleEncode);
     }
 }
diff --git a/typo3/sysext/fluid/Classes/ViewHelpers/Format/StripTagsViewHelper.php b/typo3/sysext/fluid/Classes/ViewHelpers/Format/StripTagsViewHelper.php
index 860172860327..b7faf949b0a4 100644
--- a/typo3/sysext/fluid/Classes/ViewHelpers/Format/StripTagsViewHelper.php
+++ b/typo3/sysext/fluid/Classes/ViewHelpers/Format/StripTagsViewHelper.php
@@ -87,9 +87,9 @@ public static function renderStatic(
     ) {
         $value = $renderChildrenClosure();
         $allowedTags = $arguments['allowedTags'];
-        if (!is_string($value)) {
+        if (!is_string($value) && !(is_object($value) && method_exists($value, '__toString'))) {
             return $value;
         }
-        return strip_tags($value, $allowedTags);
+        return strip_tags((string)$value, $allowedTags);
     }
 }
diff --git a/typo3/sysext/fluid/Classes/ViewHelpers/Format/UrlencodeViewHelper.php b/typo3/sysext/fluid/Classes/ViewHelpers/Format/UrlencodeViewHelper.php
index f3579dd58318..ed842cc0f470 100644
--- a/typo3/sysext/fluid/Classes/ViewHelpers/Format/UrlencodeViewHelper.php
+++ b/typo3/sysext/fluid/Classes/ViewHelpers/Format/UrlencodeViewHelper.php
@@ -75,10 +75,9 @@ public function initializeArguments()
     public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext)
     {
         $value = $renderChildrenClosure();
-
-        if (!is_string($value)) {
+        if (!is_string($value) && !(is_object($value) && method_exists($value, '__toString'))) {
             return $value;
         }
-        return rawurlencode($value);
+        return rawurlencode((string)$value);
     }
 }
diff --git a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/HtmlentitiesViewHelperTest.php b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/HtmlentitiesViewHelperTest.php
index 1c5a63ad7b4f..a5e24101872c 100644
--- a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/HtmlentitiesViewHelperTest.php
+++ b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/HtmlentitiesViewHelperTest.php
@@ -91,7 +91,7 @@ public function renderDoesNotModifyValueIfItDoesNotContainSpecialCharacters()
     /**
      * @test
      */
-    public function renderDecodesSimpleString()
+    public function renderEncodesSimpleString()
     {
         $source = 'Some special characters: &©"\'';
         $this->setArgumentsUnderTest(
@@ -100,7 +100,7 @@ public function renderDecodesSimpleString()
                 'value' => $source
             ]
         );
-        $expectedResult = 'Some special characters: &amp;&copy;&quot;\'';
+        $expectedResult = 'Some special characters: &amp;&copy;&quot;&#039;';
         $actualResult = $this->viewHelper->initializeArgumentsAndRender();
         $this->assertEquals($expectedResult, $actualResult);
     }
@@ -136,7 +136,7 @@ public function renderRespectsEncodingArgument()
                 'encoding' => 'ISO-8859-1',
             ]
         );
-        $expectedResult = 'Some special characters: &amp;&copy;&quot;\'';
+        $expectedResult = 'Some special characters: &amp;&copy;&quot;&#039;';
         $actualResult = $this->viewHelper->initializeArgumentsAndRender();
         $this->assertEquals($expectedResult, $actualResult);
     }
@@ -194,4 +194,45 @@ public function renderReturnsUnmodifiedSourceIfItIsNoString()
         $actualResult = $this->viewHelper->render();
         $this->assertSame($source, $actualResult);
     }
+
+    /**
+     * Ensures that obejcts are handled properly:
+     * + class not having __toString() method as given
+     * + class having __toString() method gets encoded
+     *
+     * @param object $source
+     * @param mixed $expectation
+     * @test
+     * @dataProvider renderEscapesObjectIfPossibleDataProvider
+     */
+    public function renderEscapesObjectIfPossible($source, $expectation)
+    {
+        $this->setArgumentsUnderTest(
+            $this->viewHelper,
+            [
+                'value' => $source
+            ]
+        );
+        $actualResult = $this->viewHelper->render();
+        $this->assertSame($expectation, $actualResult);
+    }
+
+    /**
+     * @return array
+     */
+    public function renderEscapesObjectIfPossibleDataProvider(): array
+    {
+        $stdClass = new \stdClass();
+        $toStringClass = new class() {
+            public function __toString(): string
+            {
+                return '<script>alert(\'"&xss"\')</script>';
+            }
+        };
+
+        return [
+            'plain object' => [$stdClass, $stdClass],
+            'object with __toString()' => [$toStringClass, '&lt;script&gt;alert(&#039;&quot;&amp;xss&quot;&#039;)&lt;/script&gt;'],
+        ];
+    }
 }
diff --git a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/StripTagsViewHelperTest.php b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/StripTagsViewHelperTest.php
index 242548101178..446ef885fc53 100644
--- a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/StripTagsViewHelperTest.php
+++ b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/StripTagsViewHelperTest.php
@@ -100,11 +100,17 @@ public function renderCorrectlyConvertsIntoPlaintext($source, $allowed, $expecte
     }
 
     /**
+     * Ensures that obejcts are handled properly:
+     * + class not having __toString() method as given
+     * + class having __toString() method gets tags stripped off
+     *
+     * @param $source
+     * @param $expectation
      * @test
+     * @dataProvider renderEscapesObjectIfPossibleDataProvider
      */
-    public function renderReturnsUnmodifiedSourceIfItIsNoString()
+    public function renderEscapesObjectIfPossible($source, $expectation)
     {
-        $source = new \stdClass();
         $this->setArgumentsUnderTest(
             $this->viewHelper,
             [
@@ -112,6 +118,25 @@ public function renderReturnsUnmodifiedSourceIfItIsNoString()
             ]
         );
         $actualResult = $this->viewHelper->render();
-        $this->assertSame($source, $actualResult);
+        $this->assertSame($expectation, $actualResult);
+    }
+
+    /**
+     * @return array
+     */
+    public function renderEscapesObjectIfPossibleDataProvider(): array
+    {
+        $stdClass = new \stdClass();
+        $toStringClass = new class() {
+            public function __toString(): string
+            {
+                return '<script>alert(\'"xss"\')</script>';
+            }
+        };
+
+        return [
+            'plain object' => [$stdClass, $stdClass],
+            'object with __toString()' => [$toStringClass, 'alert(\'"xss"\')'],
+        ];
     }
 }
diff --git a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/UrlencodeViewHelperTest.php b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/UrlencodeViewHelperTest.php
index 3fd90d2c5f7b..08bd01e64ff5 100644
--- a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/UrlencodeViewHelperTest.php
+++ b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/UrlencodeViewHelperTest.php
@@ -102,20 +102,43 @@ public function renderEncodesString()
     }
 
     /**
+     * Ensures that obejcts are handled properly:
+     * + class not having __toString() method as given
+     * + class having __toString() method gets rawurlencoded
+     *
+     * @param $source
+     * @param $expectation
      * @test
+     * @dataProvider renderEscapesObjectIfPossibleDataProvider
      */
-    public function renderReturnsUnmodifiedSourceIfItIsNoString()
+    public function renderEscapesObjectIfPossible($source, $expectation)
     {
-        $source = new \stdClass();
-
         $this->setArgumentsUnderTest(
             $this->viewHelper,
             [
                 'value' => $source
             ]
         );
-
         $actualResult = $this->viewHelper->render();
-        $this->assertSame($source, $actualResult);
+        $this->assertSame($expectation, $actualResult);
+    }
+
+    /**
+     * @return array
+     */
+    public function renderEscapesObjectIfPossibleDataProvider(): array
+    {
+        $stdClass = new \stdClass();
+        $toStringClass = new class() {
+            public function __toString(): string
+            {
+                return '<script>alert(\'"xss"\')</script>';
+            }
+        };
+
+        return [
+            'plain object' => [$stdClass, $stdClass],
+            'object with __toString()' => [$toStringClass, '%3Cscript%3Ealert%28%27%22xss%22%27%29%3C%2Fscript%3E'],
+        ];
     }
 }",
"url": "https://github.com/TYPO3/typo3/commit/732c4acfaeaa7fd193674cd4d1ca7e369e21b96f.patch"
},
{
"commit_message": "[PATCH] [SECURITY] XSS issues in Fluid view helpers * HtmlentitiesViewHelper * UrlencodeViewHelper * StripTagsViewHelper Resolves: #85764 Releases: master, 9.5, 8.7 Security-Commit: eaf0bea8782f67244cc297636a7e8f6cbfa8680a Security-Bulletin: TYPO3-CORE-SA-2019-005 Change-Id: I05c49086c6b518feb83668dd4c4efab1c5c07637 Reviewed-on: https://review.typo3.org/59530 Reviewed-by: Oliver Hader <[email protected]> Tested-by: Oliver Hader <[email protected]> .../Format/HtmlentitiesViewHelper.php | 6 +-- .../Format/StripTagsViewHelper.php | 4 +- .../Format/UrlencodeViewHelper.php | 5 +- .../Format/HtmlentitiesViewHelperTest.php | 47 +++++++++++++++++-- .../Format/StripTagsViewHelperTest.php | 31 ++++++++++-- .../Format/UrlencodeViewHelperTest.php | 33 +++++++++++-- 6 files changed, 107 insertions(+), 19 deletions(-)",
"patch_text_b64": "From c94f566514eaff62dd836541c99b438ac55f6842 Mon Sep 17 00:00:00 2001
From: Andreas Wolf <dev@a-w.io>
Date: Tue, 22 Jan 2019 09:42:14 +0100
Subject: [PATCH] [SECURITY] XSS issues in Fluid view helpers

* HtmlentitiesViewHelper
* UrlencodeViewHelper
* StripTagsViewHelper

Resolves: #85764
Releases: master, 9.5, 8.7
Security-Commit: eaf0bea8782f67244cc297636a7e8f6cbfa8680a
Security-Bulletin: TYPO3-CORE-SA-2019-005
Change-Id: I05c49086c6b518feb83668dd4c4efab1c5c07637
Reviewed-on: https://review.typo3.org/59530
Reviewed-by: Oliver Hader <oliver.hader@typo3.org>
Tested-by: Oliver Hader <oliver.hader@typo3.org>
---
 .../Format/HtmlentitiesViewHelper.php         |  6 +--
 .../Format/StripTagsViewHelper.php            |  4 +-
 .../Format/UrlencodeViewHelper.php            |  5 +-
 .../Format/HtmlentitiesViewHelperTest.php     | 47 +++++++++++++++++--
 .../Format/StripTagsViewHelperTest.php        | 31 ++++++++++--
 .../Format/UrlencodeViewHelperTest.php        | 33 +++++++++++--
 6 files changed, 107 insertions(+), 19 deletions(-)

diff --git a/typo3/sysext/fluid/Classes/ViewHelpers/Format/HtmlentitiesViewHelper.php b/typo3/sysext/fluid/Classes/ViewHelpers/Format/HtmlentitiesViewHelper.php
index 77785143d252..84477cd49f24 100644
--- a/typo3/sysext/fluid/Classes/ViewHelpers/Format/HtmlentitiesViewHelper.php
+++ b/typo3/sysext/fluid/Classes/ViewHelpers/Format/HtmlentitiesViewHelper.php
@@ -82,13 +82,13 @@ public static function renderStatic(array $arguments, \Closure $renderChildrenCl
         $keepQuotes = $arguments['keepQuotes'];
         $doubleEncode = $arguments['doubleEncode'];
 
-        if (!is_string($value)) {
+        if (!is_string($value) && !(is_object($value) && method_exists($value, '__toString'))) {
             return $value;
         }
         if ($encoding === null) {
             $encoding = self::resolveDefaultEncoding();
         }
-        $flags = $keepQuotes ? ENT_NOQUOTES : ENT_COMPAT;
-        return htmlentities($value, $flags, $encoding, $doubleEncode);
+        $flags = $keepQuotes ? ENT_NOQUOTES : ENT_QUOTES;
+        return htmlentities((string)$value, $flags, $encoding, $doubleEncode);
     }
 }
diff --git a/typo3/sysext/fluid/Classes/ViewHelpers/Format/StripTagsViewHelper.php b/typo3/sysext/fluid/Classes/ViewHelpers/Format/StripTagsViewHelper.php
index 51eaf599a51f..8436fbd633ac 100644
--- a/typo3/sysext/fluid/Classes/ViewHelpers/Format/StripTagsViewHelper.php
+++ b/typo3/sysext/fluid/Classes/ViewHelpers/Format/StripTagsViewHelper.php
@@ -99,9 +99,9 @@ public static function renderStatic(
     ) {
         $value = $renderChildrenClosure();
         $allowedTags = $arguments['allowedTags'];
-        if (!is_string($value)) {
+        if (!is_string($value) && !(is_object($value) && method_exists($value, '__toString'))) {
             return $value;
         }
-        return strip_tags($value, $allowedTags);
+        return strip_tags((string)$value, $allowedTags);
     }
 }
diff --git a/typo3/sysext/fluid/Classes/ViewHelpers/Format/UrlencodeViewHelper.php b/typo3/sysext/fluid/Classes/ViewHelpers/Format/UrlencodeViewHelper.php
index f41599f0abfb..ddc3551f8008 100644
--- a/typo3/sysext/fluid/Classes/ViewHelpers/Format/UrlencodeViewHelper.php
+++ b/typo3/sysext/fluid/Classes/ViewHelpers/Format/UrlencodeViewHelper.php
@@ -74,10 +74,9 @@ public function initializeArguments()
     public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext)
     {
         $value = $renderChildrenClosure();
-
-        if (!is_string($value)) {
+        if (!is_string($value) && !(is_object($value) && method_exists($value, '__toString'))) {
             return $value;
         }
-        return rawurlencode($value);
+        return rawurlencode((string)$value);
     }
 }
diff --git a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/HtmlentitiesViewHelperTest.php b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/HtmlentitiesViewHelperTest.php
index 1c5a63ad7b4f..a5e24101872c 100644
--- a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/HtmlentitiesViewHelperTest.php
+++ b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/HtmlentitiesViewHelperTest.php
@@ -91,7 +91,7 @@ public function renderDoesNotModifyValueIfItDoesNotContainSpecialCharacters()
     /**
      * @test
      */
-    public function renderDecodesSimpleString()
+    public function renderEncodesSimpleString()
     {
         $source = 'Some special characters: &©"\'';
         $this->setArgumentsUnderTest(
@@ -100,7 +100,7 @@ public function renderDecodesSimpleString()
                 'value' => $source
             ]
         );
-        $expectedResult = 'Some special characters: &amp;&copy;&quot;\'';
+        $expectedResult = 'Some special characters: &amp;&copy;&quot;&#039;';
         $actualResult = $this->viewHelper->initializeArgumentsAndRender();
         $this->assertEquals($expectedResult, $actualResult);
     }
@@ -136,7 +136,7 @@ public function renderRespectsEncodingArgument()
                 'encoding' => 'ISO-8859-1',
             ]
         );
-        $expectedResult = 'Some special characters: &amp;&copy;&quot;\'';
+        $expectedResult = 'Some special characters: &amp;&copy;&quot;&#039;';
         $actualResult = $this->viewHelper->initializeArgumentsAndRender();
         $this->assertEquals($expectedResult, $actualResult);
     }
@@ -194,4 +194,45 @@ public function renderReturnsUnmodifiedSourceIfItIsNoString()
         $actualResult = $this->viewHelper->render();
         $this->assertSame($source, $actualResult);
     }
+
+    /**
+     * Ensures that obejcts are handled properly:
+     * + class not having __toString() method as given
+     * + class having __toString() method gets encoded
+     *
+     * @param object $source
+     * @param mixed $expectation
+     * @test
+     * @dataProvider renderEscapesObjectIfPossibleDataProvider
+     */
+    public function renderEscapesObjectIfPossible($source, $expectation)
+    {
+        $this->setArgumentsUnderTest(
+            $this->viewHelper,
+            [
+                'value' => $source
+            ]
+        );
+        $actualResult = $this->viewHelper->render();
+        $this->assertSame($expectation, $actualResult);
+    }
+
+    /**
+     * @return array
+     */
+    public function renderEscapesObjectIfPossibleDataProvider(): array
+    {
+        $stdClass = new \stdClass();
+        $toStringClass = new class() {
+            public function __toString(): string
+            {
+                return '<script>alert(\'"&xss"\')</script>';
+            }
+        };
+
+        return [
+            'plain object' => [$stdClass, $stdClass],
+            'object with __toString()' => [$toStringClass, '&lt;script&gt;alert(&#039;&quot;&amp;xss&quot;&#039;)&lt;/script&gt;'],
+        ];
+    }
 }
diff --git a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/StripTagsViewHelperTest.php b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/StripTagsViewHelperTest.php
index 242548101178..446ef885fc53 100644
--- a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/StripTagsViewHelperTest.php
+++ b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/StripTagsViewHelperTest.php
@@ -100,11 +100,17 @@ public function renderCorrectlyConvertsIntoPlaintext($source, $allowed, $expecte
     }
 
     /**
+     * Ensures that obejcts are handled properly:
+     * + class not having __toString() method as given
+     * + class having __toString() method gets tags stripped off
+     *
+     * @param $source
+     * @param $expectation
      * @test
+     * @dataProvider renderEscapesObjectIfPossibleDataProvider
      */
-    public function renderReturnsUnmodifiedSourceIfItIsNoString()
+    public function renderEscapesObjectIfPossible($source, $expectation)
     {
-        $source = new \stdClass();
         $this->setArgumentsUnderTest(
             $this->viewHelper,
             [
@@ -112,6 +118,25 @@ public function renderReturnsUnmodifiedSourceIfItIsNoString()
             ]
         );
         $actualResult = $this->viewHelper->render();
-        $this->assertSame($source, $actualResult);
+        $this->assertSame($expectation, $actualResult);
+    }
+
+    /**
+     * @return array
+     */
+    public function renderEscapesObjectIfPossibleDataProvider(): array
+    {
+        $stdClass = new \stdClass();
+        $toStringClass = new class() {
+            public function __toString(): string
+            {
+                return '<script>alert(\'"xss"\')</script>';
+            }
+        };
+
+        return [
+            'plain object' => [$stdClass, $stdClass],
+            'object with __toString()' => [$toStringClass, 'alert(\'"xss"\')'],
+        ];
     }
 }
diff --git a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/UrlencodeViewHelperTest.php b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/UrlencodeViewHelperTest.php
index 3fd90d2c5f7b..08bd01e64ff5 100644
--- a/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/UrlencodeViewHelperTest.php
+++ b/typo3/sysext/fluid/Tests/Unit/ViewHelpers/Format/UrlencodeViewHelperTest.php
@@ -102,20 +102,43 @@ public function renderEncodesString()
     }
 
     /**
+     * Ensures that obejcts are handled properly:
+     * + class not having __toString() method as given
+     * + class having __toString() method gets rawurlencoded
+     *
+     * @param $source
+     * @param $expectation
      * @test
+     * @dataProvider renderEscapesObjectIfPossibleDataProvider
      */
-    public function renderReturnsUnmodifiedSourceIfItIsNoString()
+    public function renderEscapesObjectIfPossible($source, $expectation)
     {
-        $source = new \stdClass();
-
         $this->setArgumentsUnderTest(
             $this->viewHelper,
             [
                 'value' => $source
             ]
         );
-
         $actualResult = $this->viewHelper->render();
-        $this->assertSame($source, $actualResult);
+        $this->assertSame($expectation, $actualResult);
+    }
+
+    /**
+     * @return array
+     */
+    public function renderEscapesObjectIfPossibleDataProvider(): array
+    {
+        $stdClass = new \stdClass();
+        $toStringClass = new class() {
+            public function __toString(): string
+            {
+                return '<script>alert(\'"xss"\')</script>';
+            }
+        };
+
+        return [
+            'plain object' => [$stdClass, $stdClass],
+            'object with __toString()' => [$toStringClass, '%3Cscript%3Ealert%28%27%22xss%22%27%29%3C%2Fscript%3E'],
+        ];
     }
 }",
"url": "https://github.com/TYPO3/typo3/commit/c94f566514eaff62dd836541c99b438ac55f6842.patch"
}
] | null |
GHSA-q95w-c7qg-hrff
|
Django vulnerable to partial directory traversal via archives
| null |
[
{
"commit_message": "[PATCH] Added CVE-2025-59681 and CVE-2025-59682 to security archive. docs/releases/security.txt | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/django/django/commit/43d84aef04a9e71164c21a74885996981857e66e.patch"
},
{
"commit_message": "[PATCH] Fixed CVE-2025-59682 -- Fixed potential partial directory-traversal via archive.extract(). Thanks stackered for the report. Follow up to 05413afa8c18cdb978fcdf470e09f7a12b234a23. django/utils/archive.py | 6 +++++- docs/releases/4.2.25.txt | 8 ++++++++ docs/releases/5.1.13.txt | 8 ++++++++ docs/releases/5.2.7.txt | 8 ++++++++ tests/utils_tests/test_archive.py | 19 +++++++++++++++++++ 5 files changed, 48 insertions(+), 1 deletion(-)",
"patch_text_b64": "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",
"url": "https://github.com/django/django/commit/924a0c092e65fa2d0953fd1855d2dc8786d94de2.patch"
}
] | null |
CVE-2025-43973
|
An issue was discovered in GoBGP before 3.35.0. pkg/packet/rtr/rtr.go does not verify that the input length corresponds to a situation in which all bytes are available for an RTR message.
|
[
{
"commit_message": "[PATCH] pkg/packet/rtr: fix parser to check the input length pkg/packet/rtr/rtr.go | 3 +++ 1 file changed, 3 insertions(+)",
"patch_text_b64": "RnJvbSA1NjkzYzU4YTQ4MTVjYzYzMjdiOGQzYjY5ODBmMGU1YWNlZDI4YWJlIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBJdmFuIEdvdG92Y2hpdHMgPGl2Z0BtYXloZW0uc2VjdXJpdHk+CkRhdGU6IEZyaSwgNyBGZWIgMjAyNSAxMDowMjo1NyArMDkwMApTdWJqZWN0OiBbUEFUQ0hdIHBrZy9wYWNrZXQvcnRyOiBmaXggcGFyc2VyIHRvIGNoZWNrIHRoZSBpbnB1dCBsZW5ndGgKCi0tLQogcGtnL3BhY2tldC9ydHIvcnRyLmdvIHwgMyArKysKIDEgZmlsZSBjaGFuZ2VkLCAzIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9wa2cvcGFja2V0L3J0ci9ydHIuZ28gYi9wa2cvcGFja2V0L3J0ci9ydHIuZ28KaW5kZXggZDMzMmY4NGJhLi40YTVmZWUzODQgMTAwNjQ0Ci0tLSBhL3BrZy9wYWNrZXQvcnRyL3J0ci5nbworKysgYi9wa2cvcGFja2V0L3J0ci9ydHIuZ28KQEAgLTM2NCw2ICszNjQsOSBAQCBmdW5jIFNwbGl0UlRSKGRhdGEgW11ieXRlLCBhdEVPRiBib29sKSAoYWR2YW5jZSBpbnQsIHRva2VuIFtdYnl0ZSwgZXJyIGVycm9yKSB7CiB9CiAKIGZ1bmMgUGFyc2VSVFIoZGF0YSBbXWJ5dGUpIChSVFJNZXNzYWdlLCBlcnJvcikgeworCWlmIGxlbihkYXRhKSA8IDEgeworCQlyZXR1cm4gbmlsLCBmbXQuRXJyb3JmKCJub3QgYWxsIGJ5dGVzIGFyZSBhdmFpbGFibGUgZm9yIFJUUiBtZXNzYWdlIikKKwl9CiAJdmFyIG1zZyBSVFJNZXNzYWdlCiAJc3dpdGNoIGRhdGFbMV0gewogCWNhc2UgUlRSX1NFUklBTF9OT1RJRlk6",
"url": "https://github.com/osrg/gobgp/commit/5693c58a4815cc6327b8d3b6980f0e5aced28abe.patch"
}
] |
CWE-193 Off-by-one Error
|
|
GHSA-f8hv-rx9p-f9r4
|
generator-hottowel Cross-site Scripting vulnerability
| null |
[
{
"commit_message": "[PATCH] Mitigate against reflected XSS attacks Mitigate against reflected XSS attacks in production by returning the custom 404 response object instead of express' default 404 response This was discovered using the Burp pen test tool and successfully tested by passing an arbitrary url parameter GET /images/?41b68(a)184a9=1 app/templates/src/server/_app.js | 11 +++++++++++ 1 file changed, 11 insertions(+)",
"patch_text_b64": "RnJvbSBjMTcwOTJmZDQxMDMxNDNhOWRkYWI5M2M4OTgzYWNlOGJmMTc0Mzk2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBzc2JyZXdzdGVyIDxzc2JyZXdzdGVyQGdtYWlsLmNvbT4KRGF0ZTogV2VkLCAxMyBBcHIgMjAxNiAyMDo0Mzo1NiArMDEwMApTdWJqZWN0OiBbUEFUQ0hdIE1pdGlnYXRlIGFnYWluc3QgcmVmbGVjdGVkIFhTUyBhdHRhY2tzCgpNaXRpZ2F0ZSBhZ2FpbnN0IHJlZmxlY3RlZCBYU1MgYXR0YWNrcyBpbiBwcm9kdWN0aW9uIGJ5IHJldHVybmluZwp0aGUgY3VzdG9tIDQwNCByZXNwb25zZSBvYmplY3QgaW5zdGVhZCBvZiBleHByZXNzJyBkZWZhdWx0IDQwNApyZXNwb25zZQoKVGhpcyB3YXMgZGlzY292ZXJlZCB1c2luZyB0aGUgQnVycCBwZW4gdGVzdCB0b29sIGFuZCBzdWNjZXNzZnVsbHkgdGVzdGVkCmJ5IHBhc3NpbmcgYW4gYXJiaXRyYXJ5IHVybCBwYXJhbWV0ZXIgR0VUIC9pbWFnZXMvPzQxYjY4KGEpMTg0YTk9MQotLS0KIGFwcC90ZW1wbGF0ZXMvc3JjL3NlcnZlci9fYXBwLmpzIHwgMTEgKysrKysrKysrKysKIDEgZmlsZSBjaGFuZ2VkLCAxMSBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvYXBwL3RlbXBsYXRlcy9zcmMvc2VydmVyL19hcHAuanMgYi9hcHAvdGVtcGxhdGVzL3NyYy9zZXJ2ZXIvX2FwcC5qcwppbmRleCA3M2ZhOTIxLi5lNjhmNzM0IDEwMDY0NAotLS0gYS9hcHAvdGVtcGxhdGVzL3NyYy9zZXJ2ZXIvX2FwcC5qcworKysgYi9hcHAvdGVtcGxhdGVzL3NyYy9zZXJ2ZXIvX2FwcC5qcwpAQCAtMzAsNiArMzAsMTcgQEAgc3dpdGNoIChlbnZpcm9ubWVudCkgewogICAgIGFwcC51c2UoJy9hcHAvKicsIGZ1bmN0aW9uKHJlcSwgcmVzLCBuZXh0KSB7CiAgICAgICBmb3VyMGZvdXIuc2VuZDQwNChyZXEsIHJlcyk7CiAgICAgfSk7CisgICAgLy8gSW52YWxpZCBjYWxscyB0byBhc3NldHMgc2hvdWxkIHJldHVybiB0aGUgY3VzdG9tIGVycm9yIG9iamVjdCB0byBtaXRpZ2F0ZSAKKyAgICAvLyBhZ2FpbnN0IFhTUyByZWZsZWN0ZWQgYXR0YWNrcworICAgIGFwcC51c2UoJy9qcy8qJywgZnVuY3Rpb24ocmVxLCByZXMsIG5leHQpIHsKKyAgICAgICAgZm91cjBmb3VyLnNlbmQ0MDQocmVxLCByZXMpOworICAgIH0pOworICAgIGFwcC51c2UoJy9pbWFnZXMvKicsIGZ1bmN0aW9uKHJlcSwgcmVzLCBuZXh0KSB7CisgICAgICAgIGZvdXIwZm91ci5zZW5kNDA0KHJlcSwgcmVzKTsKKyAgICB9KTsKKyAgICBhcHAudXNlKCcvc3R5bGVzLyonLCBmdW5jdGlvbihyZXEsIHJlcywgbmV4dCkgeworICAgICAgICBmb3VyMGZvdXIuc2VuZDQwNChyZXEsIHJlcyk7CisgICAgfSk7CiAgICAgLy8gQW55IGRlZXAgbGluayBjYWxscyBzaG91bGQgcmV0dXJuIGluZGV4Lmh0bWwKICAgICBhcHAudXNlKCcvKicsIGV4cHJlc3Muc3RhdGljKCcuL2J1aWxkL2luZGV4Lmh0bWwnKSk7CiAgICAgYnJlYWs7",
"url": "https://github.com/johnpapa/generator-hottowel/commit/c17092fd4103143a9ddab93c8983ace8bf174396.patch"
}
] | null |
CVE-2022-25298
|
Path Traversal
|
This affects the package sprinfall/webcc before 0.3.0. It is possible to traverse directories to fetch arbitrary files from the server.
|
[
{
"commit_message": "[PATCH] fix static file serving security issue; fix url path encoding issue examples/CMakeLists.txt | 2 +- examples/encoding.cc | 60 -------------------------- examples/encoding.h | 12 ------ examples/url_unicode.cc | Bin 1244 -> 1256 bytes webcc/body.cc | 2 +- webcc/fs.h | 4 ++ webcc/request_parser.cc | 9 ++-- webcc/request_parser.h | 1 + webcc/router.cc | 7 ++- webcc/router.h | 4 +- webcc/server.cc | 36 ++++++++++++++-- webcc/server.h | 11 ++++- webcc/string.cc | 61 ++++++++++++++++++++++++++ webcc/string.h | 5 +++ webcc/url.cc | 93 ++++++++++++++++++++-------------------- webcc/url.h | 6 +++ webcc/utility.cc | 39 +++++++++++++++++ webcc/utility.h | 13 ++++++ 18 files changed, 227 insertions(+), 138 deletions(-) delete mode 100644 examples/encoding.cc delete mode 100644 examples/encoding.h",
"patch_text_b64": "From 55a45fd5039061d5cc62e9f1b9d1f7e97a15143f Mon Sep 17 00:00:00 2001
From: Chunting Gu <chunting.gu@outlook.com>
Date: Tue, 15 Feb 2022 22:58:33 +0800
Subject: [PATCH] fix static file serving security issue; fix url path encoding
 issue

---
 examples/CMakeLists.txt |   2 +-
 examples/encoding.cc    |  60 --------------------------
 examples/encoding.h     |  12 ------
 examples/url_unicode.cc | Bin 1244 -> 1256 bytes
 webcc/body.cc           |   2 +-
 webcc/fs.h              |   4 ++
 webcc/request_parser.cc |   9 ++--
 webcc/request_parser.h  |   1 +
 webcc/router.cc         |   7 ++-
 webcc/router.h          |   4 +-
 webcc/server.cc         |  36 ++++++++++++++--
 webcc/server.h          |  11 ++++-
 webcc/string.cc         |  61 ++++++++++++++++++++++++++
 webcc/string.h          |   5 +++
 webcc/url.cc            |  93 ++++++++++++++++++++--------------------
 webcc/url.h             |   6 +++
 webcc/utility.cc        |  39 +++++++++++++++++
 webcc/utility.h         |  13 ++++++
 18 files changed, 227 insertions(+), 138 deletions(-)
 delete mode 100644 examples/encoding.cc
 delete mode 100644 examples/encoding.h

diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 15d0245..22e91a6 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -37,7 +37,7 @@ if(WEBCC_ENABLE_SSL)
 endif()
 
 if(WIN32)
-    add_executable(url_unicode url_unicode.cc encoding.cc encoding.h)
+    add_executable(url_unicode url_unicode.cc)
     target_link_libraries(url_unicode ${EXAMPLE_LIBS})
     set_target_properties(url_unicode PROPERTIES FOLDER "Examples")
 endif()
diff --git a/examples/encoding.cc b/examples/encoding.cc
deleted file mode 100644
index 4faadea..0000000
--- a/examples/encoding.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "encoding.h"
-
-#include <Windows.h>
-
-namespace {
-
-// Wrapper for Windows API MultiByteToWideChar.
-std::wstring MB2WC(const std::string& input, unsigned int code_page) {
-  if (input.empty()) {
-    return L"";
-  }
-
-  int length = ::MultiByteToWideChar(code_page, 0, &input[0],
-                                     static_cast<int>(input.size()),
-                                     NULL, 0);
-
-  std::wstring output(length, '\0');
-
-  ::MultiByteToWideChar(code_page, 0, &input[0], static_cast<int>(input.size()),
-                        &output[0], static_cast<int>(output.size()));
-
-  return output;
-}
-
-// Wrapper for Windows API WideCharToMultiByte.
-std::string WC2MB(const std::wstring& input, unsigned int code_page) {
-  if (input.empty()) {
-    return "";
-  }
-
-  // There do have other code pages which require the flags to be 0, e.g.,
-  // 50220, 50211, and so on. But they are not included in our charset
-  // dictionary. So, only consider 65001 (UTF-8) and 54936 (GB18030).
-  DWORD flags = 0;
-  if (code_page != 65001 && code_page != 54936) {
-    flags = WC_NO_BEST_FIT_CHARS | WC_COMPOSITECHECK | WC_DEFAULTCHAR;
-  }
-
-  int length = ::WideCharToMultiByte(code_page, flags, &input[0],
-                                     static_cast<int>(input.size()), NULL, 0,
-                                     NULL, NULL);
-
-  std::string output(length, '\0');
-
-  ::WideCharToMultiByte(code_page, flags, &input[0],
-                        static_cast<int>(input.size()), &output[0],
-                        static_cast<int>(output.size()), NULL, NULL);
-
-  return output;
-}
-
-}  // namespace
-
-std::string Utf16ToUtf8(const std::wstring& utf16_string) {
-  return WC2MB(utf16_string, CP_UTF8);
-}
-
-std::wstring Utf8ToUtf16(const std::string& utf8_string) {
-  return MB2WC(utf8_string, CP_UTF8);
-}
diff --git a/examples/encoding.h b/examples/encoding.h
deleted file mode 100644
index cff9258..0000000
--- a/examples/encoding.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef ENCODING_H_
-#define ENCODING_H_
-
-#include <string>
-
-// Convert UTF16 to UTF8.
-std::string Utf16ToUtf8(const std::wstring& utf16_string);
-
-// Convert UTF8 to UTF16.
-std::wstring Utf8ToUtf16(const std::string& utf8_string);
-
-#endif  // ENCODING_H_
diff --git a/examples/url_unicode.cc b/examples/url_unicode.cc
index 6d24a8651b74e156f66e0d587f9eb2f3530b56ec..c8af0abff9c27c47f368e781dc8122ecd0431405 100644
GIT binary patch
delta 52
zcmcb^`GRx8m5K8dSc@4-7>YK2RcDeeXGmp8Vn_x;D<BL7il;FcGMF)hFywF6XI{$)
E0J}U6HUIzs

delta 48
zcmaFCd53etm5Ct|oT&_X49N`n3@ICbsxt|PGL$f+F&HwKF@ylcz`V`Y%xf6|agYsH

diff --git a/webcc/body.cc b/webcc/body.cc
index baca6b0..3800138 100644
--- a/webcc/body.cc
+++ b/webcc/body.cc
@@ -202,7 +202,7 @@ Payload FileBody::NextPayload(bool /*free_previous*/) {
 }
 
 void FileBody::Dump(std::ostream& os, const std::string& prefix) const {
-  os << prefix << "<file: " << path_.string() << ">" << std::endl;
+  os << prefix << "<file: " << path_.u8string() << ">" << std::endl;
 }
 
 bool FileBody::Move(const fs::path& new_path) {
diff --git a/webcc/fs.h b/webcc/fs.h
index 71decfb..7d6d51c 100644
--- a/webcc/fs.h
+++ b/webcc/fs.h
@@ -27,6 +27,8 @@ using std::filesystem::path;
 using std::filesystem::filesystem_error;
 
 // functions
+using std::filesystem::absolute;
+using std::filesystem::canonical;
 using std::filesystem::rename;
 using std::filesystem::remove;
 using std::filesystem::exists;
@@ -47,6 +49,8 @@ using boost::filesystem::path;
 using boost::filesystem::filesystem_error;
 
 // functions
+using boost::filesystem::absolute;
+using boost::filesystem::canonical;
 using boost::filesystem::rename;
 using boost::filesystem::remove;
 using boost::filesystem::exists;
diff --git a/webcc/request_parser.cc b/webcc/request_parser.cc
index daeec34..e226135 100644
--- a/webcc/request_parser.cc
+++ b/webcc/request_parser.cc
@@ -24,14 +24,13 @@ void RequestParser::Init(Request* request, ViewMatcher view_matcher) {
 }
 
 bool RequestParser::OnHeadersEnd() {
-  bool matched = view_matcher_(request_->method(), request_->url().path(),
-                               &stream_);
-
+  // Decode the URL path before match.
+  std::string url_path = Url::DecodeUnsafe(request_->url().path());
+  bool matched = view_matcher_(request_->method(), url_path, &stream_);
   if (!matched) {
     LOG_WARN("No view matches the request: %s %s", request_->method().c_str(),
-             request_->url().path().c_str());
+             url_path.c_str());
   }
-
   return matched;
 }
 
diff --git a/webcc/request_parser.h b/webcc/request_parser.h
index 31493fe..4afa54a 100644
--- a/webcc/request_parser.h
+++ b/webcc/request_parser.h
@@ -8,6 +8,7 @@
 
 namespace webcc {
 
+// Parameters: http_method, url_path, [out]stream
 using ViewMatcher =
     std::function<bool(const std::string&, const std::string&, bool*)>;
 
diff --git a/webcc/router.cc b/webcc/router.cc
index a87d68f..39a0e03 100644
--- a/webcc/router.cc
+++ b/webcc/router.cc
@@ -67,7 +67,7 @@ ViewPtr Router::FindView(const std::string& method, const std::string& url,
   return ViewPtr();
 }
 
-bool Router::MatchView(const std::string& method, const std::string& url,
+bool Router::MatchView(const std::string& method, const std::string& url_path,
                        bool* stream) {
   assert(stream != nullptr);
   *stream = false;
@@ -80,13 +80,12 @@ bool Router::MatchView(const std::string& method, const std::string& url,
 
     if (route.url.empty()) {
       std::smatch match;
-
-      if (std::regex_match(url, match, route.url_regex)) {
+      if (std::regex_match(url_path, match, route.url_regex)) {
         *stream = route.view->Stream(method);
         return true;
       }
     } else {
-      if (boost::iequals(route.url, url)) {
+      if (boost::iequals(route.url, url_path)) {
         *stream = route.view->Stream(method);
         return true;
       }
diff --git a/webcc/router.h b/webcc/router.h
index b4ee47e..28de5ec 100644
--- a/webcc/router.h
+++ b/webcc/router.h
@@ -28,10 +28,10 @@ class Router {
   ViewPtr FindView(const std::string& method, const std::string& url,
                    UrlArgs* args);
 
-  // Match the view by HTTP method and URL (path).
+  // Match the view by HTTP method and URL path.
   // Return if a view is matched or not.
   // If the view asks for data streaming, |stream| will be set to true.
-  bool MatchView(const std::string& method, const std::string& url,
+  bool MatchView(const std::string& method, const std::string& url_path,
                  bool* stream);
 
 private:
diff --git a/webcc/server.cc b/webcc/server.cc
index 3cbc13e..41b27ae 100644
--- a/webcc/server.cc
+++ b/webcc/server.cc
@@ -4,6 +4,8 @@
 #include <fstream>
 #include <utility>
 
+#include "boost/algorithm/string/trim.hpp"
+
 #include "webcc/body.h"
 #include "webcc/logger.h"
 #include "webcc/request.h"
@@ -32,6 +34,7 @@ Server::Server(boost::asio::ip::tcp protocol, std::uint16_t port,
       doc_root_(doc_root),
       acceptor_(io_context_),
       signals_(io_context_) {
+  CheckDocRoot();
   AddSignals();
 }
 
@@ -105,6 +108,27 @@ bool Server::IsRunning() const {
   return running_ && !io_context_.stopped();
 }
 
+void Server::CheckDocRoot() {
+  try {
+    if (!fs::exists(doc_root_) || !fs::is_directory(doc_root_)) {
+      LOG_ERRO("Doc root is not an existing directory!");
+      return;
+    }
+
+    if (doc_root_.is_relative()) {
+      doc_root_ = fs::absolute(doc_root_);
+    }
+
+    doc_root_ = fs::canonical(doc_root_);
+
+  } catch (fs::filesystem_error& e) {
+    LOG_ERRO("Doc root error: %s", e.what());
+    doc_root_.clear();
+  }
+
+  LOG_INFO("Doc root: %s", doc_root_.u8string().c_str());
+}
+
 void Server::AddSignals() {
   signals_.add(SIGINT);  // Ctrl+C
   signals_.add(SIGTERM);
@@ -314,14 +338,16 @@ void Server::Handle(ConnectionPtr connection) {
 }
 
 bool Server::MatchViewOrStatic(const std::string& method,
-                               const std::string& url, bool* stream) {
-  if (Router::MatchView(method, url, stream)) {
+                               const std::string& url_path, bool* stream) {
+  if (Router::MatchView(method, url_path, stream)) {
     return true;
   }
 
   // Try to match a static file.
   if (method == methods::kGet && !doc_root_.empty()) {
-    fs::path path = doc_root_ / url;
+    fs::path sub_path = utility::TranslatePath(url_path);
+    //LOG_INFO("Translated URL path: %s", sub_path.u8string().c_str());
+    fs::path path = doc_root_ / sub_path;
 
     fs::error_code ec;
     if (!fs::is_directory(path, ec) && fs::exists(path, ec)) {
@@ -340,7 +366,9 @@ ResponsePtr Server::ServeStatic(RequestPtr request) {
     return {};
   }
 
-  fs::path path = doc_root_ / request->url().path();
+  std::string url_path = Url::DecodeUnsafe(request->url().path());
+  fs::path sub_path = utility::TranslatePath(url_path);
+  fs::path path = doc_root_ / sub_path;
 
   try {
     // NOTE: FileBody might throw Error::kFileError.
diff --git a/webcc/server.h b/webcc/server.h
index 46f807e..d799110 100644
--- a/webcc/server.h
+++ b/webcc/server.h
@@ -61,6 +61,10 @@ class Server : public Router {
   bool IsRunning() const;
 
 private:
+  // Check if doc root is valid.
+  // Absolute it if necessary.
+  void CheckDocRoot();
+
   // Register signals which indicate when the server should exit.
   void AddSignals();
 
@@ -90,10 +94,13 @@ class Server : public Router {
   // request comes, this connection will be put back to the queue again.
   virtual void Handle(ConnectionPtr connection);
 
-  // Match the view by HTTP method and URL (path).
+  // Match the view by HTTP method and URL path.
   // Return if a view or static file is matched or not.
+  // The |url_path| has already been decoded.
+  // The |url_path| is UTF8 encoded by itself, and this is taken into account
+  // when match the static files.
   // If the view asks for data streaming, |stream| will be set to true.
-  bool MatchViewOrStatic(const std::string& method, const std::string& url,
+  bool MatchViewOrStatic(const std::string& method, const std::string& url_path,
                          bool* stream);
 
   // Serve static files from the doc root.
diff --git a/webcc/string.cc b/webcc/string.cc
index ed630b8..dba358b 100644
--- a/webcc/string.cc
+++ b/webcc/string.cc
@@ -1,11 +1,72 @@
 #include "webcc/string.h"
 
+#if (defined(_WIN32) || defined(_WIN64))
+#include <Windows.h>
+#endif
+
 #include <random>
 
 #include "boost/algorithm/string/trim.hpp"
 
 namespace webcc {
 
+#if (defined(_WIN32) || defined(_WIN64))
+
+// Wrapper for Windows API MultiByteToWideChar.
+static std::wstring MB2WC(const std::string& input, unsigned int code_page) {
+  if (input.empty()) {
+    return L"";
+  }
+
+  int length = ::MultiByteToWideChar(code_page, 0, &input[0],
+                                     static_cast<int>(input.size()),
+                                     NULL, 0);
+
+  std::wstring output(length, '\0');
+
+  ::MultiByteToWideChar(code_page, 0, &input[0], static_cast<int>(input.size()),
+                        &output[0], static_cast<int>(output.size()));
+
+  return output;
+}
+
+// Wrapper for Windows API WideCharToMultiByte.
+static std::string WC2MB(const std::wstring& input, unsigned int code_page) {
+  if (input.empty()) {
+    return "";
+  }
+
+  // There do have other code pages which require the flags to be 0, e.g.,
+  // 50220, 50211, and so on. But they are not included in our charset
+  // dictionary. So, only consider 65001 (UTF-8) and 54936 (GB18030).
+  DWORD flags = 0;
+  if (code_page != 65001 && code_page != 54936) {
+    flags = WC_NO_BEST_FIT_CHARS | WC_COMPOSITECHECK | WC_DEFAULTCHAR;
+  }
+
+  int length = ::WideCharToMultiByte(code_page, flags, &input[0],
+                                     static_cast<int>(input.size()), NULL, 0,
+                                     NULL, NULL);
+
+  std::string output(length, '\0');
+
+  ::WideCharToMultiByte(code_page, flags, &input[0],
+                        static_cast<int>(input.size()), &output[0],
+                        static_cast<int>(output.size()), NULL, NULL);
+
+  return output;
+}
+
+std::string Utf16To8(const std::wstring& utf16_string) {
+  return WC2MB(utf16_string, CP_UTF8);
+}
+
+std::wstring Utf8To16(const std::string& utf8_string) {
+  return MB2WC(utf8_string, CP_UTF8);
+}
+
+#endif  // defined(_WIN32) || defined(_WIN64)
+
 // Ref: https://stackoverflow.com/a/24586587
 std::string RandomString(std::size_t length) {
   static const char chrs[] =
diff --git a/webcc/string.h b/webcc/string.h
index 67e9635..e12a7e2 100644
--- a/webcc/string.h
+++ b/webcc/string.h
@@ -8,6 +8,11 @@
 
 namespace webcc {
 
+#if (defined(_WIN32) || defined(_WIN64))
+std::string Utf16To8(const std::wstring& utf16_string);
+std::wstring Utf8To16(const std::string& utf8_string);
+#endif
+
 // Get a randomly generated string with the given length.
 std::string RandomString(std::size_t length);
 
diff --git a/webcc/url.cc b/webcc/url.cc
index e7a006f..6dd46c9 100644
--- a/webcc/url.cc
+++ b/webcc/url.cc
@@ -29,52 +29,6 @@ bool HexToDecimal(char hex, int* decimal) {
   return true;
 }
 
-bool Decode(string_view encoded, std::string* raw) {
-  for (auto iter = encoded.begin(); iter != encoded.end(); ++iter) {
-    if (*iter == '%') {
-      if (++iter == encoded.end()) {
-        // Invalid URI string, two hexadecimal digits must follow '%'.
-        return false;
-      }
-
-      int h_decimal = 0;
-      if (!HexToDecimal(*iter, &h_decimal)) {
-        return false;
-      }
-
-      if (++iter == encoded.end()) {
-        // Invalid URI string, two hexadecimal digits must follow '%'.
-        return false;
-      }
-
-      int l_decimal = 0;
-      if (!HexToDecimal(*iter, &l_decimal)) {
-        return false;
-      }
-
-      raw->push_back(static_cast<char>((h_decimal << 4) + l_decimal));
-
-    } else if (*iter > 127 || *iter < 0) {
-      // Invalid encoded URI string, must be entirely ASCII.
-      return false;
-    } else {
-      raw->push_back(*iter);
-    }
-  }
-
-  return true;
-}
-
-// Unsafe decode.
-// Return the original string on failure.
-std::string DecodeUnsafe(string_view encoded) {
-  std::string raw;
-  if (Decode(encoded, &raw)) {
-    return raw;
-  }
-  return ToString(encoded);
-}
-
 // Encode all characters which should be encoded.
 std::string EncodeImpl(string_view raw,  // UTF8
                        std::function<bool(int)> should_encode) {
@@ -195,6 +149,50 @@ std::string Url::EncodeFull(string_view utf8_str) {
   });
 }
 
+bool Url::Decode(string_view encoded, std::string* raw) {
+  for (auto iter = encoded.begin(); iter != encoded.end(); ++iter) {
+    if (*iter == '%') {
+      if (++iter == encoded.end()) {
+        // Invalid URI string, two hexadecimal digits must follow '%'.
+        return false;
+      }
+
+      int h_decimal = 0;
+      if (!HexToDecimal(*iter, &h_decimal)) {
+        return false;
+      }
+
+      if (++iter == encoded.end()) {
+        // Invalid URI string, two hexadecimal digits must follow '%'.
+        return false;
+      }
+
+      int l_decimal = 0;
+      if (!HexToDecimal(*iter, &l_decimal)) {
+        return false;
+      }
+
+      raw->push_back(static_cast<char>((h_decimal << 4) + l_decimal));
+
+    } else if (*iter > 127 || *iter < 0) {
+      // Invalid encoded URI string, must be entirely ASCII.
+      return false;
+    } else {
+      raw->push_back(*iter);
+    }
+  }
+
+  return true;
+}
+
+std::string Url::DecodeUnsafe(string_view encoded) {
+  std::string raw;
+  if (Decode(encoded, &raw)) {
+    return raw;
+  }
+  return ToString(encoded);
+}
+
 // -----------------------------------------------------------------------------
 
 Url::Url(string_view str, bool encode) {
@@ -318,7 +316,8 @@ UrlQuery::UrlQuery(const std::string& encoded_str) {
       string_view key;
       string_view value;
       if (SplitKV(kv, '=', false, &key, &value)) {
-        parameters_.push_back({ DecodeUnsafe(key), DecodeUnsafe(value) });
+        parameters_.push_back(
+            { Url::DecodeUnsafe(key), Url::DecodeUnsafe(value) });
       }
     }
   }
diff --git a/webcc/url.h b/webcc/url.h
index 0f81b07..d1659ce 100644
--- a/webcc/url.h
+++ b/webcc/url.h
@@ -22,6 +22,12 @@ class Url {
   static std::string EncodeQuery(string_view utf8_str);
   static std::string EncodeFull(string_view utf8_str);
 
+  static bool Decode(string_view encoded, std::string* raw);
+
+  // Unsafe decode.
+  // Return the original string on failure.
+  static std::string DecodeUnsafe(string_view encoded);
+
 public:
   Url() = default;
 
diff --git a/webcc/utility.cc b/webcc/utility.cc
index 8c6ab4b..d127512 100644
--- a/webcc/utility.cc
+++ b/webcc/utility.cc
@@ -7,6 +7,8 @@
 #include <iostream>
 #include <sstream>
 
+#include "boost/algorithm/string.hpp"
+
 #include "webcc/string.h"
 #include "webcc/version.h"
 
@@ -91,5 +93,42 @@ std::string EndpointToString(const tcp::endpoint& endpoint) {
   return ss.str();
 }
 
+fs::path TranslatePath(const std::string& utf8_url_path) {
+#if (defined(_WIN32) || defined(_WIN64))
+  std::wstring url_path = Utf8To16(utf8_url_path);
+  std::vector<std::wstring> words;
+  boost::split(words, url_path, boost::is_any_of(L"/"),
+               boost::token_compress_on);
+#else
+  std::vector<std::string> words;
+  boost::split(words, utf8_url_path, boost::is_any_of("/"),
+               boost::token_compress_on);
+#endif  // defined(_WIN32) || defined(_WIN64)
+
+  fs::path path;
+  for (auto& word : words) {
+    // Ignore . and ..
+#if (defined(_WIN32) || defined(_WIN64))
+    if (word == L"." || word == L"..") {
+#else
+    if (word == "." || word == "..") {
+#endif
+      continue;
+    }
+
+    fs::path p{ word };
+
+    // Ignore C:\\, C:, path\\sub, ...
+    // parent_path() is similar to Python os.path.dirname().
+    if (!p.parent_path().empty()) {
+      continue;
+    }
+
+    path /= p;
+  }
+
+  return path;
+}
+
 }  // namespace utility
 }  // namespace webcc
diff --git a/webcc/utility.h b/webcc/utility.h
index 4270ade..f8d247c 100644
--- a/webcc/utility.h
+++ b/webcc/utility.h
@@ -39,6 +39,19 @@ void PrintEndpoint(std::ostream& ostream,
 // TCP endpoint to string.
 std::string EndpointToString(const boost::asio::ip::tcp::endpoint& endpoint);
 
+// Translate a /-separated URL path to the local (relative) path.
+// Examples:
+//   (Non-Windows)
+//   "/path/to/file" -> "path/to/file"
+//   "/path/./to/../file" -> "path/to/file" (. and .. are ignored)
+//   "/path//to//file" -> "path/to/file"
+//   (Windows)
+//   "/path/to/file" -> "path\to\file"
+//   "/path\\sub/to/file" -> "to\file" (path\\sub is ignored)
+//   "/C:\\test/path" -> "path" (C:\\test is ignored)
+// Reference: Python http/server.py translate_path()
+fs::path TranslatePath(const std::string& utf8_url_path);
+
 }  // namespace utility
 }  // namespace webcc",
"url": "https://github.com/sprinfall/webcc/commit/55a45fd5039061d5cc62e9f1b9d1f7e97a15143f.patch"
}
] |
Path Traversal
|
CVE-2025-65091
|
XWiki Full Calendar Macro vulnerable to SQL injection through Calendar.JSONService
|
XWiki Full Calendar Macro displays objects from the wiki on the calendar. Prior to version 2.4.5, users with the right to view the Calendar.JSONService page (including guest users) can exploit a SQL injection vulnerability by accessing database info or starting a DoS attack. This issue has been patched in version 2.4.5.
|
[
{
"commit_message": "[PATCH] Merge commit from fork * security fix * security fix * security fix * security fix * security fix .../src/main/resources/Calendar/JSONService.xml | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/xwiki-contrib/macro-fullcalendar/commit/5fdcf06a05015786492fda69b4d9dea5460cc994.patch"
}
] |
CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')
|
GHSA-fpgg-qjcj-58g7
| null |
[
{
"commit_message": "[PATCH] dont allow directory traversal #2 src/node/utils/Minify.js | 1 - 1 file changed, 1 deletion(-)",
"patch_text_b64": "RnJvbSAwZmE3NjUwZGY4Zjk0MGVkNmI1NzdkNzk4MzZhNzhlYjA5NzI2YzRiIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBsb3VpcyA8bG91aXNAc3lzdGVtbGkub3JnPgpEYXRlOiBTdW4sIDEyIEFwciAyMDE1IDE3OjEyOjM1ICswMjAwClN1YmplY3Q6IFtQQVRDSF0gZG9udCBhbGxvdyBkaXJlY3RvcnkgdHJhdmVyc2FsICMyCgotLS0KIHNyYy9ub2RlL3V0aWxzL01pbmlmeS5qcyB8IDEgLQogMSBmaWxlIGNoYW5nZWQsIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9zcmMvbm9kZS91dGlscy9NaW5pZnkuanMgYi9zcmMvbm9kZS91dGlscy9NaW5pZnkuanMKaW5kZXggYmE0NWFiNzVlODAuLjNiMGJlMzhjMjlkIDEwMDY0NAotLS0gYS9zcmMvbm9kZS91dGlscy9NaW5pZnkuanMKKysrIGIvc3JjL25vZGUvdXRpbHMvTWluaWZ5LmpzCkBAIC0xNjUsNyArMTY1LDYgQEAgZnVuY3Rpb24gbWluaWZ5KHJlcSwgcmVzLCBuZXh0KQogICAgICAgdmFyIHBsdWdpbiA9IHBsdWdpbnMucGx1Z2luc1tsaWJyYXJ5XTsKICAgICAgIHZhciBwbHVnaW5QYXRoID0gcGx1Z2luLnBhY2thZ2UucmVhbFBhdGg7CiAgICAgICBmaWxlbmFtZSA9IHBhdGgucmVsYXRpdmUoUk9PVF9ESVIsIHBsdWdpblBhdGggKyBsaWJyYXJ5UGF0aCk7Ci0gICAgICBmaWxlbmFtZSA9IGZpbGVuYW1lLnJlcGxhY2UoL1xcL2csICcvJyk7IC8vIFdpbmRvd3MgKHNhZmUgZ2VuZXJhbGx5PykKICAgICB9IGVsc2UgaWYgKExJQlJBUllfV0hJVEVMSVNULmluZGV4T2YobGlicmFyeSkgIT0gLTEpIHsKICAgICAgIC8vIEdvIHN0cmFpZ2h0IGludG8gbm9kZV9tb2R1bGVzCiAgICAgICAvLyBBdm9pZCBgcmVxdWlyZS5yZXNvbHZlKClgLCBzaW5jZSAnbXVzdGFjaGUnIGFuZCAnbXVzdGFjaGUvaW5kZXguanMn",
"url": "https://github.com/ether/etherpad-lite/commit/0fa7650df8f940ed6b577d79836a78eb09726c4b.patch"
}
] | null |
|
CVE-2019-13275
|
An issue was discovered in the VeronaLabs wp-statistics plugin before 12.6.7 for WordPress. The v1/hit endpoint of the API, when the non-default "use cache plugin" setting is enabled, is vulnerable to unauthenticated blind SQL Injection.
|
[
{
"commit_message": "[PATCH] Check Prepare Parameter in CURD wpdb #286 includes/class-wp-statistics-pages.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/wp-statistics/wp-statistics/commit/bd46721b97794a1b1520e24ff5023b6da738dd75.patch"
}
] |
n/a
|
|
CVE-2023-1067
|
Cross-site Scripting (XSS) - Stored in pimcore/pimcore
|
Cross-site Scripting (XSS) - Stored in GitHub repository pimcore/pimcore prior to 10.5.18.
|
[
{
"commit_message": "[PATCH] [Task] Improve GDPR email search (#14410) * improved email in toolbar * added validator to email search input .../js/pimcore/settings/gdpr/dataproviders/sentMail.js | 2 +- .../public/js/pimcore/settings/gdpr/gdprPanel.js | 9 ++++++++- 2 files changed, 9 insertions(+), 2 deletions(-)",
"patch_text_b64": "RnJvbSA0YjU3MzMyNjZkN2Q2YWViNGYyMjFhMTVlMDA1ZGI4M2ZjMTk4ZWRmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBDaHJpc3RpYW4gRiA8Y2hyaXN0aWFuLmZlbGRraXJjaG5lckBwaW1jb3JlLmNvbT4KRGF0ZTogTW9uLCAyNyBGZWIgMjAyMyAxMzoxNDo0MiArMDEwMApTdWJqZWN0OiBbUEFUQ0hdIFtUYXNrXSBJbXByb3ZlIEdEUFIgZW1haWwgc2VhcmNoICgjMTQ0MTApCgoqIGltcHJvdmVkIGVtYWlsIGluIHRvb2xiYXIKCiogYWRkZWQgdmFsaWRhdG9yIHRvIGVtYWlsIHNlYXJjaCBpbnB1dAotLS0KIC4uLi9qcy9waW1jb3JlL3NldHRpbmdzL2dkcHIvZGF0YXByb3ZpZGVycy9zZW50TWFpbC5qcyAgIHwgMiArLQogLi4uL3B1YmxpYy9qcy9waW1jb3JlL3NldHRpbmdzL2dkcHIvZ2RwclBhbmVsLmpzICAgICAgICAgfCA5ICsrKysrKysrLQogMiBmaWxlcyBjaGFuZ2VkLCA5IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYnVuZGxlcy9BZG1pbkJ1bmRsZS9SZXNvdXJjZXMvcHVibGljL2pzL3BpbWNvcmUvc2V0dGluZ3MvZ2Rwci9kYXRhcHJvdmlkZXJzL3NlbnRNYWlsLmpzIGIvYnVuZGxlcy9BZG1pbkJ1bmRsZS9SZXNvdXJjZXMvcHVibGljL2pzL3BpbWNvcmUvc2V0dGluZ3MvZ2Rwci9kYXRhcHJvdmlkZXJzL3NlbnRNYWlsLmpzCmluZGV4IGVhNDUzOTQ5OWY4Li42MmFmYjQ4ZjAyZSAxMDA2NDQKLS0tIGEvYnVuZGxlcy9BZG1pbkJ1bmRsZS9SZXNvdXJjZXMvcHVibGljL2pzL3BpbWNvcmUvc2V0dGluZ3MvZ2Rwci9kYXRhcHJvdmlkZXJzL3NlbnRNYWlsLmpzCisrKyBiL2J1bmRsZXMvQWRtaW5CdW5kbGUvUmVzb3VyY2VzL3B1YmxpYy9qcy9waW1jb3JlL3NldHRpbmdzL2dkcHIvZGF0YXByb3ZpZGVycy9zZW50TWFpbC5qcwpAQCAtMzY2LDcgKzM2Niw3IEBAIHBpbWNvcmUuc2V0dGluZ3MuZ2Rwci5kYXRhcHJvdmlkZXJzLnNlbnRNYWlsID0gQ2xhc3MuY3JlYXRlKHsKICAgICAgICAgICAgIGNsczogJ3BpbWNvcmVfbWFpbl90b29sYmFyJywKICAgICAgICAgICAgIGl0ZW1zOiBbCiAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICB0ZXh0OiB0KCJnZHByX2RhdGFTb3VyY2Vfc2VudE1haWxfb25seV9lbWFpbCIpICsgIjogIiArIHRoaXMuc2VhcmNoUGFyYW1zLmVtYWlsLAorICAgICAgICAgICAgICAgICAgICB0ZXh0OiB0KCJnZHByX2RhdGFTb3VyY2Vfc2VudE1haWxfb25seV9lbWFpbCIpICsgIjogIiArIEV4dC51dGlsLkZvcm1hdC5odG1sRW5jb2RlKHRoaXMuc2VhcmNoUGFyYW1zLmVtYWlsKSwKICAgICAgICAgICAgICAgICAgICAgeHR5cGU6ICJ0YnRleHQiLAogICAgICAgICAgICAgICAgICAgICBzdHlsZTogIm1hcmdpbjogMCAxMHB4IDAgMDsiCiAgICAgICAgICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvYnVuZGxlcy9BZG1pbkJ1bmRsZS9SZXNvdXJjZXMvcHVibGljL2pzL3BpbWNvcmUvc2V0dGluZ3MvZ2Rwci9nZHByUGFuZWwuanMgYi9idW5kbGVzL0FkbWluQnVuZGxlL1Jlc291cmNlcy9wdWJsaWMvanMvcGltY29yZS9zZXR0aW5ncy9nZHByL2dkcHJQYW5lbC5qcwppbmRleCA1OGYxODE0NDE1YS4uZmJmZWNhYTFjMDQgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvQWRtaW5CdW5kbGUvUmVzb3VyY2VzL3B1YmxpYy9qcy9waW1jb3JlL3NldHRpbmdzL2dkcHIvZ2RwclBhbmVsLmpzCisrKyBiL2J1bmRsZXMvQWRtaW5CdW5kbGUvUmVzb3VyY2VzL3B1YmxpYy9qcy9waW1jb3JlL3NldHRpbmdzL2dkcHIvZ2RwclBhbmVsLmpzCkBAIC03Niw3ICs3NiwxNCBAQCBwaW1jb3JlLnNldHRpbmdzLmdkcHIuZ2RwclBhbmVsID0gQ2xhc3MuY3JlYXRlKHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4dHlwZTogJ3RleHRmaWVsZCcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbmFtZTogJ2VtYWlsJywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmaWVsZExhYmVsOiB0KCJnZHByX2RhdGFfZXh0cmFjdG9yX2xhYmVsX2VtYWlsIiksCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgd2lkdGg6IDY1MAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHdpZHRoOiA2NTAsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgdmFsaWRhdG9yOiBmdW5jdGlvbiAodmFsdWUpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYodmFsdWUgIT09IHZhbHVlLnJlcGxhY2UoL1teYS16QS1aMC05X1wtQC5dL2csJycpKXsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRoaXMuc2V0VmFsdWUodmFsdWUucmVwbGFjZSgvW15hLXpBLVowLTlfXC1ALl0vZywnJykpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4dHlwZTogImJ1dHRvbiIs",
"url": "https://github.com/pimcore/pimcore/commit/4b5733266d7d6aeb4f221a15e005db83fc198edf.patch"
}
] |
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
GHSA-wfcc-pff6-rgc5
|
Jetty vulnerable to exposure of sensitive information due to observable discrepancy
| null |
[
{
"commit_message": "[PATCH] Fixes #1556 - A timing channel in Password.java. .../jaspi/modules/DigestAuthModule.java | 3 +- .../authentication/DigestAuthenticator.java | 2 +- .../jetty/util/security/Credential.java | 57 ++++++++++++++----- .../eclipse/jetty/util/security/Password.java | 25 ++++---- 4 files changed, 57 insertions(+), 30 deletions(-)",
"patch_text_b64": "From 042f325f1cd6e7891d72c7e668f5947b5457dc02 Mon Sep 17 00:00:00 2001
From: Simone Bordet <simone.bordet@gmail.com>
Date: Tue, 16 May 2017 10:41:08 +0200
Subject: [PATCH] Fixes #1556 - A timing channel in Password.java.

---
 .../jaspi/modules/DigestAuthModule.java       |  3 +-
 .../authentication/DigestAuthenticator.java   |  2 +-
 .../jetty/util/security/Credential.java       | 57 ++++++++++++++-----
 .../eclipse/jetty/util/security/Password.java | 25 ++++----
 4 files changed, 57 insertions(+), 30 deletions(-)

diff --git a/jetty-jaspi/src/main/java/org/eclipse/jetty/security/jaspi/modules/DigestAuthModule.java b/jetty-jaspi/src/main/java/org/eclipse/jetty/security/jaspi/modules/DigestAuthModule.java
index afe3bcf1adc6..54ad4f062a10 100644
--- a/jetty-jaspi/src/main/java/org/eclipse/jetty/security/jaspi/modules/DigestAuthModule.java
+++ b/jetty-jaspi/src/main/java/org/eclipse/jetty/security/jaspi/modules/DigestAuthModule.java
@@ -341,7 +341,7 @@ public boolean check(Object credentials)
                 byte[] digest = md.digest();
 
                 // check digest
-                return (TypeUtil.toString(digest, 16).equalsIgnoreCase(response));
+                return stringEquals(TypeUtil.toString(digest, 16).toLowerCase(), response == null ? null : response.toLowerCase());
             }
             catch (Exception e)
             {
@@ -356,6 +356,5 @@ public String toString()
         {
             return username + "," + response;
         }
-
     }
 }
diff --git a/jetty-security/src/main/java/org/eclipse/jetty/security/authentication/DigestAuthenticator.java b/jetty-security/src/main/java/org/eclipse/jetty/security/authentication/DigestAuthenticator.java
index a982f56aa6b4..450556701199 100644
--- a/jetty-security/src/main/java/org/eclipse/jetty/security/authentication/DigestAuthenticator.java
+++ b/jetty-security/src/main/java/org/eclipse/jetty/security/authentication/DigestAuthenticator.java
@@ -401,7 +401,7 @@ public boolean check(Object credentials)
                 byte[] digest = md.digest();
 
                 // check digest
-                return (TypeUtil.toString(digest, 16).equalsIgnoreCase(response));
+                return stringEquals(TypeUtil.toString(digest, 16).toLowerCase(), response == null ? null : response.toLowerCase());
             }
             catch (Exception e)
             {
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/security/Credential.java b/jetty-util/src/main/java/org/eclipse/jetty/util/security/Credential.java
index 9b855faf0926..77692d35c4ba 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/security/Credential.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/security/Credential.java
@@ -71,6 +71,44 @@ public static Credential getCredential(String credential)
         return new Password(credential);
     }
 
+    /**
+     * <p>Utility method that replaces String.equals() to avoid timing attacks.</p>
+     *
+     * @param s1 the first string to compare
+     * @param s2 the second string to compare
+     * @return whether the two strings are equal
+     */
+    protected static boolean stringEquals(String s1, String s2)
+    {
+        if (s1 == s2)
+            return true;
+        if (s1 == null || s2 == null || s1.length() != s2.length())
+            return false;
+        boolean result = false;
+        for (int i = 0; i < s1.length(); i++)
+            result |= s1.charAt(i) == s2.charAt(i);
+        return result;
+    }
+
+    /**
+     * <p>Utility method that replaces Arrays.equals() to avoid timing attacks.</p>
+     *
+     * @param b1 the first byte array to compare
+     * @param b2 the second byte array to compare
+     * @return whether the two byte arrays are equal
+     */
+    protected static boolean byteEquals(byte[] b1, byte[] b2)
+    {
+        if (b1 == b2)
+            return true;
+        if (b1 == null || b2 == null || b1.length != b2.length)
+            return false;
+        boolean result = false;
+        for (int i = 0; i < b1.length; i++)
+            result |= b1[i] == b2[i];
+        return result;
+    }
+
     /**
      * Unix Crypt Credentials
      */
@@ -93,8 +131,7 @@ public boolean check(Object credentials)
                 credentials=new String((char[])credentials);
             if (!(credentials instanceof String) && !(credentials instanceof Password)) 
                 LOG.warn("Can't check " + credentials.getClass() + " against CRYPT");
-            String passwd = credentials.toString();
-            return _cooked.equals(UnixCrypt.crypt(passwd, _cooked));
+            return stringEquals(_cooked, UnixCrypt.crypt(credentials.toString(), _cooked));
         }
 
         public static String crypt(String user, String pw)
@@ -143,26 +180,18 @@ public boolean check(Object credentials)
                         __md.update(credentials.toString().getBytes(StandardCharsets.ISO_8859_1));
                         digest = __md.digest();
                     }
-                    if (digest == null || digest.length != _digest.length) return false;
-                    boolean digestMismatch = false;
-                    for (int i = 0; i < digest.length; i++)
-                        digestMismatch |= (digest[i] != _digest[i]);
-                    return !digestMismatch;
+                    return byteEquals(_digest, digest);
                 }
                 else if (credentials instanceof MD5)
                 {
-                    MD5 md5 = (MD5) credentials;
-                    if (_digest.length != md5._digest.length) return false;
-                    boolean digestMismatch = false;
-                    for (int i = 0; i < _digest.length; i++)
-                        digestMismatch |= (_digest[i] != md5._digest[i]);
-                    return !digestMismatch;
+                    MD5 md5 = (MD5)credentials;
+                    return byteEquals(_digest, md5._digest);
                 }
                 else if (credentials instanceof Credential)
                 {
                     // Allow credential to attempt check - i.e. this'll work
                     // for DigestAuthModule$Digest credentials
-                    return ((Credential) credentials).check(this);
+                    return ((Credential)credentials).check(this);
                 }
                 else
                 {
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/security/Password.java b/jetty-util/src/main/java/org/eclipse/jetty/util/security/Password.java
index 81ff1b92bd03..fe7839bf4e0a 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/security/Password.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/security/Password.java
@@ -20,7 +20,6 @@
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
 import java.util.Locale;
 
 import org.eclipse.jetty.util.log.Log;
@@ -96,15 +95,20 @@ public String toStarString()
     @Override
     public boolean check(Object credentials)
     {
-        if (this == credentials) return true;
+        if (this == credentials)
+            return true;
 
-        if (credentials instanceof Password) return credentials.equals(_pw);
+        if (credentials instanceof Password)
+            return credentials.equals(_pw);
 
-        if (credentials instanceof String) return credentials.equals(_pw);
+        if (credentials instanceof String)
+            return stringEquals(_pw, (String)credentials);
 
-        if (credentials instanceof char[]) return Arrays.equals(_pw.toCharArray(), (char[]) credentials);
+        if (credentials instanceof char[])
+            return stringEquals(_pw, new String((char[])credentials));
 
-        if (credentials instanceof Credential) return ((Credential) credentials).check(_pw);
+        if (credentials instanceof Credential)
+            return ((Credential)credentials).check(_pw);
 
         return false;
     }
@@ -120,14 +124,10 @@ public boolean equals(Object o)
             return false;
 
         if (o instanceof Password)
-        {
-            Password p = (Password) o;
-            //noinspection StringEquality
-            return p._pw == _pw || (null != _pw && _pw.equals(p._pw));
-        }
+            return stringEquals(_pw, ((Password)o)._pw);
 
         if (o instanceof String)
-            return o.equals(_pw);
+            return stringEquals(_pw, (String)o);
 
         return false;
     }
@@ -175,7 +175,6 @@ public static String obfuscate(String s)
 
         }
         return buf.toString();
-
     }
 
     /* ------------------------------------------------------------ */",
"url": "https://github.com/eclipse/jetty.project/commit/042f325f1cd6e7891d72c7e668f5947b5457dc02.patch"
}
] | null |
CVE-2018-14016
|
The r_bin_mdmp_init_directory_entry function in mdmp.c in radare2 2.7.0 allows remote attackers to cause a denial of service (heap-based buffer over-read and application crash) via a crafted Mini Crash Dump file.
|
[
{
"commit_message": "[PATCH] Fix #10464 - oobread crash in mdmp (#10683) libr/bin/format/mdmp/mdmp.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/radareorg/radare2/commit/eb7deb281df54771fb8ecf5890dc325a7d22d3e2.patch"
}
] |
n/a
|
|
CVE-2023-4750
|
Use After Free in vim/vim
|
Use After Free in GitHub repository vim/vim prior to 9.0.1857.
|
[
{
"commit_message": "[PATCH] patch 9.0.1857: [security] heap-use-after-free in is_qf_win() Problem: heap-use-after-free in is_qf_win() Solution: Check buffer is valid before accessing it Signed-off-by: Christian Brabandt <[email protected]> src/main.c | 2 +- src/quickfix.c | 2 +- src/testdir/crash/bt_quickfix_poc | 9 ++++++++ src/testdir/test_crash.vim | 34 ++++++++++++++++++++++++------- src/version.c | 2 ++ 5 files changed, 40 insertions(+), 9 deletions(-) create mode 100644 src/testdir/crash/bt_quickfix_poc",
"patch_text_b64": "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",
"url": "https://github.com/vim/vim/commit/fc68299d436cf87453e432daa77b6d545df4d7ed.patch"
}
] |
CWE-416 Use After Free
|
CVE-2016-15010
|
University of Cambridge django-ucamlookup Lookup cross site scripting
|
** UNSUPPORTED WHEN ASSIGNED ** A vulnerability classified as problematic was found in University of Cambridge django-ucamlookup up to 1.9.1. Affected by this vulnerability is an unknown functionality of the component Lookup Handler. The manipulation leads to cross site scripting. The attack can be launched remotely. Upgrading to version 1.9.2 is able to address this issue. The identifier of the patch is 5e25e4765637ea4b9e0bf5fcd5e9a922abee7eb3. It is recommended to upgrade the affected component. The identifier VDB-217441 was assigned to this vulnerability. NOTE: This vulnerability only affects products that are no longer supported by the maintainer.
|
[
{
"commit_message": "[PATCH] Fix lack of escaping (and so XSS vuln.) in select2 calls The invocation of Jquery select2 to provide searchable dropdowns didn't sanitise data coming fom lookup, with the result that any HTML markup it contained, including <script>...</script>, was interpreted. The documentation is difficult to follow, but indications are that the formater functions (at least formatResult and formatSelection), if overriden have to do their own escaping of data as necessary. They are however passed the current global 'escapeMarkup' function as their final parameter. .../templates/admin/auth/lookup_group/add_form.html | 12 +++++------- .../templates/admin/auth/lookup_user/add_form.html | 12 +++++------- ucamlookup/templates/ucamlookup_groups.html | 12 +++++------- ucamlookup/templates/ucamlookup_users.html | 12 +++++------- 4 files changed, 20 insertions(+), 28 deletions(-)",
"patch_text_b64": "From 5e25e4765637ea4b9e0bf5fcd5e9a922abee7eb3 Mon Sep 17 00:00:00 2001
From: Jon Warbrick <jw35@cam.ac.uk>
Date: Wed, 14 Sep 2016 15:54:06 +0100
Subject: [PATCH] Fix lack of escaping (and so XSS vuln.) in select2 calls

The invocation of Jquery select2 to provide searchable dropdowns
didn't sanitise data coming fom lookup, with the result that any
HTML markup it contained, including <script>...</script>, was
interpreted.

The documentation is difficult to follow, but indications are that the
formater functions (at least formatResult and formatSelection), if
overriden have to do their own escaping of data as necessary. They are
however passed the current global 'escapeMarkup' function as their
final parameter.
---
 .../templates/admin/auth/lookup_group/add_form.html  | 12 +++++-------
 .../templates/admin/auth/lookup_user/add_form.html   | 12 +++++-------
 ucamlookup/templates/ucamlookup_groups.html          | 12 +++++-------
 ucamlookup/templates/ucamlookup_users.html           | 12 +++++-------
 4 files changed, 20 insertions(+), 28 deletions(-)

diff --git a/ucamlookup/templates/admin/auth/lookup_group/add_form.html b/ucamlookup/templates/admin/auth/lookup_group/add_form.html
index 3db4956..ab9c13e 100644
--- a/ucamlookup/templates/admin/auth/lookup_group/add_form.html
+++ b/ucamlookup/templates/admin/auth/lookup_group/add_form.html
@@ -47,20 +47,18 @@
                     return {results: data.groups};
                 }
             },
-            formatResult: function(group) {
-                return group.title;
+            formatResult: function(group, container, query, escapeMarkup) {
+                return escapeMarkup(group.title);
             },
-            formatSelection: function(group) {
-                return group.title;
+            formatSelection: function(group, container, escapeMarkup) {
+                return escapeMarkup(group.title);
             },
             id: function(group) {
                 return group.groupid;
             },
             dropdownCssClass: "bigdrop", // apply css that makes the dropdown taller
-            escapeMarkup: function (m) { return m; },
-            // we do not want to escape markup since we are displaying html in results
             width: '100%'
         });
     });
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/ucamlookup/templates/admin/auth/lookup_user/add_form.html b/ucamlookup/templates/admin/auth/lookup_user/add_form.html
index c4081e4..26d7576 100644
--- a/ucamlookup/templates/admin/auth/lookup_user/add_form.html
+++ b/ucamlookup/templates/admin/auth/lookup_user/add_form.html
@@ -46,20 +46,18 @@
                     return {results: data.persons};
                 }
             },
-            formatResult: function(person) {
-                return person.visibleName+" ("+person.crsid+") ";
+            formatResult: function(person, container, query, escapeMarkup) {
+                return escapeMarkup(person.visibleName+" ("+person.crsid+") ");
             },
-            formatSelection: function(person) {
-                return person.visibleName+" ("+person.crsid+") ";
+            formatSelection: function(person, container, escapeMarkup) {
+                return escapeMarkup(person.visibleName+" ("+person.crsid+") ");
             },
             id: function(person) {
                 return person.crsid;
             },
             dropdownCssClass: "bigdrop", // apply css that makes the dropdown taller
-            escapeMarkup: function (m) { return m; },
-            // we do not want to escape markup since we are displaying html in results
             width: '50%'
         });
     });
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/ucamlookup/templates/ucamlookup_groups.html b/ucamlookup/templates/ucamlookup_groups.html
index 6d95f26..5b7dc92 100644
--- a/ucamlookup/templates/ucamlookup_groups.html
+++ b/ucamlookup/templates/ucamlookup_groups.html
@@ -25,18 +25,16 @@
                     return {results: data.groups};
                 }
             },
-            formatResult: function(group) {
-                return group.title;
+            formatResult: function(group, container, query, escapeMarkup) {
+                return escapeMarkup(group.title);
             },
-            formatSelection: function(group) {
-                return group.title;
+            formatSelection: function(group, container, escapeMarkup) {
+                return escapeMarkup(group.title);
             },
             id: function(group) {
                 return group.groupid;
             },
             dropdownCssClass: "bigdrop", // apply css that makes the dropdown taller
-            escapeMarkup: function (m) { return m; }
-            // we do not want to escape markup since we are displaying html in results
         });
 
         $("#{{ input_tag_id }}").select2("data", [
@@ -48,4 +46,4 @@
             {% endfor %}
         ]);
     });
-</script>
\ No newline at end of file
+</script>
diff --git a/ucamlookup/templates/ucamlookup_users.html b/ucamlookup/templates/ucamlookup_users.html
index 94317ce..6c8b44e 100644
--- a/ucamlookup/templates/ucamlookup_users.html
+++ b/ucamlookup/templates/ucamlookup_users.html
@@ -25,18 +25,16 @@
                     return {results: data.persons};
                 }
             },
-            formatResult: function(person) {
-                return person.visibleName+" ("+person.crsid+") ";
+            formatResult: function(person, container, wuery, escapeMarkup) {
+                return escapeMarkup(person.visibleName+" ("+person.crsid+") ");
             },
-            formatSelection: function(person) {
-                return person.visibleName+" ("+person.crsid+") ";
+            formatSelection: function(person, container, escapeMarkup) {
+                return escapeMarkup(person.visibleName+" ("+person.crsid+") ");
             },
             id: function(person) {
                 return person.crsid;
             },
             dropdownCssClass: "bigdrop", // apply css that makes the dropdown taller
-            escapeMarkup: function (m) { return m; }
-            // we do not want to escape markup since we are displaying html in results
         });
 
         $("#{{ input_tag_id }}").select2("data", [
@@ -51,4 +49,4 @@
             {% endfor %}
         ]);
     });
-</script>
\ No newline at end of file
+</script>",
"url": "https://github.com/uisautomation/django-ucamlookup/commit/5e25e4765637ea4b9e0bf5fcd5e9a922abee7eb3.patch"
}
] |
CWE-79 Cross Site Scripting
|
GHSA-3jh2-wmv7-m932
|
LibreNMS stored Cross-site Scripting via Schedule Maintenance `Title` parameter
| null |
[
{
"commit_message": "[PATCH] Fix scheduled maintenance xss (#14360) Fix for fields title, notes, and maybe recurring_day. Other fields can't store html. https://huntr.dev/bounties/bcb6ee68-1452-4fdb-932a-f1031d10984f/ app/Http/Controllers/Table/AlertScheduleController.php | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/librenms/librenms/commit/08050020861230ff96a6507b309cc172a9e70af8.patch"
}
] | null |
GHSA-8cxx-7fx3-j6xj
| null |
[
{
"commit_message": "[PATCH] Fix for #519 #520 #521 plugins/codecs/zfp/blosc2-zfp.c | 6 ++++++ 1 file changed, 6 insertions(+)",
"patch_text_b64": "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",
"url": "https://github.com/Blosc/c-blosc2/commit/425e8a9a59d49378d57e2116b6c9b0190a5986f5.patch"
}
] | null |
|
GHSA-6673-4983-2vx5
|
fonttools XML External Entity Injection (XXE) Vulnerability
| null |
[
{
"commit_message": "[PATCH] subset: parse OT-SVG with resolve_entities=False to guard against XXE attacks as recommended in https://codeql.github.com/codeql-query-help/python/py-xxe/ Lib/fontTools/subset/svg.py | 3 +++ 1 file changed, 3 insertions(+)",
"patch_text_b64": "RnJvbSA5ZjYxMjcxZGMxY2E4MmVkOTFmNTI5YjEzMGZlNWRjNWM5YmYxZjRjIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBDb3NpbW8gTHVwbyA8Y2x1cG9AZ29vZ2xlLmNvbT4KRGF0ZTogRnJpLCAxNSBTZXAgMjAyMyAxNjo1MDozOCArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIHN1YnNldDogcGFyc2UgT1QtU1ZHIHdpdGggcmVzb2x2ZV9lbnRpdGllcz1GYWxzZQoKdG8gZ3VhcmQgYWdhaW5zdCBYWEUgYXR0YWNrcyBhcyByZWNvbW1lbmRlZCBpbiBodHRwczovL2NvZGVxbC5naXRodWIuY29tL2NvZGVxbC1xdWVyeS1oZWxwL3B5dGhvbi9weS14eGUvCi0tLQogTGliL2ZvbnRUb29scy9zdWJzZXQvc3ZnLnB5IHwgMyArKysKIDEgZmlsZSBjaGFuZ2VkLCAzIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9MaWIvZm9udFRvb2xzL3N1YnNldC9zdmcucHkgYi9MaWIvZm9udFRvb2xzL3N1YnNldC9zdmcucHkKaW5kZXggZjZkNzRhNDAwMi4uMmU1NWJmNTRjMCAxMDA2NDQKLS0tIGEvTGliL2ZvbnRUb29scy9zdWJzZXQvc3ZnLnB5CisrKyBiL0xpYi9mb250VG9vbHMvc3Vic2V0L3N2Zy5weQpAQCAtMjI1LDYgKzIyNSw5IEBAIGRlZiBzdWJzZXRfZ2x5cGhzKHNlbGYsIHMpIC0+IGJvb2w6CiAgICAgICAgICAgICAgICAgIyBpZ25vcmUgYmxhbmsgdGV4dCBhcyBpdCdzIG5vdCBtZWFuaW5nZnVsIGluIE9ULVNWRzsgaXQgYWxzbyBwcmV2ZW50cwogICAgICAgICAgICAgICAgICMgZGFuZ2xpbmcgdGFpbCB0ZXh0IGFmdGVyIHJlbW92aW5nIGFuIGVsZW1lbnQgd2hlbiBwcmV0dHlfcHJpbnQ9VHJ1ZQogICAgICAgICAgICAgICAgIHJlbW92ZV9ibGFua190ZXh0PVRydWUsCisgICAgICAgICAgICAgICAgIyBkb24ndCByZXBsYWNlIGVudGl0aWVzOyB3ZSBkb24ndCBleHBlY3QgYW55IGluIE9ULVNWRyBhbmQgdGhleSBtYXkKKyAgICAgICAgICAgICAgICAjIGFib3VzZWQgZm9yIFhYRSBhdHRhY2tzCisgICAgICAgICAgICAgICAgcmVzb2x2ZV9lbnRpdGllcz1GYWxzZSwKICAgICAgICAgICAgICksCiAgICAgICAgICk=",
"url": "https://github.com/fonttools/fonttools/commit/9f61271dc1ca82ed91f529b130fe5dc5c9bf1f4c.patch"
}
] | null |
CVE-2021-29549
|
Division by 0 in `QuantizedAdd`
|
TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a runtime division by zero error and denial of service in `tf.raw_ops.QuantizedBatchNormWithGlobalNormalization`. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/6f26b3f3418201479c264f2a02000880d8df151c/tensorflow/core/kernels/quantized_add_op.cc#L289-L295) computes a modulo operation without validating that the divisor is not zero. Since `vector_num_elements` is determined based on input shapes(https://github.com/tensorflow/tensorflow/blob/6f26b3f3418201479c264f2a02000880d8df151c/tensorflow/core/kernels/quantized_add_op.cc#L522-L544), a user can trigger scenarios where this quantity is 0. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range.
|
[
{
"commit_message": "[PATCH] Validate work in `QuantizedAdd`, ensure at least one element. PiperOrigin-RevId: 370127996 Change-Id: I57c6f3e01afdeada84737820a131590137463855 tensorflow/core/kernels/quantized_add_op.cc | 2 ++ 1 file changed, 2 insertions(+)",
"patch_text_b64": "RnJvbSA3NDQwMDljOWU1Y2M1ZDA0NDdmMGRjMzlkMDU1ZjkxN2UxZmQ5ZTE2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWhhaSBNYXJ1c2VhYyA8bWloYWltYXJ1c2VhY0Bnb29nbGUuY29tPgpEYXRlOiBGcmksIDIzIEFwciAyMDIxIDEyOjAwOjEyIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gVmFsaWRhdGUgd29yayBpbiBgUXVhbnRpemVkQWRkYCwgZW5zdXJlIGF0IGxlYXN0IG9uZSBlbGVtZW50LgoKUGlwZXJPcmlnaW4tUmV2SWQ6IDM3MDEyNzk5NgpDaGFuZ2UtSWQ6IEk1N2M2ZjNlMDFhZmRlYWRhODQ3Mzc4MjBhMTMxNTkwMTM3NDYzODU1Ci0tLQogdGVuc29yZmxvdy9jb3JlL2tlcm5lbHMvcXVhbnRpemVkX2FkZF9vcC5jYyB8IDIgKysKIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS90ZW5zb3JmbG93L2NvcmUva2VybmVscy9xdWFudGl6ZWRfYWRkX29wLmNjIGIvdGVuc29yZmxvdy9jb3JlL2tlcm5lbHMvcXVhbnRpemVkX2FkZF9vcC5jYwppbmRleCA1NWM2OWRlN2QzZWE2Yy4uYjE4NmYwMGYxNWMwNjEgMTAwNjQ0Ci0tLSBhL3RlbnNvcmZsb3cvY29yZS9rZXJuZWxzL3F1YW50aXplZF9hZGRfb3AuY2MKKysrIGIvdGVuc29yZmxvdy9jb3JlL2tlcm5lbHMvcXVhbnRpemVkX2FkZF9vcC5jYwpAQCAtNTM4LDYgKzUzOCw4IEBAIGNsYXNzIFF1YW50aXplZEFkZE9wIDogcHVibGljIE9wS2VybmVsIHsKICAgICAgICAgdGVuc29yX21pbiA9IG1pbl94OwogICAgICAgICB0ZW5zb3JfbWF4ID0gbWF4X3g7CiAgICAgICB9CisgICAgICBPUF9SRVFVSVJFUyhjb250ZXh0LCB2ZWN0b3JfbnVtX2VsZW1lbnRzID4gMCwKKyAgICAgICAgICAgICAgICAgIGVycm9yczo6SW52YWxpZEFyZ3VtZW50KCJNdXN0IGhhdmUgc29tZSBlbGVtZW50cyB0byBhZGQiKSk7CiAgICAgICBWZWN0b3JUZW5zb3JBZGRpdGlvbjxULCBUb3V0cHV0PigKICAgICAgICAgICB2ZWN0b3JfZGF0YSwgdmVjdG9yX21pbiwgdmVjdG9yX21heCwgdmVjdG9yX251bV9lbGVtZW50cywgdGVuc29yX2RhdGEsCiAgICAgICAgICAgdGVuc29yX21pbiwgdGVuc29yX21heCwgdGVuc29yX251bV9lbGVtZW50cywgbWluX3pfdmFsdWUsIG1heF96X3ZhbHVlLA==",
"url": "https://github.com/tensorflow/tensorflow/commit/744009c9e5cc5d0447f0dc39d055f917e1fd9e16.patch"
}
] |
CWE-369: Divide By Zero
|
CVE-2020-23915
|
An issue was discovered in cpp-peglib through v0.1.12. peg::resolve_escape_sequence() in peglib.h has a heap-based buffer over-read.
|
[
{
"commit_message": "[PATCH] Fix #122 peglib.h | 6 +++--- test/test1.cc | 11 +++++++++++ 2 files changed, 14 insertions(+), 3 deletions(-)",
"patch_text_b64": "RnJvbSBiM2IyOWNlOGYzYWNmM2EzMjczM2Q5MzAxMDVhMTdkN2IwYmEzNDdlIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiB5aGlyb3NlIDx5dWppLmhpcm9zZS5idWdAZ21haWwuY29tPgpEYXRlOiBGcmksIDcgQXVnIDIwMjAgMTM6MzU6NDggLTA0MDAKU3ViamVjdDogW1BBVENIXSBGaXggIzEyMgoKLS0tCiBwZWdsaWIuaCAgICAgIHwgIDYgKysrLS0tCiB0ZXN0L3Rlc3QxLmNjIHwgMTEgKysrKysrKysrKysKIDIgZmlsZXMgY2hhbmdlZCwgMTQgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9wZWdsaWIuaCBiL3BlZ2xpYi5oCmluZGV4IGZjOTQ5ZGUuLjg5ZjlhYmMgMTAwNjQ0Ci0tLSBhL3BlZ2xpYi5oCisrKyBiL3BlZ2xpYi5oCkBAIC0xODAsMTEgKzE4MCwxMSBAQCBpbmxpbmUgc2l6ZV90IGNvZGVwb2ludF9sZW5ndGgoY29uc3QgY2hhciAqczgsIHNpemVfdCBsKSB7CiAgICAgYXV0byBiID0gc3RhdGljX2Nhc3Q8dWludDhfdD4oczhbMF0pOwogICAgIGlmICgoYiAmIDB4ODApID09IDApIHsKICAgICAgIHJldHVybiAxOwotICAgIH0gZWxzZSBpZiAoKGIgJiAweEUwKSA9PSAweEMwKSB7CisgICAgfSBlbHNlIGlmICgoYiAmIDB4RTApID09IDB4QzAgJiYgbCA+PSAyKSB7CiAgICAgICByZXR1cm4gMjsKLSAgICB9IGVsc2UgaWYgKChiICYgMHhGMCkgPT0gMHhFMCkgeworICAgIH0gZWxzZSBpZiAoKGIgJiAweEYwKSA9PSAweEUwICYmIGwgPj0gMykgewogICAgICAgcmV0dXJuIDM7Ci0gICAgfSBlbHNlIGlmICgoYiAmIDB4RjgpID09IDB4RjApIHsKKyAgICB9IGVsc2UgaWYgKChiICYgMHhGOCkgPT0gMHhGMCAmJiBsID49IDQpIHsKICAgICAgIHJldHVybiA0OwogICAgIH0KICAgfQpkaWZmIC0tZ2l0IGEvdGVzdC90ZXN0MS5jYyBiL3Rlc3QvdGVzdDEuY2MKaW5kZXggMzJlNjcwNi4uYTU4M2U4MSAxMDA2NDQKLS0tIGEvdGVzdC90ZXN0MS5jYworKysgYi90ZXN0L3Rlc3QxLmNjCkBAIC00NSw2ICs0NSwxNyBAQCBURVNUX0NBU0UoIlN0YXJ0IHJ1bGUgd2l0aCBpZ25vcmUgb3BlcmF0b3IgdGVzdCIsICJbZ2VuZXJhbF0iKQogICAgIFJFUVVJUkUocmV0ID09IGZhbHNlKTsKIH0KIAorVEVTVF9DQVNFKCJJbnZhbGlkIFVURi04IHRleHQgdGVzdCIsICJbZ2VuZXJhbF0iKQoreworICAgIHN0ZDo6c3RyaW5nIHMgPSAiYSA8LSAnIjsKKyAgICBzICs9IHN0YXRpY19jYXN0PGNoYXI+KDB4ZTgpOyAvLyBNYWtlIGludmFsaWQgdXRmOCB0ZXh0Li4uCisKKyAgICBwYXJzZXIgcGFyc2VyKHMuY19zdHIoKSk7CisKKyAgICBib29sIHJldCA9IHBhcnNlcjsKKyAgICBSRVFVSVJFKHJldCA9PSBmYWxzZSk7Cit9CisKIFRFU1RfQ0FTRSgiQmFja3NsYXNoIGVzY2FwZSBzZXF1ZW5jZSB0ZXN0IiwgIltnZW5lcmFsXSIpCiB7CiAgICAgcGFyc2VyIHBhcnNlcihSIig=",
"url": "https://github.com/yhirose/cpp-peglib/commit/b3b29ce8f3acf3a32733d930105a17d7b0ba347e.patch"
}
] |
n/a
|
|
CVE-2024-4030
|
tempfile.mkdtemp() may be readable and writeable by all users on Windows
|
On Windows a directory returned by tempfile.mkdtemp() would not always have permissions set to restrict reading and writing to the temporary directory by other users, instead usually inheriting the correct permissions from the default location. Alternate configurations or users without a profile directory may not have the intended permissions.
If you’re not using Windows or haven’t changed the temporary directory location then you aren’t affected by this vulnerability. On other platforms the returned directory is consistently readable and writable only by the current user.
This issue was caused by Python not supporting Unix permissions on Windows. The fix adds support for Unix “700” for the mkdir function on Windows which is used by mkdtemp() to ensure the newly created directory has the proper permissions.
|
[
{
"commit_message": "[PATCH] gh-118486: Support mkdir(mode=0o700) on Windows (GH-118488) Doc/library/os.rst | 7 + Lib/test/test_os.py | 19 +++ Lib/test/test_tempfile.py | 28 ++++ ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst | 2 + Modules/posixmodule.c | 158 +++++++++++++++++- 5 files changed, 212 insertions(+), 2 deletions(-) create mode 100644 Misc/NEWS.d/next/Windows/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst",
"patch_text_b64": "From 81939dad77001556c527485d31a2d0f4a759033e Mon Sep 17 00:00:00 2001
From: Steve Dower <steve.dower@python.org>
Date: Thu, 2 May 2024 15:20:43 +0100
Subject: [PATCH] gh-118486: Support mkdir(mode=0o700) on Windows (GH-118488)

---
 Doc/library/os.rst                            |   7 +
 Lib/test/test_os.py                           |  19 +++
 Lib/test/test_tempfile.py                     |  28 ++++
 ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst |   2 +
 Modules/posixmodule.c                         | 158 +++++++++++++++++-
 5 files changed, 212 insertions(+), 2 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Windows/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst

diff --git a/Doc/library/os.rst b/Doc/library/os.rst
index 844b5f26d8d4d1..6c92eed9c063f1 100644
--- a/Doc/library/os.rst
+++ b/Doc/library/os.rst
@@ -2430,6 +2430,10 @@ features:
    platform-dependent.  On some platforms, they are ignored and you should call
    :func:`chmod` explicitly to set them.
 
+   On Windows, a *mode* of ``0o700`` is specifically handled to apply access
+   control to the new directory such that only the current user and
+   administrators have access. Other values of *mode* are ignored.
+
    This function can also support :ref:`paths relative to directory descriptors
    <dir_fd>`.
 
@@ -2444,6 +2448,9 @@ features:
    .. versionchanged:: 3.6
       Accepts a :term:`path-like object`.
 
+   .. versionchanged:: 3.13
+      Windows now handles a *mode* of ``0o700``.
+
 
 .. function:: makedirs(name, mode=0o777, exist_ok=False)
 
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index eaa676673f8af0..9c9c8536dc7542 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -1811,6 +1811,25 @@ def test_exist_ok_existing_regular_file(self):
         self.assertRaises(OSError, os.makedirs, path, exist_ok=True)
         os.remove(path)
 
+    @unittest.skipUnless(os.name == 'nt', "requires Windows")
+    def test_win32_mkdir_700(self):
+        base = os_helper.TESTFN
+        path1 = os.path.join(os_helper.TESTFN, 'dir1')
+        path2 = os.path.join(os_helper.TESTFN, 'dir2')
+        # mode=0o700 is special-cased to override ACLs on Windows
+        # There's no way to know exactly how the ACLs will look, so we'll
+        # check that they are different from a regularly created directory.
+        os.mkdir(path1, mode=0o700)
+        os.mkdir(path2, mode=0o777)
+
+        out1 = subprocess.check_output(["icacls.exe", path1], encoding="oem")
+        out2 = subprocess.check_output(["icacls.exe", path2], encoding="oem")
+        os.rmdir(path1)
+        os.rmdir(path2)
+        out1 = out1.replace(path1, "<PATH>")
+        out2 = out2.replace(path2, "<PATH>")
+        self.assertNotEqual(out1, out2)
+
     def tearDown(self):
         path = os.path.join(os_helper.TESTFN, 'dir1', 'dir2', 'dir3',
                             'dir4', 'dir5', 'dir6')
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index b64b6a4f2baeb5..19ddeaa169bf93 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -13,6 +13,7 @@
 import weakref
 import gc
 import shutil
+import subprocess
 from unittest import mock
 
 import unittest
@@ -803,6 +804,33 @@ def test_mode(self):
         finally:
             os.rmdir(dir)
 
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_mode_win32(self):
+        # Use icacls.exe to extract the users with some level of access
+        # Main thing we are testing is that the BUILTIN\Users group has
+        # no access. The exact ACL is going to vary based on which user
+        # is running the test.
+        dir = self.do_create()
+        try:
+            out = subprocess.check_output(["icacls.exe", dir], encoding="oem").casefold()
+        finally:
+            os.rmdir(dir)
+
+        dir = dir.casefold()
+        users = set()
+        found_user = False
+        for line in out.strip().splitlines():
+            acl = None
+            # First line of result includes our directory
+            if line.startswith(dir):
+                acl = line.removeprefix(dir).strip()
+            elif line and line[:1].isspace():
+                acl = line.strip()
+            if acl:
+                users.add(acl.partition(":")[0])
+
+        self.assertNotIn(r"BUILTIN\Users".casefold(), users)
+
     def test_collision_with_existing_file(self):
         # mkdtemp tries another name when a file with
         # the chosen name already exists
diff --git a/Misc/NEWS.d/next/Windows/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst b/Misc/NEWS.d/next/Windows/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
new file mode 100644
index 00000000000000..cdbce9a0bebf6b
--- /dev/null
+++ b/Misc/NEWS.d/next/Windows/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
@@ -0,0 +1,2 @@
+:func:`os.mkdir` now accepts *mode* of ``0o700`` to restrict the new
+directory to the current user.
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index 722159a39d098f..f9533577a8fa34 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -37,6 +37,8 @@
 #  include <winioctl.h>
 #  include <lmcons.h>             // UNLEN
 #  include "osdefs.h"             // SEP
+#  include <aclapi.h>             // SetEntriesInAcl
+#  include <sddl.h>               // SDDL_REVISION_1
 #  if defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM)
 #    define HAVE_SYMLINK
 #  endif /* MS_WINDOWS_DESKTOP | MS_WINDOWS_SYSTEM */
@@ -5539,6 +5541,133 @@ os__path_normpath_impl(PyObject *module, PyObject *path)
     return result;
 }
 
+#ifdef MS_WINDOWS
+
+/* We centralise SECURITY_ATTRIBUTE initialization based around
+templates that will probably mostly match common POSIX mode settings.
+The _Py_SECURITY_ATTRIBUTE_DATA structure contains temporary data, as
+a constructed SECURITY_ATTRIBUTE structure typically refers to memory
+that has to be alive while it's being used.
+
+Typical use will look like:
+    SECURITY_ATTRIBUTES *pSecAttr = NULL;
+    struct _Py_SECURITY_ATTRIBUTE_DATA secAttrData;
+    int error, error2;
+
+    Py_BEGIN_ALLOW_THREADS
+    switch (mode) {
+    case 0x1C0: // 0o700
+        error = initializeMkdir700SecurityAttributes(&pSecAttr, &secAttrData);
+        break;
+    ...
+    default:
+        error = initializeDefaultSecurityAttributes(&pSecAttr, &secAttrData);
+        break;
+    }
+
+    if (!error) {
+        // do operation, passing pSecAttr
+    }
+
+    // Unconditionally clear secAttrData.
+    error2 = clearSecurityAttributes(&pSecAttr, &secAttrData);
+    if (!error) {
+        error = error2;
+    }
+    Py_END_ALLOW_THREADS
+
+    if (error) {
+        PyErr_SetFromWindowsErr(error);
+        return NULL;
+    }
+*/
+
+struct _Py_SECURITY_ATTRIBUTE_DATA {
+    SECURITY_ATTRIBUTES securityAttributes;
+    PACL acl;
+    SECURITY_DESCRIPTOR sd;
+    EXPLICIT_ACCESS_W ea[4];
+};
+
+static int
+initializeDefaultSecurityAttributes(
+    PSECURITY_ATTRIBUTES *securityAttributes,
+    struct _Py_SECURITY_ATTRIBUTE_DATA *data
+) {
+    assert(securityAttributes);
+    assert(data);
+    *securityAttributes = NULL;
+    memset(data, 0, sizeof(*data));
+    return 0;
+}
+
+static int
+initializeMkdir700SecurityAttributes(
+    PSECURITY_ATTRIBUTES *securityAttributes,
+    struct _Py_SECURITY_ATTRIBUTE_DATA *data
+) {
+    assert(securityAttributes);
+    assert(data);
+    *securityAttributes = NULL;
+    memset(data, 0, sizeof(*data));
+
+    if (!InitializeSecurityDescriptor(&data->sd, SECURITY_DESCRIPTOR_REVISION)
+        || !SetSecurityDescriptorGroup(&data->sd, NULL, TRUE)) {
+        return GetLastError();
+    }
+
+    data->securityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
+    data->ea[0].grfAccessPermissions = GENERIC_ALL;
+    data->ea[0].grfAccessMode = SET_ACCESS;
+    data->ea[0].grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
+    data->ea[0].Trustee.TrusteeForm = TRUSTEE_IS_NAME;
+    data->ea[0].Trustee.TrusteeType = TRUSTEE_IS_ALIAS;
+    data->ea[0].Trustee.ptstrName = L"CURRENT_USER";
+
+    data->ea[1].grfAccessPermissions = GENERIC_ALL;
+    data->ea[1].grfAccessMode = SET_ACCESS;
+    data->ea[1].grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
+    data->ea[1].Trustee.TrusteeForm = TRUSTEE_IS_NAME;
+    data->ea[1].Trustee.TrusteeType = TRUSTEE_IS_ALIAS;
+    data->ea[1].Trustee.ptstrName = L"SYSTEM";
+
+    data->ea[2].grfAccessPermissions = GENERIC_ALL;
+    data->ea[2].grfAccessMode = SET_ACCESS;
+    data->ea[2].grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
+    data->ea[2].Trustee.TrusteeForm = TRUSTEE_IS_NAME;
+    data->ea[2].Trustee.TrusteeType = TRUSTEE_IS_ALIAS;
+    data->ea[2].Trustee.ptstrName = L"ADMINISTRATORS";
+
+    int r = SetEntriesInAclW(3, data->ea, NULL, &data->acl);
+    if (r) {
+        return r;
+    }
+    if (!SetSecurityDescriptorDacl(&data->sd, TRUE, data->acl, FALSE)) {
+        return GetLastError();
+    }
+    data->securityAttributes.lpSecurityDescriptor = &data->sd;
+    *securityAttributes = &data->securityAttributes;
+    return 0;
+}
+
+static int
+clearSecurityAttributes(
+    PSECURITY_ATTRIBUTES *securityAttributes,
+    struct _Py_SECURITY_ATTRIBUTE_DATA *data
+) {
+    assert(securityAttributes);
+    assert(data);
+    *securityAttributes = NULL;
+    if (data->acl) {
+        if (LocalFree((void *)data->acl)) {
+            return GetLastError();
+        }
+    }
+    return 0;
+}
+
+#endif
+
 /*[clinic input]
 os.mkdir
 
@@ -5568,6 +5697,12 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 /*[clinic end generated code: output=a70446903abe821f input=a61722e1576fab03]*/
 {
     int result;
+#ifdef MS_WINDOWS
+    int error = 0;
+    int pathError = 0;
+    SECURITY_ATTRIBUTES *pSecAttr = NULL;
+    struct _Py_SECURITY_ATTRIBUTE_DATA secAttrData;
+#endif
 #ifdef HAVE_MKDIRAT
     int mkdirat_unavailable = 0;
 #endif
@@ -5579,11 +5714,30 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 
 #ifdef MS_WINDOWS
     Py_BEGIN_ALLOW_THREADS
-    result = CreateDirectoryW(path->wide, NULL);
+    switch (mode) {
+    case 0x1C0: // 0o700
+        error = initializeMkdir700SecurityAttributes(&pSecAttr, &secAttrData);
+        break;
+    default:
+        error = initializeDefaultSecurityAttributes(&pSecAttr, &secAttrData);
+        break;
+    }
+    if (!error) {
+        result = CreateDirectoryW(path->wide, pSecAttr);
+        error = clearSecurityAttributes(&pSecAttr, &secAttrData);
+    } else {
+        // Ignore error from "clear" - we have a more interesting one already
+        clearSecurityAttributes(&pSecAttr, &secAttrData);
+    }
     Py_END_ALLOW_THREADS
 
-    if (!result)
+    if (error) {
+        PyErr_SetFromWindowsErr(error);
+        return NULL;
+    }
+    if (!result) {
         return path_error(path);
+    }
 #else
     Py_BEGIN_ALLOW_THREADS
 #if HAVE_MKDIRAT",
"url": "https://github.com/python/cpython/commit/81939dad77001556c527485d31a2d0f4a759033e.patch"
},
{
"commit_message": "[PATCH] gh-118486: Switch mkdir(mode=0o700) on Windows to use OWNER RIGHTS instead of CURRENT_USER (GH-118515) Modules/posixmodule.c | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/python/cpython/commit/8ed546679524140d8282175411fd141fe7df070d.patch"
},
{
"commit_message": "[PATCH] [3.11] gh-118486: Support mkdir(mode=0o700) on Windows (GH-118488) (GH-118739) Doc/library/os.rst | 7 ++++ Doc/whatsnew/3.11.rst | 12 ++++++ Lib/test/test_os.py | 12 ++++++ Lib/test/test_tempfile.py | 28 +++++++++++++ ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst | 4 ++ Modules/posixmodule.c | 42 ++++++++++++++++++- 6 files changed, 103 insertions(+), 2 deletions(-) create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst",
"patch_text_b64": "From 35c799d79177b962ddace2fa068101465570a29a Mon Sep 17 00:00:00 2001
From: Steve Dower <steve.dower@python.org>
Date: Fri, 24 May 2024 01:13:18 +0100
Subject: [PATCH] [3.11] gh-118486: Support mkdir(mode=0o700) on Windows
 (GH-118488) (GH-118739)

---
 Doc/library/os.rst                            |  7 ++++
 Doc/whatsnew/3.11.rst                         | 12 ++++++
 Lib/test/test_os.py                           | 12 ++++++
 Lib/test/test_tempfile.py                     | 28 +++++++++++++
 ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst |  4 ++
 Modules/posixmodule.c                         | 42 ++++++++++++++++++-
 6 files changed, 103 insertions(+), 2 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst

diff --git a/Doc/library/os.rst b/Doc/library/os.rst
index 5fefee382fd8fb..1af9e79db57664 100644
--- a/Doc/library/os.rst
+++ b/Doc/library/os.rst
@@ -2178,6 +2178,10 @@ features:
    platform-dependent.  On some platforms, they are ignored and you should call
    :func:`chmod` explicitly to set them.
 
+   On Windows, a *mode* of ``0o700`` is specifically handled to apply access
+   control to the new directory such that only the current user and
+   administrators have access. Other values of *mode* are ignored.
+
    This function can also support :ref:`paths relative to directory descriptors
    <dir_fd>`.
 
@@ -2192,6 +2196,9 @@ features:
    .. versionchanged:: 3.6
       Accepts a :term:`path-like object`.
 
+   .. versionchanged:: 3.11.10
+      Windows now handles a *mode* of ``0o700``.
+
 
 .. function:: makedirs(name, mode=0o777, exist_ok=False)
 
diff --git a/Doc/whatsnew/3.11.rst b/Doc/whatsnew/3.11.rst
index 42b61c75c7e621..d79c2a29604a4a 100644
--- a/Doc/whatsnew/3.11.rst
+++ b/Doc/whatsnew/3.11.rst
@@ -899,6 +899,13 @@ os
   instead of ``CryptGenRandom()`` which is deprecated.
   (Contributed by Donghee Na in :issue:`44611`.)
 
+* As of 3.11.10, :func:`os.mkdir` and :func:`os.makedirs` on Windows
+  now support passing a *mode* value of ``0o700`` to apply access
+  control to the new directory. This implicitly affects
+  :func:`tempfile.mkdtemp` and is a mitigation for CVE-2024-4030.
+  Other values for *mode* continue to be ignored.
+  (Contributed by Steve Dower in :gh:`118486`.)
+
 
 .. _whatsnew311-pathlib:
 
@@ -1059,6 +1066,11 @@ tempfile
   such as compression modules.
   (Contributed by Carey Metcalfe in :gh:`70363`.)
 
+* As of 3.11.10 on Windows, the default mode ``0o700`` used by
+  :func:`tempfile.mkdtemp` now limits access to the new directory due to
+  changes to :func:`os.mkdir`. This is a mitigation for CVE-2024-4030.
+  (Contributed by Steve Dower in :gh:`118486`.)
+
 
 .. _whatsnew311-threading:
 
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index 3dab98d45772d1..2d5b76ec826ca3 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -1743,6 +1743,18 @@ def test_exist_ok_existing_regular_file(self):
         self.assertRaises(OSError, os.makedirs, path, exist_ok=True)
         os.remove(path)
 
+    @unittest.skipUnless(os.name == 'nt', "requires Windows")
+    def test_win32_mkdir_700(self):
+        base = os_helper.TESTFN
+        path = os.path.abspath(os.path.join(os_helper.TESTFN, 'dir'))
+        os.mkdir(path, mode=0o700)
+        out = subprocess.check_output(["cacls.exe", path, "/s"], encoding="oem")
+        os.rmdir(path)
+        self.assertEqual(
+            out.strip(),
+            f'{path} "D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)"',
+        )
+
     def tearDown(self):
         path = os.path.join(os_helper.TESTFN, 'dir1', 'dir2', 'dir3',
                             'dir4', 'dir5', 'dir6')
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index e735a2520e77ee..0d6b95441cd508 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -11,6 +11,7 @@
 import stat
 import types
 import weakref
+import subprocess
 from unittest import mock
 
 import unittest
@@ -801,6 +802,33 @@ def test_mode(self):
         finally:
             os.rmdir(dir)
 
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_mode_win32(self):
+        # Use icacls.exe to extract the users with some level of access
+        # Main thing we are testing is that the BUILTIN\Users group has
+        # no access. The exact ACL is going to vary based on which user
+        # is running the test.
+        dir = self.do_create()
+        try:
+            out = subprocess.check_output(["icacls.exe", dir], encoding="oem").casefold()
+        finally:
+            os.rmdir(dir)
+
+        dir = dir.casefold()
+        users = set()
+        found_user = False
+        for line in out.strip().splitlines():
+            acl = None
+            # First line of result includes our directory
+            if line.startswith(dir):
+                acl = line.removeprefix(dir).strip()
+            elif line and line[:1].isspace():
+                acl = line.strip()
+            if acl:
+                users.add(acl.partition(":")[0])
+
+        self.assertNotIn(r"BUILTIN\Users".casefold(), users)
+
     def test_collision_with_existing_file(self):
         # mkdtemp tries another name when a file with
         # the chosen name already exists
diff --git a/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst b/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
new file mode 100644
index 00000000000000..a28a4e5cdb6991
--- /dev/null
+++ b/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
@@ -0,0 +1,4 @@
+:func:`os.mkdir` on Windows now accepts *mode* of ``0o700`` to restrict
+the new directory to the current user. This fixes CVE-2024-4030
+affecting :func:`tempfile.mkdtemp` in scenarios where the base temporary
+directory is more permissive than the default.
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index 6114f61168240d..46859dab35c500 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -34,6 +34,11 @@
 #include "pycore_pystate.h"       // _PyInterpreterState_GET()
 #include "pycore_signal.h"        // Py_NSIG
 
+#ifdef MS_WINDOWS
+#  include <aclapi.h>             // SetEntriesInAcl
+#  include <sddl.h>               // SDDL_REVISION_1
+#endif
+
 #include "structmember.h"         // PyMemberDef
 #ifndef MS_WINDOWS
 #  include "posixmodule.h"
@@ -4611,6 +4616,12 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 /*[clinic end generated code: output=a70446903abe821f input=a61722e1576fab03]*/
 {
     int result;
+#ifdef MS_WINDOWS
+    int error = 0;
+    int pathError = 0;
+    SECURITY_ATTRIBUTES secAttr = { sizeof(secAttr) };
+    SECURITY_ATTRIBUTES *pSecAttr = NULL;
+#endif
 #ifdef HAVE_MKDIRAT
     int mkdirat_unavailable = 0;
 #endif
@@ -4622,11 +4633,38 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 
 #ifdef MS_WINDOWS
     Py_BEGIN_ALLOW_THREADS
-    result = CreateDirectoryW(path->wide, NULL);
+    if (mode == 0700 /* 0o700 */) {
+        ULONG sdSize;
+        pSecAttr = &secAttr;
+        // Set a discretionary ACL (D) that is protected (P) and includes
+        // inheritable (OICI) entries that allow (A) full control (FA) to
+        // SYSTEM (SY), Administrators (BA), and the owner (OW).
+        if (!ConvertStringSecurityDescriptorToSecurityDescriptorW(
+            L"D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)",
+            SDDL_REVISION_1,
+            &secAttr.lpSecurityDescriptor,
+            &sdSize
+        )) {
+            error = GetLastError();
+        }
+    }
+    if (!error) {
+        result = CreateDirectoryW(path->wide, pSecAttr);
+        if (secAttr.lpSecurityDescriptor &&
+            // uncommonly, LocalFree returns non-zero on error, but still uses
+            // GetLastError() to see what the error code is
+            LocalFree(secAttr.lpSecurityDescriptor)) {
+            error = GetLastError();
+        }
+    }
     Py_END_ALLOW_THREADS
 
-    if (!result)
+    if (error) {
+        return PyErr_SetFromWindowsErr(error);
+    }
+    if (!result) {
         return path_error(path);
+    }
 #else
     Py_BEGIN_ALLOW_THREADS
 #if HAVE_MKDIRAT",
"url": "https://github.com/python/cpython/commit/35c799d79177b962ddace2fa068101465570a29a.patch"
},
{
"commit_message": "[PATCH] [3.9] gh-118486: Support mkdir(mode=0o700) on Windows (GH-118488) (GH-118741) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Łukasz Langa <[email protected]> Doc/library/os.rst | 7 +++ Doc/whatsnew/3.9.rst | 15 +++++++ Lib/test/test_os.py | 12 +++++ Lib/test/test_tempfile.py | 28 ++++++++++++ ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst | 4 ++ Modules/posixmodule.c | 44 +++++++++++++++++-- 6 files changed, 107 insertions(+), 3 deletions(-) create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst",
"patch_text_b64": "From 5130731c9e779b97d00a24f54cdce73ce9975dfd Mon Sep 17 00:00:00 2001
From: Steve Dower <steve.dower@python.org>
Date: Fri, 24 May 2024 18:27:01 +0100
Subject: [PATCH] [3.9] gh-118486: Support mkdir(mode=0o700) on Windows
 (GH-118488) (GH-118741)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Łukasz Langa <lukasz@langa.pl>
---
 Doc/library/os.rst                            |  7 +++
 Doc/whatsnew/3.9.rst                          | 15 +++++++
 Lib/test/test_os.py                           | 12 +++++
 Lib/test/test_tempfile.py                     | 28 ++++++++++++
 ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst |  4 ++
 Modules/posixmodule.c                         | 44 +++++++++++++++++--
 6 files changed, 107 insertions(+), 3 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst

diff --git a/Doc/library/os.rst b/Doc/library/os.rst
index 35a7e1e96d3460..1d10ae7bbce0be 100644
--- a/Doc/library/os.rst
+++ b/Doc/library/os.rst
@@ -1929,6 +1929,10 @@ features:
    platform-dependent.  On some platforms, they are ignored and you should call
    :func:`chmod` explicitly to set them.
 
+   On Windows, a *mode* of ``0o700`` is specifically handled to apply access
+   control to the new directory such that only the current user and
+   administrators have access. Other values of *mode* are ignored.
+
    This function can also support :ref:`paths relative to directory descriptors
    <dir_fd>`.
 
@@ -1943,6 +1947,9 @@ features:
    .. versionchanged:: 3.6
       Accepts a :term:`path-like object`.
 
+   .. versionchanged:: 3.9.20
+      Windows now handles a *mode* of ``0o700``.
+
 
 .. function:: makedirs(name, mode=0o777, exist_ok=False)
 
diff --git a/Doc/whatsnew/3.9.rst b/Doc/whatsnew/3.9.rst
index 1756a3733863c8..9383047098d1e4 100644
--- a/Doc/whatsnew/3.9.rst
+++ b/Doc/whatsnew/3.9.rst
@@ -613,6 +613,13 @@ Added :func:`os.waitstatus_to_exitcode` function:
 convert a wait status to an exit code.
 (Contributed by Victor Stinner in :issue:`40094`.)
 
+As of 3.9.20, :func:`os.mkdir` and :func:`os.makedirs` on Windows now support
+passing a *mode* value of ``0o700`` to apply access control to the new
+directory. This implicitly affects :func:`tempfile.mkdtemp` and is a
+mitigation for CVE-2024-4030. Other values for *mode* continue to be
+ignored.
+(Contributed by Steve Dower in :gh:`118486`.)
+
 pathlib
 -------
 
@@ -704,6 +711,14 @@ Previously, :attr:`sys.stderr` was block-buffered when non-interactive. Now
 ``stderr`` defaults to always being line-buffered.
 (Contributed by Jendrik Seipp in :issue:`13601`.)
 
+tempfile
+--------
+
+As of 3.9.20 on Windows, the default mode ``0o700`` used by
+:func:`tempfile.mkdtemp` now limits access to the new directory due to
+changes to :func:`os.mkdir`. This is a mitigation for CVE-2024-4030.
+(Contributed by Steve Dower in :gh:`118486`.)
+
 tracemalloc
 -----------
 
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index 78dd3151b36f92..f8b4e091e08ef4 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -1493,6 +1493,18 @@ def test_exist_ok_existing_regular_file(self):
         self.assertRaises(OSError, os.makedirs, path, exist_ok=True)
         os.remove(path)
 
+    @unittest.skipUnless(os.name == 'nt', "requires Windows")
+    def test_win32_mkdir_700(self):
+        base = support.TESTFN
+        path = os.path.abspath(os.path.join(support.TESTFN, 'dir'))
+        os.mkdir(path, mode=0o700)
+        out = subprocess.check_output(["cacls.exe", path, "/s"], encoding="oem")
+        os.rmdir(path)
+        self.assertEqual(
+            out.strip(),
+            f'{path} "D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)"',
+        )
+
     def tearDown(self):
         path = os.path.join(support.TESTFN, 'dir1', 'dir2', 'dir3',
                             'dir4', 'dir5', 'dir6')
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index 571263d9c957d7..8d13c22f2ee8a1 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -11,6 +11,7 @@
 import stat
 import types
 import weakref
+import subprocess
 from unittest import mock
 
 import unittest
@@ -772,6 +773,33 @@ def test_mode(self):
         finally:
             os.rmdir(dir)
 
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_mode_win32(self):
+        # Use icacls.exe to extract the users with some level of access
+        # Main thing we are testing is that the BUILTIN\Users group has
+        # no access. The exact ACL is going to vary based on which user
+        # is running the test.
+        dir = self.do_create()
+        try:
+            out = subprocess.check_output(["icacls.exe", dir], encoding="oem").casefold()
+        finally:
+            os.rmdir(dir)
+
+        dir = dir.casefold()
+        users = set()
+        found_user = False
+        for line in out.strip().splitlines():
+            acl = None
+            # First line of result includes our directory
+            if line.startswith(dir):
+                acl = line.removeprefix(dir).strip()
+            elif line and line[:1].isspace():
+                acl = line.strip()
+            if acl:
+                users.add(acl.partition(":")[0])
+
+        self.assertNotIn(r"BUILTIN\Users".casefold(), users)
+
     def test_collision_with_existing_file(self):
         # mkdtemp tries another name when a file with
         # the chosen name already exists
diff --git a/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst b/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
new file mode 100644
index 00000000000000..a28a4e5cdb6991
--- /dev/null
+++ b/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
@@ -0,0 +1,4 @@
+:func:`os.mkdir` on Windows now accepts *mode* of ``0o700`` to restrict
+the new directory to the current user. This fixes CVE-2024-4030
+affecting :func:`tempfile.mkdtemp` in scenarios where the base temporary
+directory is more permissive than the default.
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index bf4e648421d3e0..7645bcfea97b4f 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -24,6 +24,12 @@
 #include "pycore_ceval.h"         // _PyEval_ReInitThreads()
 #include "pycore_import.h"        // _PyImport_ReInitLock()
 #include "pycore_pystate.h"       // _PyInterpreterState_GET()
+
+#ifdef MS_WINDOWS
+#  include <aclapi.h>             // SetEntriesInAcl
+#  include <sddl.h>               // SDDL_REVISION_1
+#endif
+
 #include "structmember.h"         // PyMemberDef
 #ifndef MS_WINDOWS
 #  include "posixmodule.h"
@@ -4425,7 +4431,6 @@ os__path_splitroot_impl(PyObject *module, path_t *path)
 
 #endif /* MS_WINDOWS */
 
-
 /*[clinic input]
 os.mkdir
 
@@ -4454,6 +4459,12 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 /*[clinic end generated code: output=a70446903abe821f input=e965f68377e9b1ce]*/
 {
     int result;
+#ifdef MS_WINDOWS
+    int error = 0;
+    int pathError = 0;
+    SECURITY_ATTRIBUTES secAttr = { sizeof(secAttr) };
+    SECURITY_ATTRIBUTES *pSecAttr = NULL;
+#endif
 #ifdef HAVE_MKDIRAT
     int mkdirat_unavailable = 0;
 #endif
@@ -4465,11 +4476,38 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 
 #ifdef MS_WINDOWS
     Py_BEGIN_ALLOW_THREADS
-    result = CreateDirectoryW(path->wide, NULL);
+    if (mode == 0700 /* 0o700 */) {
+        ULONG sdSize;
+        pSecAttr = &secAttr;
+        // Set a discretionary ACL (D) that is protected (P) and includes
+        // inheritable (OICI) entries that allow (A) full control (FA) to
+        // SYSTEM (SY), Administrators (BA), and the owner (OW).
+        if (!ConvertStringSecurityDescriptorToSecurityDescriptorW(
+            L"D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)",
+            SDDL_REVISION_1,
+            &secAttr.lpSecurityDescriptor,
+            &sdSize
+        )) {
+            error = GetLastError();
+        }
+    }
+    if (!error) {
+        result = CreateDirectoryW(path->wide, pSecAttr);
+        if (secAttr.lpSecurityDescriptor &&
+            // uncommonly, LocalFree returns non-zero on error, but still uses
+            // GetLastError() to see what the error code is
+            LocalFree(secAttr.lpSecurityDescriptor)) {
+            error = GetLastError();
+        }
+    }
     Py_END_ALLOW_THREADS
 
-    if (!result)
+    if (error) {
+        return PyErr_SetFromWindowsErr(error);
+    }
+    if (!result) {
         return path_error(path);
+    }
 #else
     Py_BEGIN_ALLOW_THREADS
 #if HAVE_MKDIRAT",
"url": "https://github.com/python/cpython/commit/5130731c9e779b97d00a24f54cdce73ce9975dfd.patch"
},
{
"commit_message": "[PATCH] gh-118486: Update docs for CVE-2024-4030 reference (GH-118737) Doc/whatsnew/3.13.rst | 14 ++++++++++++++ .../2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst | 4 ++++ 2 files changed, 18 insertions(+) create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst",
"patch_text_b64": "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",
"url": "https://github.com/python/cpython/commit/66f8bb76a15e64a1bb7688b177ed29e26230fdee.patch"
},
{
"commit_message": "<[email protected]> [PATCH] gh-118486: Simplify test_win32_mkdir_700 to check the exact ACL (GH-119056) (cherry picked from commit 94591dca510c796c7d40e9b4167ea56f2fdf28ca) Co-authored-by: Steve Dower <[email protected]> Lib/test/test_os.py | 23 ++++++++--------------- Modules/posixmodule.c | 2 +- 2 files changed, 9 insertions(+), 16 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/python/cpython/commit/6d0850c4c8188035643586ab4d8ec2468abd699e.patch"
},
{
"commit_message": "[PATCH] [3.8] gh-118486: Support mkdir(mode=0o700) on Windows (GH-118488) (GH-118742) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Łukasz Langa <[email protected]> Doc/library/os.rst | 7 +++ Doc/whatsnew/3.8.rst | 16 +++++++ Lib/test/test_os.py | 12 +++++ Lib/test/test_tempfile.py | 28 ++++++++++++ ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst | 4 ++ Modules/posixmodule.c | 44 +++++++++++++++++-- 6 files changed, 108 insertions(+), 3 deletions(-) create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst",
"patch_text_b64": "From 91e3669e01245185569d09e9e6e11641282971ee Mon Sep 17 00:00:00 2001
From: Steve Dower <steve.dower@python.org>
Date: Fri, 24 May 2024 18:27:13 +0100
Subject: [PATCH] [3.8] gh-118486: Support mkdir(mode=0o700) on Windows
 (GH-118488) (GH-118742)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Łukasz Langa <lukasz@langa.pl>
---
 Doc/library/os.rst                            |  7 +++
 Doc/whatsnew/3.8.rst                          | 16 +++++++
 Lib/test/test_os.py                           | 12 +++++
 Lib/test/test_tempfile.py                     | 28 ++++++++++++
 ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst |  4 ++
 Modules/posixmodule.c                         | 44 +++++++++++++++++--
 6 files changed, 108 insertions(+), 3 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst

diff --git a/Doc/library/os.rst b/Doc/library/os.rst
index d0a37a8bbdbf05..736a59a9216b6f 100644
--- a/Doc/library/os.rst
+++ b/Doc/library/os.rst
@@ -1909,6 +1909,10 @@ features:
    platform-dependent.  On some platforms, they are ignored and you should call
    :func:`chmod` explicitly to set them.
 
+   On Windows, a *mode* of ``0o700`` is specifically handled to apply access
+   control to the new directory such that only the current user and
+   administrators have access. Other values of *mode* are ignored.
+
    This function can also support :ref:`paths relative to directory descriptors
    <dir_fd>`.
 
@@ -1923,6 +1927,9 @@ features:
    .. versionchanged:: 3.6
       Accepts a :term:`path-like object`.
 
+   .. versionchanged:: 3.8.20
+      Windows now handles a *mode* of ``0o700``.
+
 
 .. function:: makedirs(name, mode=0o777, exist_ok=False)
 
diff --git a/Doc/whatsnew/3.8.rst b/Doc/whatsnew/3.8.rst
index de4dd856877543..4cd581a189147e 100644
--- a/Doc/whatsnew/3.8.rst
+++ b/Doc/whatsnew/3.8.rst
@@ -1046,6 +1046,13 @@ treat junctions as links.
 
 (Contributed by Steve Dower in :issue:`37834`.)
 
+As of 3.8.20, :func:`os.mkdir` and :func:`os.makedirs` on Windows now support
+passing a *mode* value of ``0o700`` to apply access control to the new
+directory. This implicitly affects :func:`tempfile.mkdtemp` and is a
+mitigation for CVE-2024-4030. Other values for *mode* continue to be
+ignored.
+(Contributed by Steve Dower in :gh:`118486`.)
+
 
 os.path
 -------
@@ -1252,6 +1259,15 @@ in a standardized and extensible format, and offers several other benefits.
 (Contributed by C.A.M. Gerlach in :issue:`36268`.)
 
 
+tempfile
+--------
+
+As of 3.8.20 on Windows, the default mode ``0o700`` used by
+:func:`tempfile.mkdtemp` now limits access to the new directory due to
+changes to :func:`os.mkdir`. This is a mitigation for CVE-2024-4030.
+(Contributed by Steve Dower in :gh:`118486`.)
+
+
 threading
 ---------
 
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index 5302b1ce575d4e..84f78c222982a8 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -1380,6 +1380,18 @@ def test_exist_ok_existing_regular_file(self):
         self.assertRaises(OSError, os.makedirs, path, exist_ok=True)
         os.remove(path)
 
+    @unittest.skipUnless(os.name == 'nt', "requires Windows")
+    def test_win32_mkdir_700(self):
+        base = support.TESTFN
+        path = os.path.abspath(os.path.join(support.TESTFN, 'dir'))
+        os.mkdir(path, mode=0o700)
+        out = subprocess.check_output(["cacls.exe", path, "/s"], encoding="oem")
+        os.rmdir(path)
+        self.assertEqual(
+            out.strip(),
+            f'{path} "D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)"',
+        )
+
     def tearDown(self):
         path = os.path.join(support.TESTFN, 'dir1', 'dir2', 'dir3',
                             'dir4', 'dir5', 'dir6')
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index 8cb36f38a2a35c..c1fdcea04bb935 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -11,6 +11,7 @@
 import contextlib
 import stat
 import weakref
+import subprocess
 from unittest import mock
 
 import unittest
@@ -760,6 +761,33 @@ def test_mode(self):
         finally:
             os.rmdir(dir)
 
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_mode_win32(self):
+        # Use icacls.exe to extract the users with some level of access
+        # Main thing we are testing is that the BUILTIN\Users group has
+        # no access. The exact ACL is going to vary based on which user
+        # is running the test.
+        dir = self.do_create()
+        try:
+            out = subprocess.check_output(["icacls.exe", dir], encoding="oem").casefold()
+        finally:
+            os.rmdir(dir)
+
+        dir = dir.casefold()
+        users = set()
+        found_user = False
+        for line in out.strip().splitlines():
+            acl = None
+            # First line of result includes our directory
+            if line.startswith(dir):
+                acl = line[len(dir):].strip()
+            elif line and line[:1].isspace():
+                acl = line.strip()
+            if acl:
+                users.add(acl.partition(":")[0])
+
+        self.assertNotIn(r"BUILTIN\Users".casefold(), users)
+
     def test_collision_with_existing_file(self):
         # mkdtemp tries another name when a file with
         # the chosen name already exists
diff --git a/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst b/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
new file mode 100644
index 00000000000000..a28a4e5cdb6991
--- /dev/null
+++ b/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
@@ -0,0 +1,4 @@
+:func:`os.mkdir` on Windows now accepts *mode* of ``0o700`` to restrict
+the new directory to the current user. This fixes CVE-2024-4030
+affecting :func:`tempfile.mkdtemp` in scenarios where the base temporary
+directory is more permissive than the default.
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index d7edabe5da08d1..2ec8458cb51bfb 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -40,6 +40,12 @@
 #include "pycore_pystate.h"   /* _PyRuntime */
 #include "pythread.h"
 #include "structmember.h"
+
+#ifdef MS_WINDOWS
+#  include <aclapi.h>             // SetEntriesInAcl
+#  include <sddl.h>               // SDDL_REVISION_1
+#endif
+
 #ifndef MS_WINDOWS
 #  include "posixmodule.h"
 #else
@@ -4122,7 +4128,6 @@ os__path_splitroot_impl(PyObject *module, path_t *path)
 
 #endif /* MS_WINDOWS */
 
-
 /*[clinic input]
 os.mkdir
 
@@ -4151,6 +4156,12 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 /*[clinic end generated code: output=a70446903abe821f input=e965f68377e9b1ce]*/
 {
     int result;
+#ifdef MS_WINDOWS
+    int error = 0;
+    int pathError = 0;
+    SECURITY_ATTRIBUTES secAttr = { sizeof(secAttr) };
+    SECURITY_ATTRIBUTES *pSecAttr = NULL;
+#endif
 
     if (PySys_Audit("os.mkdir", "Oii", path->object, mode,
                     dir_fd == DEFAULT_DIR_FD ? -1 : dir_fd) < 0) {
@@ -4159,11 +4170,38 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 
 #ifdef MS_WINDOWS
     Py_BEGIN_ALLOW_THREADS
-    result = CreateDirectoryW(path->wide, NULL);
+    if (mode == 0700 /* 0o700 */) {
+        ULONG sdSize;
+        pSecAttr = &secAttr;
+        // Set a discretionary ACL (D) that is protected (P) and includes
+        // inheritable (OICI) entries that allow (A) full control (FA) to
+        // SYSTEM (SY), Administrators (BA), and the owner (OW).
+        if (!ConvertStringSecurityDescriptorToSecurityDescriptorW(
+            L"D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)",
+            SDDL_REVISION_1,
+            &secAttr.lpSecurityDescriptor,
+            &sdSize
+        )) {
+            error = GetLastError();
+        }
+    }
+    if (!error) {
+        result = CreateDirectoryW(path->wide, pSecAttr);
+        if (secAttr.lpSecurityDescriptor &&
+            // uncommonly, LocalFree returns non-zero on error, but still uses
+            // GetLastError() to see what the error code is
+            LocalFree(secAttr.lpSecurityDescriptor)) {
+            error = GetLastError();
+        }
+    }
     Py_END_ALLOW_THREADS
 
-    if (!result)
+    if (error) {
+        return PyErr_SetFromWindowsErr(error);
+    }
+    if (!result) {
         return path_error(path);
+    }
 #else
     Py_BEGIN_ALLOW_THREADS
 #if HAVE_MKDIRAT",
"url": "https://github.com/python/cpython/commit/91e3669e01245185569d09e9e6e11641282971ee.patch"
},
{
"commit_message": "[PATCH] gh-118486: Simplify test_win32_mkdir_700 to check the exact ACL (GH-119056) Lib/test/test_os.py | 23 ++++++++--------------- Modules/posixmodule.c | 2 +- 2 files changed, 9 insertions(+), 16 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/python/cpython/commit/94591dca510c796c7d40e9b4167ea56f2fdf28ca.patch"
},
{
"commit_message": "[PATCH] [3.10] gh-118486: Support mkdir(mode=0o700) on Windows (GH-118488) (GH-118740) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Łukasz Langa <[email protected]> Doc/library/os.rst | 7 +++ Doc/whatsnew/3.10.rst | 15 +++++++ Lib/test/test_os.py | 12 +++++ Lib/test/test_tempfile.py | 28 ++++++++++++ ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst | 4 ++ Modules/posixmodule.c | 44 +++++++++++++++++-- 6 files changed, 107 insertions(+), 3 deletions(-) create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst",
"patch_text_b64": "From c8f868dc52f98011d0f9b459b6487920bfb0ac4d Mon Sep 17 00:00:00 2001
From: Steve Dower <steve.dower@python.org>
Date: Fri, 24 May 2024 18:26:44 +0100
Subject: [PATCH] [3.10] gh-118486: Support mkdir(mode=0o700) on Windows
 (GH-118488) (GH-118740)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Łukasz Langa <lukasz@langa.pl>
---
 Doc/library/os.rst                            |  7 +++
 Doc/whatsnew/3.10.rst                         | 15 +++++++
 Lib/test/test_os.py                           | 12 +++++
 Lib/test/test_tempfile.py                     | 28 ++++++++++++
 ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst |  4 ++
 Modules/posixmodule.c                         | 44 +++++++++++++++++--
 6 files changed, 107 insertions(+), 3 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst

diff --git a/Doc/library/os.rst b/Doc/library/os.rst
index 28990c216af3d1..8405fb1917e714 100644
--- a/Doc/library/os.rst
+++ b/Doc/library/os.rst
@@ -2065,6 +2065,10 @@ features:
    platform-dependent.  On some platforms, they are ignored and you should call
    :func:`chmod` explicitly to set them.
 
+   On Windows, a *mode* of ``0o700`` is specifically handled to apply access
+   control to the new directory such that only the current user and
+   administrators have access. Other values of *mode* are ignored.
+
    This function can also support :ref:`paths relative to directory descriptors
    <dir_fd>`.
 
@@ -2079,6 +2083,9 @@ features:
    .. versionchanged:: 3.6
       Accepts a :term:`path-like object`.
 
+   .. versionchanged:: 3.10.15
+      Windows now handles a *mode* of ``0o700``.
+
 
 .. function:: makedirs(name, mode=0o777, exist_ok=False)
 
diff --git a/Doc/whatsnew/3.10.rst b/Doc/whatsnew/3.10.rst
index d6ccf96a4cfec2..f71a50163f49ea 100644
--- a/Doc/whatsnew/3.10.rst
+++ b/Doc/whatsnew/3.10.rst
@@ -1247,6 +1247,13 @@ Add :data:`~os.O_EVTONLY`, :data:`~os.O_FSYNC`, :data:`~os.O_SYMLINK`
 and :data:`~os.O_NOFOLLOW_ANY` for macOS.
 (Contributed by Dong-hee Na in :issue:`43106`.)
 
+As of 3.10.15, :func:`os.mkdir` and :func:`os.makedirs` on Windows now support
+passing a *mode* value of ``0o700`` to apply access control to the new
+directory. This implicitly affects :func:`tempfile.mkdtemp` and is a
+mitigation for CVE-2024-4030. Other values for *mode* continue to be
+ignored.
+(Contributed by Steve Dower in :gh:`118486`.)
+
 os.path
 -------
 
@@ -1399,6 +1406,14 @@ Add :data:`sys.stdlib_module_names`, containing the list of the standard library
 module names.
 (Contributed by Victor Stinner in :issue:`42955`.)
 
+tempfile
+--------
+
+As of 3.10.15 on Windows, the default mode ``0o700`` used by
+:func:`tempfile.mkdtemp` now limits access to the new directory due to
+changes to :func:`os.mkdir`. This is a mitigation for CVE-2024-4030.
+(Contributed by Steve Dower in :gh:`118486`.)
+
 _thread
 -------
 
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index 6b443c48f8fcb5..044ce5c1a39f30 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -1635,6 +1635,18 @@ def test_exist_ok_existing_regular_file(self):
         self.assertRaises(OSError, os.makedirs, path, exist_ok=True)
         os.remove(path)
 
+    @unittest.skipUnless(os.name == 'nt', "requires Windows")
+    def test_win32_mkdir_700(self):
+        base = os_helper.TESTFN
+        path = os.path.abspath(os.path.join(os_helper.TESTFN, 'dir'))
+        os.mkdir(path, mode=0o700)
+        out = subprocess.check_output(["cacls.exe", path, "/s"], encoding="oem")
+        os.rmdir(path)
+        self.assertEqual(
+            out.strip(),
+            f'{path} "D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)"',
+        )
+
     def tearDown(self):
         path = os.path.join(os_helper.TESTFN, 'dir1', 'dir2', 'dir3',
                             'dir4', 'dir5', 'dir6')
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index 30d57baf977f52..6e06bfc7f2f78d 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -11,6 +11,7 @@
 import stat
 import types
 import weakref
+import subprocess
 from unittest import mock
 
 import unittest
@@ -800,6 +801,33 @@ def test_mode(self):
         finally:
             os.rmdir(dir)
 
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_mode_win32(self):
+        # Use icacls.exe to extract the users with some level of access
+        # Main thing we are testing is that the BUILTIN\Users group has
+        # no access. The exact ACL is going to vary based on which user
+        # is running the test.
+        dir = self.do_create()
+        try:
+            out = subprocess.check_output(["icacls.exe", dir], encoding="oem").casefold()
+        finally:
+            os.rmdir(dir)
+
+        dir = dir.casefold()
+        users = set()
+        found_user = False
+        for line in out.strip().splitlines():
+            acl = None
+            # First line of result includes our directory
+            if line.startswith(dir):
+                acl = line.removeprefix(dir).strip()
+            elif line and line[:1].isspace():
+                acl = line.strip()
+            if acl:
+                users.add(acl.partition(":")[0])
+
+        self.assertNotIn(r"BUILTIN\Users".casefold(), users)
+
     def test_collision_with_existing_file(self):
         # mkdtemp tries another name when a file with
         # the chosen name already exists
diff --git a/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst b/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
new file mode 100644
index 00000000000000..a28a4e5cdb6991
--- /dev/null
+++ b/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
@@ -0,0 +1,4 @@
+:func:`os.mkdir` on Windows now accepts *mode* of ``0o700`` to restrict
+the new directory to the current user. This fixes CVE-2024-4030
+affecting :func:`tempfile.mkdtemp` in scenarios where the base temporary
+directory is more permissive than the default.
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index c0421a94c17397..43e69fc322b595 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -33,6 +33,12 @@
 #include "pycore_import.h"        // _PyImport_ReInitLock()
 #include "pycore_initconfig.h"    // _PyStatus_EXCEPTION()
 #include "pycore_pystate.h"       // _PyInterpreterState_GET()
+
+#ifdef MS_WINDOWS
+#  include <aclapi.h>             // SetEntriesInAcl
+#  include <sddl.h>               // SDDL_REVISION_1
+#endif
+
 #include "structmember.h"         // PyMemberDef
 #ifndef MS_WINDOWS
 #  include "posixmodule.h"
@@ -4465,7 +4471,6 @@ os__path_splitroot_impl(PyObject *module, path_t *path)
 
 #endif /* MS_WINDOWS */
 
-
 /*[clinic input]
 os.mkdir
 
@@ -4495,6 +4500,12 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 /*[clinic end generated code: output=a70446903abe821f input=a61722e1576fab03]*/
 {
     int result;
+#ifdef MS_WINDOWS
+    int error = 0;
+    int pathError = 0;
+    SECURITY_ATTRIBUTES secAttr = { sizeof(secAttr) };
+    SECURITY_ATTRIBUTES *pSecAttr = NULL;
+#endif
 #ifdef HAVE_MKDIRAT
     int mkdirat_unavailable = 0;
 #endif
@@ -4506,11 +4517,38 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 
 #ifdef MS_WINDOWS
     Py_BEGIN_ALLOW_THREADS
-    result = CreateDirectoryW(path->wide, NULL);
+    if (mode == 0700 /* 0o700 */) {
+        ULONG sdSize;
+        pSecAttr = &secAttr;
+        // Set a discretionary ACL (D) that is protected (P) and includes
+        // inheritable (OICI) entries that allow (A) full control (FA) to
+        // SYSTEM (SY), Administrators (BA), and the owner (OW).
+        if (!ConvertStringSecurityDescriptorToSecurityDescriptorW(
+            L"D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)",
+            SDDL_REVISION_1,
+            &secAttr.lpSecurityDescriptor,
+            &sdSize
+        )) {
+            error = GetLastError();
+        }
+    }
+    if (!error) {
+        result = CreateDirectoryW(path->wide, pSecAttr);
+        if (secAttr.lpSecurityDescriptor &&
+            // uncommonly, LocalFree returns non-zero on error, but still uses
+            // GetLastError() to see what the error code is
+            LocalFree(secAttr.lpSecurityDescriptor)) {
+            error = GetLastError();
+        }
+    }
     Py_END_ALLOW_THREADS
 
-    if (!result)
+    if (error) {
+        return PyErr_SetFromWindowsErr(error);
+    }
+    if (!result) {
         return path_error(path);
+    }
 #else
     Py_BEGIN_ALLOW_THREADS
 #if HAVE_MKDIRAT",
"url": "https://github.com/python/cpython/commit/c8f868dc52f98011d0f9b459b6487920bfb0ac4d.patch"
},
{
"commit_message": "[PATCH] gh-118486: Update docs for CVE-2024-4030 reference (GH-118737) Update docs for CVE-2024-4030 reference Doc/whatsnew/3.13.rst | 14 ++++++++++++++ .../2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst | 4 ++++ 2 files changed, 18 insertions(+) create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst",
"patch_text_b64": "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",
"url": "https://github.com/python/cpython/commit/d86b49411753bf2c83291e3a14ae43fefded2f84.patch"
},
{
"commit_message": "<[email protected]> [PATCH] gh-118486: Simplify test_win32_mkdir_700 to check the exact ACL (GH-119056) (cherry picked from commit 94591dca510c796c7d40e9b4167ea56f2fdf28ca) Co-authored-by: Steve Dower <[email protected]> Lib/test/test_os.py | 23 ++++++++--------------- Modules/posixmodule.c | 2 +- 2 files changed, 9 insertions(+), 16 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/python/cpython/commit/e1dfa978b1ad210d551385ad8073ec6154f53763.patch"
},
{
"commit_message": "[PATCH] gh-118486: Support mkdir(mode=0o700) on Windows (GH-118488) Doc/library/os.rst | 7 ++++ Doc/whatsnew/3.12.rst | 11 ++++++ Lib/test/test_os.py | 19 +++++++++ Lib/test/test_tempfile.py | 28 +++++++++++++ ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst | 4 ++ Modules/posixmodule.c | 39 ++++++++++++++++++- 6 files changed, 106 insertions(+), 2 deletions(-) create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst",
"patch_text_b64": "From eb29e2f5905da93333d1ce78bc98b151e763ff46 Mon Sep 17 00:00:00 2001
From: Steve Dower <steve.dower@python.org>
Date: Thu, 9 May 2024 19:18:56 +0100
Subject: [PATCH] gh-118486: Support mkdir(mode=0o700) on Windows (GH-118488)

---
 Doc/library/os.rst                            |  7 ++++
 Doc/whatsnew/3.12.rst                         | 11 ++++++
 Lib/test/test_os.py                           | 19 +++++++++
 Lib/test/test_tempfile.py                     | 28 +++++++++++++
 ...-05-01-20-57-09.gh-issue-118486.K44KJG.rst |  4 ++
 Modules/posixmodule.c                         | 39 ++++++++++++++++++-
 6 files changed, 106 insertions(+), 2 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst

diff --git a/Doc/library/os.rst b/Doc/library/os.rst
index 623f38b03ed285..a793d244de9a04 100644
--- a/Doc/library/os.rst
+++ b/Doc/library/os.rst
@@ -2356,6 +2356,10 @@ features:
    platform-dependent.  On some platforms, they are ignored and you should call
    :func:`chmod` explicitly to set them.
 
+   On Windows, a *mode* of ``0o700`` is specifically handled to apply access
+   control to the new directory such that only the current user and
+   administrators have access. Other values of *mode* are ignored.
+
    This function can also support :ref:`paths relative to directory descriptors
    <dir_fd>`.
 
@@ -2370,6 +2374,9 @@ features:
    .. versionchanged:: 3.6
       Accepts a :term:`path-like object`.
 
+   .. versionchanged:: 3.12.4
+      Windows now handles a *mode* of ``0o700``.
+
 
 .. function:: makedirs(name, mode=0o777, exist_ok=False)
 
diff --git a/Doc/whatsnew/3.12.rst b/Doc/whatsnew/3.12.rst
index 71bc89240c73b0..16723964121284 100644
--- a/Doc/whatsnew/3.12.rst
+++ b/Doc/whatsnew/3.12.rst
@@ -778,6 +778,13 @@ os
   Both functions may be significantly faster on newer releases of
   Windows. (Contributed by Steve Dower in :gh:`99726`.)
 
+* As of 3.12.4, :func:`os.mkdir` and :func:`os.makedirs` on Windows
+  now support passing a *mode* value of ``0o700`` to apply access
+  control to the new directory. This implicitly affects
+  :func:`tempfile.mkdtemp` and is a mitigation for :cve:`2024-4030`.
+  Other values for *mode* continue to be ignored.
+  (Contributed by Steve Dower in :gh:`118486`.)
+
 os.path
 -------
 
@@ -925,6 +932,10 @@ tempfile
   *delete_on_close* (Contributed by Evgeny Zorin in :gh:`58451`.)
 * :func:`tempfile.mkdtemp` now always returns an absolute path, even if the
   argument provided to the *dir* parameter is a relative path.
+* As of 3.12.4 on Windows, the default mode ``0o700`` used by
+  :func:`tempfile.mkdtemp` now limits access to the new directory due to
+  changes to :func:`os.mkdir`. This is a mitigation for :cve:`2024-4030`.
+  (Contributed by Steve Dower in :gh:`118486`.)
 
 threading
 ---------
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index 7464aaa794941c..a64761c76d62fc 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -1797,6 +1797,25 @@ def test_exist_ok_existing_regular_file(self):
         self.assertRaises(OSError, os.makedirs, path, exist_ok=True)
         os.remove(path)
 
+    @unittest.skipUnless(os.name == 'nt', "requires Windows")
+    def test_win32_mkdir_700(self):
+        base = os_helper.TESTFN
+        path1 = os.path.join(os_helper.TESTFN, 'dir1')
+        path2 = os.path.join(os_helper.TESTFN, 'dir2')
+        # mode=0o700 is special-cased to override ACLs on Windows
+        # There's no way to know exactly how the ACLs will look, so we'll
+        # check that they are different from a regularly created directory.
+        os.mkdir(path1, mode=0o700)
+        os.mkdir(path2, mode=0o777)
+
+        out1 = subprocess.check_output(["icacls.exe", path1], encoding="oem")
+        out2 = subprocess.check_output(["icacls.exe", path2], encoding="oem")
+        os.rmdir(path1)
+        os.rmdir(path2)
+        out1 = out1.replace(path1, "<PATH>")
+        out2 = out2.replace(path2, "<PATH>")
+        self.assertNotEqual(out1, out2)
+
     def tearDown(self):
         path = os.path.join(os_helper.TESTFN, 'dir1', 'dir2', 'dir3',
                             'dir4', 'dir5', 'dir6')
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index b64b6a4f2baeb5..19ddeaa169bf93 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -13,6 +13,7 @@
 import weakref
 import gc
 import shutil
+import subprocess
 from unittest import mock
 
 import unittest
@@ -803,6 +804,33 @@ def test_mode(self):
         finally:
             os.rmdir(dir)
 
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_mode_win32(self):
+        # Use icacls.exe to extract the users with some level of access
+        # Main thing we are testing is that the BUILTIN\Users group has
+        # no access. The exact ACL is going to vary based on which user
+        # is running the test.
+        dir = self.do_create()
+        try:
+            out = subprocess.check_output(["icacls.exe", dir], encoding="oem").casefold()
+        finally:
+            os.rmdir(dir)
+
+        dir = dir.casefold()
+        users = set()
+        found_user = False
+        for line in out.strip().splitlines():
+            acl = None
+            # First line of result includes our directory
+            if line.startswith(dir):
+                acl = line.removeprefix(dir).strip()
+            elif line and line[:1].isspace():
+                acl = line.strip()
+            if acl:
+                users.add(acl.partition(":")[0])
+
+        self.assertNotIn(r"BUILTIN\Users".casefold(), users)
+
     def test_collision_with_existing_file(self):
         # mkdtemp tries another name when a file with
         # the chosen name already exists
diff --git a/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst b/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
new file mode 100644
index 00000000000000..8ac48aac816a60
--- /dev/null
+++ b/Misc/NEWS.d/next/Security/2024-05-01-20-57-09.gh-issue-118486.K44KJG.rst
@@ -0,0 +1,4 @@
+:func:`os.mkdir` on Windows now accepts *mode* of ``0o700`` to restrict
+the new directory to the current user. This fixes :cve:`2024-4030`
+affecting :func:`tempfile.mkdtemp` in scenarios where the base temporary
+directory is more permissive than the default.
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index 8fce40bb686783..ebd076b4e44214 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -32,6 +32,8 @@
 #  include <winioctl.h>
 #  include <lmcons.h>             // UNLEN
 #  include "osdefs.h"             // SEP
+#  include <aclapi.h>             // SetEntriesInAcl
+#  include <sddl.h>               // SDDL_REVISION_1
 #  if defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM)
 #    define HAVE_SYMLINK
 #  endif /* MS_WINDOWS_DESKTOP | MS_WINDOWS_SYSTEM */
@@ -5342,6 +5344,12 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 /*[clinic end generated code: output=a70446903abe821f input=a61722e1576fab03]*/
 {
     int result;
+#ifdef MS_WINDOWS
+    int error = 0;
+    int pathError = 0;
+    SECURITY_ATTRIBUTES secAttr = { sizeof(secAttr) };
+    SECURITY_ATTRIBUTES *pSecAttr = NULL;
+#endif
 #ifdef HAVE_MKDIRAT
     int mkdirat_unavailable = 0;
 #endif
@@ -5353,11 +5361,38 @@ os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd)
 
 #ifdef MS_WINDOWS
     Py_BEGIN_ALLOW_THREADS
-    result = CreateDirectoryW(path->wide, NULL);
+    if (mode == 0700 /* 0o700 */) {
+        ULONG sdSize;
+        pSecAttr = &secAttr;
+        // Set a discreationary ACL (D) that is protected (P) and includes
+        // inheritable (OICI) entries that allow (A) full control (FA) to
+        // SYSTEM (SY), Administrators (BA), and the owner (OW).
+        if (!ConvertStringSecurityDescriptorToSecurityDescriptorW(
+            L"D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)",
+            SDDL_REVISION_1,
+            &secAttr.lpSecurityDescriptor,
+            &sdSize
+        )) {
+            error = GetLastError();
+        }
+    }
+    if (!error) {
+        result = CreateDirectoryW(path->wide, pSecAttr);
+        if (secAttr.lpSecurityDescriptor &&
+            // uncommonly, LocalFree returns non-zero on error, but still uses
+            // GetLastError() to see what the error code is
+            LocalFree(secAttr.lpSecurityDescriptor)) {
+            error = GetLastError();
+        }
+    }
     Py_END_ALLOW_THREADS
 
-    if (!result)
+    if (error) {
+        return PyErr_SetFromWindowsErr(error);
+    }
+    if (!result) {
         return path_error(path);
+    }
 #else
     Py_BEGIN_ALLOW_THREADS
 #if HAVE_MKDIRAT",
"url": "https://github.com/python/cpython/commit/eb29e2f5905da93333d1ce78bc98b151e763ff46.patch"
}
] |
CWE-276 Incorrect Default Permissions
|
CVE-2025-67724
|
Tornado vulnerable to Header Injection and XSS via reason argument
|
Tornado is a Python web framework and asynchronous networking library. In versions 6.5.2 and below, the supplied reason phrase is used unescaped in HTTP headers (where it could be used for header injection) or in HTML in the default error page (where it could be used for XSS) and can be exploited by passing untrusted or malicious data into the reason argument. Used by both RequestHandler.set_status and tornado.web.HTTPError, the argument is designed to allow applications to pass custom "reason" phrases (the "Not Found" in HTTP/1.1 404 Not Found) to the HTTP status line (mainly for non-standard status codes). This issue is fixed in version 6.5.3.
|
[
{
"commit_message": "[PATCH] web: Harden against invalid HTTP reason phrases We allow applications to set custom reason phrases for the HTTP status line (to support custom status codes), but if this were exposed to untrusted data it could be exploited in various ways. This commit guards against invalid reason phrases in both HTTP headers and in error pages. tornado/test/web_test.py | 15 ++++++++++++++- tornado/web.py | 25 +++++++++++++++++++------ 2 files changed, 33 insertions(+), 7 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/tornadoweb/tornado/commit/9c163aebeaad9e6e7d28bac1f33580eb00b0e421.patch"
}
] |
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
CVE-2016-6271
|
The Bzrtp library (aka libbzrtp) 1.0.x before 1.0.4 allows man-in-the-middle attackers to conduct spoofing attacks by leveraging a missing HVI check on DHPart2 packet reception.
|
[
{
"commit_message": "[PATCH] Add ZRTP Commit packet hvi check on DHPart2 packet reception include/packetParser.h | 1 + src/packetParser.c | 28 ++++++++++++++++++++++- test/bzrtpParserTest.c | 51 ++++++++++++++++++++++++++++++++++++++++-- test/bzrtpParserTest.h | 1 + test/bzrtpTest.c | 1 + 5 files changed, 79 insertions(+), 3 deletions(-)",
"patch_text_b64": "From bbb1e6e2f467ee4bd7b9a8c800e4f07343d7d99b Mon Sep 17 00:00:00 2001
From: Johan Pascal <johan.pascal@belledonne-communications.com>
Date: Thu, 31 Mar 2016 17:42:30 +0200
Subject: [PATCH] Add ZRTP Commit packet hvi check on DHPart2 packet reception

---
 include/packetParser.h |  1 +
 src/packetParser.c     | 28 ++++++++++++++++++++++-
 test/bzrtpParserTest.c | 51 ++++++++++++++++++++++++++++++++++++++++--
 test/bzrtpParserTest.h |  1 +
 test/bzrtpTest.c       |  1 +
 5 files changed, 79 insertions(+), 3 deletions(-)

diff --git a/include/packetParser.h b/include/packetParser.h
index 622213f..95ec6d5 100644
--- a/include/packetParser.h
+++ b/include/packetParser.h
@@ -42,6 +42,7 @@
 #define		BZRTP_PARSER_ERROR_UNMATCHINGHASHCHAIN	0xa080
 #define		BZRTP_PARSER_ERROR_UNMATCHINGMAC		0xa100
 #define		BZRTP_PARSER_ERROR_UNEXPECTEDMESSAGE	0xa200
+#define		BZRTP_PARSER_ERROR_UNMATCHINGHVI		0xa400
 
 #define		BZRTP_BUILDER_ERROR_INVALIDPACKET		0x5001
 #define		BZRTP_BUILDER_ERROR_INVALIDMESSAGE		0x5002
diff --git a/src/packetParser.c b/src/packetParser.c
index 767c5d4..2ca5cdb 100644
--- a/src/packetParser.c
+++ b/src/packetParser.c
@@ -438,6 +438,32 @@ int bzrtp_packetParser(bzrtpContext_t *zrtpContext, bzrtpChannelContext_t *zrtpC
 						free (messageData);
 						return BZRTP_PARSER_ERROR_UNMATCHINGMAC;
 					}
+
+					/* Check the hvi received in the commit message  - RFC section 4.4.1.1*/
+					/* First compute the expected hvi */
+					/* hvi = hash(initiator's DHPart2 message(current zrtpPacket)) || responder's Hello message) using the agreed hash function truncated to 256 bits */
+					/* create a string with the messages concatenated */
+					{
+						uint8_t computedHvi[32];
+						uint16_t HelloMessageLength = zrtpChannelContext->selfPackets[HELLO_MESSAGE_STORE_ID]->messageLength;
+						uint16_t DHPartHelloMessageStringLength = zrtpPacket->messageLength + HelloMessageLength;
+
+						uint8_t *DHPartHelloMessageString = (uint8_t *)malloc(DHPartHelloMessageStringLength*sizeof(uint8_t));
+
+						memcpy(DHPartHelloMessageString, input+ZRTP_PACKET_HEADER_LENGTH, zrtpPacket->messageLength);
+						memcpy(DHPartHelloMessageString+zrtpPacket->messageLength, zrtpChannelContext->selfPackets[HELLO_MESSAGE_STORE_ID]->packetString+ZRTP_PACKET_HEADER_LENGTH, HelloMessageLength);
+
+						zrtpChannelContext->hashFunction(DHPartHelloMessageString, DHPartHelloMessageStringLength, 32, computedHvi);
+
+						free(DHPartHelloMessageString);
+
+						/* Compare computed and received hvi */
+						if (memcmp(computedHvi, peerCommitMessageData->hvi, 32)!=0) {
+							free (messageData);
+							return BZRTP_PARSER_ERROR_UNMATCHINGHVI;
+						}
+					}
+
 				} else { /* if we are initiator(we didn't received any commit message and then no H2), we must check that H3=SHA256(SHA256(H1)) and the Hello message MAC */
 					uint8_t checkH2[32];
 					uint8_t checkH3[32];
@@ -482,7 +508,7 @@ int bzrtp_packetParser(bzrtpContext_t *zrtpContext, bzrtpChannelContext_t *zrtpC
 				/* attach the message structure to the packet one */
 				zrtpPacket->messageData = (void *)messageData;
 
-				/* the parsed commit packet must be saved as it is used to generate the total_hash */
+				/* the parsed packet must be saved as it is used to generate the total_hash */
 				zrtpPacket->packetString = (uint8_t *)malloc(inputLength*sizeof(uint8_t));
 				memcpy(zrtpPacket->packetString, input, inputLength); /* store the whole packet even if we may use the message only */
 			}
diff --git a/test/bzrtpParserTest.c b/test/bzrtpParserTest.c
index cf67bb5..faa1b8c 100644
--- a/test/bzrtpParserTest.c
+++ b/test/bzrtpParserTest.c
@@ -101,7 +101,8 @@ uint8_t mackeyr[32] = {0x3a, 0xa5, 0x22, 0x43, 0x26, 0x13, 0x8f, 0xd6, 0x54, 0x5
 uint8_t zrtpkeyi[16] = {0x22, 0xf6, 0xea, 0xaa, 0xa4, 0xad, 0x53, 0x30, 0x71, 0x97, 0xcc, 0x68, 0x6b, 0xb0, 0xcb, 0x55};
 uint8_t zrtpkeyr[16] = {0x09, 0x50, 0xcd, 0x9e, 0xc2, 0x78, 0x54, 0x31, 0x93, 0x2e, 0x99, 0x31, 0x15, 0x58, 0xd0, 0x2a};
 
-void test_parser(void) {
+
+void test_parser_param(uint8_t hvi_trick) {
 	int i, retval;
 	bzrtpPacket_t *zrtpPacket;
 
@@ -159,13 +160,34 @@ void test_parser(void) {
 		/* parse a packet string from patterns */
 		zrtpPacket = bzrtp_packetCheck(patternZRTPPackets[i], patternZRTPMetaData[i][0], (patternZRTPMetaData[i][1])-1, &retval);
 		retval +=  bzrtp_packetParser((patternZRTPMetaData[i][2]==0x87654321)?context12345678:context87654321, (patternZRTPMetaData[i][2]==0x87654321)?context12345678->channelContext[0]:context87654321->channelContext[0], patternZRTPPackets[i], patternZRTPMetaData[i][0], zrtpPacket);
-		/*printf("parsing Ret val is %x index is %d\n", retval, i);*/
+		if (hvi_trick==0) {
+			CU_ASSERT_EQUAL_FATAL(retval,0);
+		} else { /* when hvi trick is enable, the DH2 parsing shall fail and return BZRTP_PARSER_ERROR_UNMATCHINGHVI */
+			if (zrtpPacket->messageType==MSGTYPE_DHPART2) {
+				CU_ASSERT_EQUAL_FATAL(retval, BZRTP_PARSER_ERROR_UNMATCHINGHVI);
+				/* We shall then anyway skip the end of the test */
+				/* reset pointers to selfHello packet in order to avoid double free */
+				context87654321->channelContext[0]->selfPackets[HELLO_MESSAGE_STORE_ID] = NULL;
+				context12345678->channelContext[0]->selfPackets[HELLO_MESSAGE_STORE_ID] = NULL;
+
+				bzrtp_destroyBzrtpContext(context87654321, 0x87654321);
+				bzrtp_destroyBzrtpContext(context12345678, 0x12345678);
+
+				return;
+
+			} else {
+				CU_ASSERT_EQUAL_FATAL(retval,0);
+			}
+		}
+			bzrtp_message("parsing Ret val is %x index is %d\n", retval, i);
 		/* We must store some packets in the context if we want to be able to parse further packets */
 		if (zrtpPacket->messageType==MSGTYPE_HELLO) {
 			if (patternZRTPMetaData[i][2]==0x87654321) {
 				context12345678->channelContext[0]->peerPackets[HELLO_MESSAGE_STORE_ID] = zrtpPacket;
+				context87654321->channelContext[0]->selfPackets[HELLO_MESSAGE_STORE_ID] = zrtpPacket;
 			} else {
 				context87654321->channelContext[0]->peerPackets[HELLO_MESSAGE_STORE_ID] = zrtpPacket;
+				context12345678->channelContext[0]->selfPackets[HELLO_MESSAGE_STORE_ID] = zrtpPacket;
 			}
 			freePacketFlag = 0;
 		}
@@ -205,13 +227,38 @@ void test_parser(void) {
 		if (freePacketFlag == 1) {
 			bzrtp_freeZrtpPacket(zrtpPacket);
 		}
+
+		/* modify the hvi stored in the peerPackets, this shall result in parsing failure on DH2 packet */
+		if (hvi_trick == 1) {
+			if (zrtpPacket->messageType==MSGTYPE_COMMIT) {
+				if (patternZRTPMetaData[i][2]==0x87654321) {
+					bzrtpCommitMessage_t *peerCommitMessageData;
+					peerCommitMessageData = (bzrtpCommitMessage_t *)zrtpPacket->messageData;
+					peerCommitMessageData->hvi[0]=0xFF;
+				}
+			}
+		}
+
 	}
 
+	/* reset pointers to selfHello packet in order to avoid double free */
+	context87654321->channelContext[0]->selfPackets[HELLO_MESSAGE_STORE_ID] = NULL;
+	context12345678->channelContext[0]->selfPackets[HELLO_MESSAGE_STORE_ID] = NULL;
+
+
 	bzrtp_destroyBzrtpContext(context87654321, 0x87654321);
 	bzrtp_destroyBzrtpContext(context12345678, 0x12345678);
 
 }
 
+void test_parser(void) {
+	test_parser_param(0);
+}
+
+void test_parser_hvi(void) {
+	test_parser_param(1);
+}
+
 /* context structure mainly used by statemachine test, but also needed by parserComplete to get the zid Filename */
 typedef struct my_Context_struct {
 	unsigned char nom[30]; /* nom du contexte */
diff --git a/test/bzrtpParserTest.h b/test/bzrtpParserTest.h
index 8a70878..74548f2 100644
--- a/test/bzrtpParserTest.h
+++ b/test/bzrtpParserTest.h
@@ -20,5 +20,6 @@
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */
 void test_parser(void);
+void test_parser_hvi(void);
 void test_parserComplete(void);
 void test_stateMachine(void);
diff --git a/test/bzrtpTest.c b/test/bzrtpTest.c
index dba439d..a9fa90f 100644
--- a/test/bzrtpTest.c
+++ b/test/bzrtpTest.c
@@ -75,6 +75,7 @@ int main(int argc, char *argv[] ) {
 	/* Add the parser suite to the registry */
 	parserTestSuite = CU_add_suite("Bzrtp ZRTP Packet Parser", NULL, NULL);
 	CU_add_test(parserTestSuite, "Parse", test_parser);
+	CU_add_test(parserTestSuite, "Parse hvi check fail", test_parser_hvi);
 	CU_add_test(parserTestSuite, "Parse Exchange", test_parserComplete);
 	CU_add_test(parserTestSuite, "State machine", test_stateMachine);",
"url": "https://github.com/BelledonneCommunications/bzrtp/commit/bbb1e6e2f467ee4bd7b9a8c800e4f07343d7d99b.patch"
}
] |
n/a
|
|
CVE-2016-9387
|
Integer overflow in the jpc_dec_process_siz function in libjasper/jpc/jpc_dec.c in JasPer before 1.900.13 allows remote attackers to have unspecified impact via a crafted file, which triggers an assertion failure.
|
[
{
"commit_message": "[PATCH] Fixed another integer overflow problem. src/libjasper/jpc/jpc_dec.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)",
"patch_text_b64": "RnJvbSBkOTExOThhYmQwMGZjNDM1YTM5N2ZlNmJhZDkwNmE0YzE3NDhlOWNmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWNoYWVsIEFkYW1zIDxtZGFkYW1zQGVjZS51dmljLmNhPgpEYXRlOiBTdW4sIDIzIE9jdCAyMDE2IDAzOjM0OjM1IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gRml4ZWQgYW5vdGhlciBpbnRlZ2VyIG92ZXJmbG93IHByb2JsZW0uCgotLS0KIHNyYy9saWJqYXNwZXIvanBjL2pwY19kZWMuYyB8IDYgKysrKystCiAxIGZpbGUgY2hhbmdlZCwgNSBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2xpYmphc3Blci9qcGMvanBjX2RlYy5jIGIvc3JjL2xpYmphc3Blci9qcGMvanBjX2RlYy5jCmluZGV4IGQyZjI1OGUzLi40ZjI0NjYwZCAxMDA2NDQKLS0tIGEvc3JjL2xpYmphc3Blci9qcGMvanBjX2RlYy5jCisrKyBiL3NyYy9saWJqYXNwZXIvanBjL2pwY19kZWMuYwpAQCAtMTE5NSw2ICsxMTk1LDcgQEAgc3RhdGljIGludCBqcGNfZGVjX3Byb2Nlc3Nfc2l6KGpwY19kZWNfdCAqZGVjLCBqcGNfbXNfdCAqbXMpCiAJaW50IGh0aWxlbm87CiAJaW50IHZ0aWxlbm87CiAJanBjX2RlY19jbXB0X3QgKmNtcHQ7CisJc2l6ZV90IHNpemU7CiAKIAlkZWMtPnhzdGFydCA9IHNpei0+eG9mZjsKIAlkZWMtPnlzdGFydCA9IHNpei0+eW9mZjsKQEAgLTEyMzEsNyArMTIzMiwxMCBAQCBzdGF0aWMgaW50IGpwY19kZWNfcHJvY2Vzc19zaXooanBjX2RlY190ICpkZWMsIGpwY19tc190ICptcykKIAogCWRlYy0+bnVtaHRpbGVzID0gSlBDX0NFSUxESVYoZGVjLT54ZW5kIC0gZGVjLT50aWxleG9mZiwgZGVjLT50aWxld2lkdGgpOwogCWRlYy0+bnVtdnRpbGVzID0gSlBDX0NFSUxESVYoZGVjLT55ZW5kIC0gZGVjLT50aWxleW9mZiwgZGVjLT50aWxlaGVpZ2h0KTsKLQlkZWMtPm51bXRpbGVzID0gZGVjLT5udW1odGlsZXMgKiBkZWMtPm51bXZ0aWxlczsKKwlpZiAoIWphc19zYWZlX3NpemVfbXVsKGRlYy0+bnVtaHRpbGVzLCBkZWMtPm51bXZ0aWxlcywgJnNpemUpKSB7CisJCXJldHVybiAtMTsKKwl9CisJZGVjLT5udW10aWxlcyA9IHNpemU7CiAJSkFTX0RCR0xPRygxMCwgKCJudW10aWxlcyA9ICVkOyBudW1odGlsZXMgPSAlZDsgbnVtdnRpbGVzID0gJWQ7XG4iLAogCSAgZGVjLT5udW10aWxlcywgZGVjLT5udW1odGlsZXMsIGRlYy0+bnVtdnRpbGVzKSk7CiAJaWYgKCEoZGVjLT50aWxlcyA9IGphc19hbGxvYzIoZGVjLT5udW10aWxlcywgc2l6ZW9mKGpwY19kZWNfdGlsZV90KSkpKSB7",
"url": "https://github.com/mdadams/jasper/commit/d91198abd00fc435a397fe6bad906a4c1748e9cf.patch"
}
] |
n/a
|
|
PYSEC-2021-655
| null |
[
{
"commit_message": "[PATCH] Fix heap buffer overflow caused by rounding. This was hard to fix. Due to the way we compute the pixels that influence an output pixel in resized images, for certain input configuration we might have issued a read to a pixel that is outside of boundary of the original image. This is because of floating errors that affected truncation results. PiperOrigin-RevId: 369757871 Change-Id: If89425fff930983829a2168203c11858883eebc9 tensorflow/core/kernels/quantized_resize_bilinear_op.cc | 2 ++ 1 file changed, 2 insertions(+)",
"patch_text_b64": "RnJvbSBmODUxNjEzZjhmMGZiMGM4MzhkMTYwY2VkMTNjMTM0Zjc3OGUzY2U3IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWhhaSBNYXJ1c2VhYyA8bWloYWltYXJ1c2VhY0Bnb29nbGUuY29tPgpEYXRlOiBXZWQsIDIxIEFwciAyMDIxIDE2OjIwOjQ4IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gRml4IGhlYXAgYnVmZmVyIG92ZXJmbG93IGNhdXNlZCBieSByb3VuZGluZy4KClRoaXMgd2FzIGhhcmQgdG8gZml4LiBEdWUgdG8gdGhlIHdheSB3ZSBjb21wdXRlIHRoZSBwaXhlbHMgdGhhdCBpbmZsdWVuY2UgYW4gb3V0cHV0IHBpeGVsIGluIHJlc2l6ZWQgaW1hZ2VzLCBmb3IgY2VydGFpbiBpbnB1dCBjb25maWd1cmF0aW9uIHdlIG1pZ2h0IGhhdmUgaXNzdWVkIGEgcmVhZCB0byBhIHBpeGVsIHRoYXQgaXMgb3V0c2lkZSBvZiBib3VuZGFyeSBvZiB0aGUgb3JpZ2luYWwgaW1hZ2UuIFRoaXMgaXMgYmVjYXVzZSBvZiBmbG9hdGluZyBlcnJvcnMgdGhhdCBhZmZlY3RlZCB0cnVuY2F0aW9uIHJlc3VsdHMuCgpQaXBlck9yaWdpbi1SZXZJZDogMzY5NzU3ODcxCkNoYW5nZS1JZDogSWY4OTQyNWZmZjkzMDk4MzgyOWEyMTY4MjAzYzExODU4ODgzZWViYzkKLS0tCiB0ZW5zb3JmbG93L2NvcmUva2VybmVscy9xdWFudGl6ZWRfcmVzaXplX2JpbGluZWFyX29wLmNjIHwgMiArKwogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL3RlbnNvcmZsb3cvY29yZS9rZXJuZWxzL3F1YW50aXplZF9yZXNpemVfYmlsaW5lYXJfb3AuY2MgYi90ZW5zb3JmbG93L2NvcmUva2VybmVscy9xdWFudGl6ZWRfcmVzaXplX2JpbGluZWFyX29wLmNjCmluZGV4IDA3NDUzYzdlNzMyODRiLi4yZmQ4MDdmNmRmOTYxNCAxMDA2NDQKLS0tIGEvdGVuc29yZmxvdy9jb3JlL2tlcm5lbHMvcXVhbnRpemVkX3Jlc2l6ZV9iaWxpbmVhcl9vcC5jYworKysgYi90ZW5zb3JmbG93L2NvcmUva2VybmVscy9xdWFudGl6ZWRfcmVzaXplX2JpbGluZWFyX29wLmNjCkBAIC02NCw2ICs2NCw4IEBAIGlubGluZSB2b2lkIENvbXB1dGVJbnRlcnBvbGF0aW9uV2VpZ2h0cygKICAgICAgICAgc3RkOjptYXgoc3RhdGljX2Nhc3Q8aW50NjQ+KGluX2YpLCBzdGF0aWNfY2FzdDxpbnQ2ND4oMCkpOwogICAgIGludGVycG9sYXRpb24tPnVwcGVyW2ldID0KICAgICAgICAgc3RkOjptaW4oc3RhdGljX2Nhc3Q8aW50NjQ+KHN0ZDo6Y2VpbChpbikpLCBpbl9zaXplIC0gMSk7CisgICAgaW50ZXJwb2xhdGlvbi0+bG93ZXJbaV0gPQorICAgICAgICBzdGQ6Om1pbihpbnRlcnBvbGF0aW9uLT5sb3dlcltpXSwgaW50ZXJwb2xhdGlvbi0+dXBwZXJbaV0pOwogICAgIGludGVycG9sYXRpb24tPmxlcnBbaV0gPSBpbiAtIGluX2Y7CiAgICAgaW50ZXJwb2xhdGlvbi0+aWxlcnBbaV0gPQogICAgICAgICBzdGF0aWNfY2FzdDxUX1NDQUxFPigoaW4gLSBpbl9mKSAqICgxIDw8IHJlc29sdXRpb24pKTs=",
"url": "https://github.com/tensorflow/tensorflow/commit/f851613f8f0fb0c838d160ced13c134f778e3ce7.patch"
}
] | null |
|
GHSA-2cpx-427x-q2c6
|
CHECK-fail in AddManySparseToTensorsMap
| null |
[
{
"commit_message": "[PATCH] Fix overflow CHECK issue with `tf.raw_ops.AddManySparseToTensorsMap`. PiperOrigin-RevId: 369492969 Change-Id: I1d70d6c0c92e3d7a25bc3b3aa2a0c0ac9688bf81 .../core/kernels/sparse_tensors_map_ops.cc | 26 ++++++++++++++----- 1 file changed, 19 insertions(+), 7 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/tensorflow/tensorflow/commit/69c68ecbb24dff3fa0e46da0d16c821a2dd22d7c.patch"
}
] | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.