import python2-2.7.18-13.module+el8.8.0+19042+06909d2c.1

SOURCES/00394-cve-2022-45061-cpu-denial-of-service-via-inefficient-idna-decoder.patch

@@ -96,3 +96,23 @@ index 00000000000..5185fac2e29
 +length hostname involving bidirectional characters were decoded. Some protocols
 +such as :mod:`urllib` http ``3xx`` redirects potentially allow for an attacker
 +to supply such a name.
+diff -urNp a/Lib/encodings/idna.py b/Lib/encodings/idna.py
+--- a/Lib/encodings/idna.py	2023-02-16 08:58:06.884171667 +0100
++++ b/Lib/encodings/idna.py	2023-02-16 08:59:31.931296399 +0100
+@@ -101,6 +101,16 @@ def ToASCII(label):
+     raise UnicodeError("label empty or too long")
+ 
+ def ToUnicode(label):
++    if len(label) > 1024:
++        # Protection from https://github.com/python/cpython/issues/98433.
++        # https://datatracker.ietf.org/doc/html/rfc5894#section-6
++        # doesn't specify a label size limit prior to NAMEPREP. But having
++        # one makes practical sense.
++        # This leaves ample room for nameprep() to remove Nothing characters
++        # per https://www.rfc-editor.org/rfc/rfc3454#section-3.1 while still
++        # preventing us from wasting time decoding a big thing that'll just
++        # hit the actual <= 63 length limit in Step 6.
++        raise UnicodeError("label way too long")
+     # Step 1: Check for ASCII
+     if isinstance(label, str):
+         pure_ascii = True

SOURCES/00399-cve-2023-24329.patch

@@ -0,0 +1,127 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lumir Balhar <lbalhar@redhat.com>
+Date: Thu, 25 May 2023 10:03:57 +0200
+Subject: [PATCH] 00399-cve-2023-24329.patch
+
+00399 #
+
+* gh-102153: Start stripping C0 control and space chars in `urlsplit` (GH-102508)
+
+`urllib.parse.urlsplit` has already been respecting the WHATWG spec a bit GH-25595.
+
+This adds more sanitizing to respect the "Remove any leading C0 control or space from input" [rule](https://url.spec.whatwg.org/GH-url-parsing:~:text=Remove%20any%20leading%20and%20trailing%20C0%20control%20or%20space%20from%20input.) in response to [CVE-2023-24329](https://nvd.nist.gov/vuln/detail/CVE-2023-24329).
+
+Backported to Python 2 from Python 3.12.
+
+Co-authored-by: Illia Volochii <illia.volochii@gmail.com>
+Co-authored-by: Gregory P. Smith [Google] <greg@krypto.org>
+Co-authored-by: Lumir Balhar <lbalhar@redhat.com>
+---
+ Lib/test/test_urlparse.py | 57 +++++++++++++++++++++++++++++++++++++++
+ Lib/urlparse.py           | 10 +++++++
+ 2 files changed, 67 insertions(+)
+
+diff --git a/Lib/test/test_urlparse.py b/Lib/test/test_urlparse.py
+index 16eefed56f6..419e9c2bdcc 100644
+--- a/Lib/test/test_urlparse.py
++++ b/Lib/test/test_urlparse.py
+@@ -666,7 +666,64 @@ class UrlParseTestCase(unittest.TestCase):
+             self.assertEqual(p.scheme, "https")
+             self.assertEqual(p.geturl(), "https://www.python.org/javascript:alert('msg')/?query=something#fragment")
+ 
++    def test_urlsplit_strip_url(self):
++        noise = "".join([chr(i) for i in range(0, 0x20 + 1)])
++        base_url = "http://User:Pass@www.python.org:080/doc/?query=yes#frag"
+ 
++        url = noise.decode("utf-8") + base_url
++        p = urlparse.urlsplit(url)
++        self.assertEqual(p.scheme, "http")
++        self.assertEqual(p.netloc, "User:Pass@www.python.org:080")
++        self.assertEqual(p.path, "/doc/")
++        self.assertEqual(p.query, "query=yes")
++        self.assertEqual(p.fragment, "frag")
++        self.assertEqual(p.username, "User")
++        self.assertEqual(p.password, "Pass")
++        self.assertEqual(p.hostname, "www.python.org")
++        self.assertEqual(p.port, 80)
++        self.assertEqual(p.geturl(), base_url)
++
++        url = noise + base_url.encode("utf-8")
++        p = urlparse.urlsplit(url)
++        self.assertEqual(p.scheme, b"http")
++        self.assertEqual(p.netloc, b"User:Pass@www.python.org:080")
++        self.assertEqual(p.path, b"/doc/")
++        self.assertEqual(p.query, b"query=yes")
++        self.assertEqual(p.fragment, b"frag")
++        self.assertEqual(p.username, b"User")
++        self.assertEqual(p.password, b"Pass")
++        self.assertEqual(p.hostname, b"www.python.org")
++        self.assertEqual(p.port, 80)
++        self.assertEqual(p.geturl(), base_url.encode("utf-8"))
++
++        # Test that trailing space is preserved as some applications rely on
++        # this within query strings.
++        query_spaces_url = "https://www.python.org:88/doc/?query=    "
++        p = urlparse.urlsplit(noise.decode("utf-8") + query_spaces_url)
++        self.assertEqual(p.scheme, "https")
++        self.assertEqual(p.netloc, "www.python.org:88")
++        self.assertEqual(p.path, "/doc/")
++        self.assertEqual(p.query, "query=    ")
++        self.assertEqual(p.port, 88)
++        self.assertEqual(p.geturl(), query_spaces_url)
++
++        p = urlparse.urlsplit("www.pypi.org ")
++        # That "hostname" gets considered a "path" due to the
++        # trailing space and our existing logic...  YUCK...
++        # and re-assembles via geturl aka unurlsplit into the original.
++        # django.core.validators.URLValidator (at least through v3.2) relies on
++        # this, for better or worse, to catch it in a ValidationError via its
++        # regular expressions.
++        # Here we test the basic round trip concept of such a trailing space.
++        self.assertEqual(urlparse.urlunsplit(p), "www.pypi.org ")
++
++        # with scheme as cache-key
++        url = "//www.python.org/"
++        scheme = noise.decode("utf-8") + "https" + noise.decode("utf-8")
++        for _ in range(2):
++            p = urlparse.urlsplit(url, scheme=scheme)
++            self.assertEqual(p.scheme, "https")
++            self.assertEqual(p.geturl(), "https://www.python.org/")
+ 
+     def test_attributes_bad_port(self):
+         """Check handling of non-integer ports."""
+diff --git a/Lib/urlparse.py b/Lib/urlparse.py
+index 6cc40a8d2fb..0f03a7cc4a9 100644
+--- a/Lib/urlparse.py
++++ b/Lib/urlparse.py
+@@ -26,6 +26,10 @@ scenarios for parsing, and for backward compatibility purposes, some
+ parsing quirks from older RFCs are retained. The testcases in
+ test_urlparse.py provides a good indicator of parsing behavior.
+ 
++The WHATWG URL Parser spec should also be considered.  We are not compliant with
++it either due to existing user code API behavior expectations (Hyrum's Law).
++It serves as a useful guide when making changes.
++
+ """
+ 
+ import re
+@@ -63,6 +67,10 @@ scheme_chars = ('abcdefghijklmnopqrstuvwxyz'
+                 '0123456789'
+                 '+-.')
+ 
++# Leading and trailing C0 control and space to be stripped per WHATWG spec.
++# == "".join([chr(i) for i in range(0, 0x20 + 1)])
++_WHATWG_C0_CONTROL_OR_SPACE = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f '
++
+ # Unsafe bytes to be removed per WHATWG spec
+ _UNSAFE_URL_BYTES_TO_REMOVE = ['\t', '\r', '\n']
+ 
+@@ -201,6 +209,8 @@ def urlsplit(url, scheme='', allow_fragments=True):
+     (e.g. netloc is a single string) and we don't expand % escapes."""
+     url = _remove_unsafe_bytes_from_url(url)
+     scheme = _remove_unsafe_bytes_from_url(scheme)
++    url = url.lstrip(_WHATWG_C0_CONTROL_OR_SPACE)
++    scheme = scheme.strip(_WHATWG_C0_CONTROL_OR_SPACE)
+     allow_fragments = bool(allow_fragments)
+     key = url, scheme, allow_fragments, type(url), type(scheme)
+     cached = _parse_cache.get(key, None)

SPECS/python2.spec

@@ -104,7 +104,7 @@ Summary: An interpreted, interactive, object-oriented programming language
 Name: %{python}
 # Remember to also rebase python2-docs when changing this:
 Version: 2.7.18
-Release: 12%{?dist}
+Release: 13%{?dist}.1
 License: Python
 Group: Development/Languages
 Requires: %{python}-libs%{?_isa} = %{version}-%{release}
@@ -816,6 +816,16 @@ Patch382: 00382-cve-2015-20107.patch
 # Backported from python3.
 Patch394: 00394-cve-2022-45061-cpu-denial-of-service-via-inefficient-idna-decoder.patch
 
+# 00399 #
+# * gh-102153: Start stripping C0 control and space chars in `urlsplit` (GH-102508)
+#
+# `urllib.parse.urlsplit` has already been respecting the WHATWG spec a bit GH-25595.
+#
+# This adds more sanitizing to respect the "Remove any leading C0 control or space from input" [rule](https://url.spec.whatwg.org/GH-url-parsing:~:text=Remove%%20any%%20leading%%20and%%20trailing%%20C0%%20control%%20or%%20space%%20from%%20input.) in response to [CVE-2023-24329](https://nvd.nist.gov/vuln/detail/CVE-2023-24329).
+#
+# Backported to Python 2 from Python 3.12.
+Patch399: 00399-cve-2023-24329.patch
+
 # (New patches go here ^^^)
 #
 # When adding new patches to "python2" and "python3" in Fedora, EL, etc.,
@@ -1150,6 +1160,7 @@ git apply %{PATCH351}
 %patch378 -p1
 %patch382 -p1
 %patch394 -p1
+%patch399 -p1
 
 
 # This shouldn't be necesarry, but is right now (2.2a3)
@@ -2089,6 +2100,13 @@ fi
 # ======================================================
 
 %changelog
+* Thu May 25 2023 Charalampos Stratakis <cstratak@redhat.com> - 2.7.18-13.1
+- Fix for CVE-2023-24329
+Resolves: rhbz#2173917
+
+* Thu Feb 16 2023 Josef Ridky <jridky@redhat.com> - 2.7.18-13
+- Add missing part of fix for CVE-2022-45061 (#2145071)
+
 * Wed Dec 21 2022 Charalampos Stratakis <cstratak@redhat.com> - 2.7.18-12
 - Security fix for CVE-2022-45061: CPU denial of service via inefficient IDNA decoder
 Resolves: rhbz#2144072