fixup! gh-125318: Fix validation of zoneinfo false friends

Author: pganssle

Lib/test/test_zoneinfo/test_zoneinfo.py

@@ -443,19 +443,16 @@ def __eq__(self, other):
             self.assertFalse(key.eq_called)
             self.assertIs(tz2, tz1)
 
-
-class CZoneInfoTest(ZoneInfoTest):
-    module = c_zoneinfo
-
     def test_duck_typed_invalid_values(self):
         long_max = (1 << (struct.calcsize("l") * 8 - 1)) - 1
+        int_max = (1 << (struct.calcsize("i") * 8 - 1)) - 1
         cases = [
-            ("fold", value, ValueError, f"fold must be 0 or 1, got {value}")
+            ("fold", value, ValueError, f"fold must be 0 or 1, not {value}")
             for value in (-1, 2, 3, 256, long_max, -long_max - 1)
         ]
         cases.extend(
             ("year", value, ValueError, f"year must be in 1..9999, not {value}")
-            for value in (0, -1, 10000)
+            for value in (0, -1, 10000, int_max, -int_max - 1)
         )
         cases.extend(
             (attr, value, exc, message)
@@ -464,21 +461,29 @@ def test_duck_typed_invalid_values(self):
                 (1 << 100, OverflowError, ""),
                 (-(1 << 100), OverflowError, ""),
                 (None, TypeError, ""),
+                (1.0, TypeError, ""),
             )
         )
+        cases.extend(
+            (attr, value, OverflowError, "")
+            for attr, maximum in (("fold", long_max), ("year", int_max))
+            for value in (maximum + 1, -maximum - 2)
+        )
         # Use a date beyond the last transition to exercise year validation.
         dt = datetime(2040, 1, 1)
-        zi = self.zone_from_key("Europe/London")
         for attr, value, exc, message in cases:
             false_friend = types.SimpleNamespace(
                 year=dt.year, hour=0, minute=0, second=0, fold=0,
                 toordinal=dt.toordinal,
             )
             setattr(false_friend, attr, value)
-            for method in (zi.utcoffset, zi.dst, zi.tzname):
-                with self.subTest(attr=attr, value=value, method=method):
-                    with self.assertRaisesRegex(exc, re.escape(message)):
-                        method(false_friend)
+            for key in ("Europe/London", "UTC"):
+                zi = self.zone_from_key(key)
+                for method in (zi.utcoffset, zi.dst, zi.tzname):
+                    with self.subTest(attr=attr, value=value, key=key,
+                                      method=method):
+                        with self.assertRaisesRegex(exc, re.escape(message)):
+                            method(false_friend)
 
     def test_duck_typed_valid_boundaries(self):
         zi = self.zone_from_key("Europe/London")
@@ -493,6 +498,30 @@ def test_duck_typed_valid_boundaries(self):
                     with self.subTest(year=year, fold=fold, method=method):
                         self.assertEqual(method(false_friend), method(dt))
 
+    def test_duck_typed_index(self):
+        class Index:
+            def __init__(self, value):
+                self.value = value
+
+            def __index__(self):
+                return self.value
+
+        zi = self.zone_from_key("Europe/London")
+        for fold in (0, 1):
+            # An ambiguous time beyond the last explicit transition.
+            dt = datetime(2040, 10, 28, 1, 30, fold=fold)
+            false_friend = types.SimpleNamespace(
+                year=Index(dt.year), hour=dt.hour, minute=dt.minute,
+                second=dt.second, fold=Index(fold), toordinal=dt.toordinal,
+            )
+            for method in (zi.utcoffset, zi.dst, zi.tzname):
+                with self.subTest(fold=fold, method=method):
+                    self.assertEqual(method(false_friend), method(dt))
+
+
+class CZoneInfoTest(ZoneInfoTest):
+    module = c_zoneinfo
+
     @unittest.skipIf(MISSING_C_DOCSTRINGS,
                      "Signature information for builtins requires docstrings")
     def test_signatures(self):

Lib/zoneinfo/_zoneinfo.py

@@ -2,7 +2,9 @@
 import calendar
 import collections
 import functools
+import operator
 import re
+import struct
 import weakref
 from datetime import datetime, timedelta, tzinfo
 
@@ -11,6 +13,10 @@
 EPOCH = datetime(1970, 1, 1)
 EPOCHORDINAL = datetime(1970, 1, 1).toordinal()
 
+# Match the integer conversions in the C implementation.
+_LONG_MAX = (1 << (struct.calcsize("l") * 8 - 1)) - 1
+_INT_MAX = (1 << (struct.calcsize("i") * 8 - 1)) - 1
+
 # It is relatively expensive to construct new timedelta objects, and in most
 # cases we're looking at the same deltas, like integer numbers of hours, etc.
 # To improve speed and memory use, we'll keep a dictionary with references
@@ -168,15 +174,26 @@ def _find_trans(self, dt):
 
         ts = self._get_local_timestamp(dt)
 
-        lt = self._trans_local[dt.fold]
+        fold = operator.index(dt.fold)
+        if not -_LONG_MAX - 1 <= fold <= _LONG_MAX:
+            raise OverflowError("Python int too large to convert to C long")
+        if not 0 <= fold <= 1:
+            raise ValueError(f"fold must be 0 or 1, not {fold}")
+
+        lt = self._trans_local[fold]
 
         num_trans = len(lt)
 
         if num_trans and ts < lt[0]:
             return self._tti_before
         elif not num_trans or ts > lt[-1]:
+            year = operator.index(dt.year)
+            if not -_INT_MAX - 1 <= year <= _INT_MAX:
+                raise OverflowError("Python int too large to convert to C int")
+            if not 1 <= year <= 9999:
+                raise ValueError(f"year must be in 1..9999, not {year}")
             if isinstance(self._tz_after, _TZStr):
-                return self._tz_after.get_trans_info(ts, dt.year, dt.fold)
+                return self._tz_after.get_trans_info(ts, year, fold)
             else:
                 return self._tz_after
         else:

Modules/_zoneinfo.c

@@ -2250,12 +2250,12 @@ find_ttinfo(zoneinfo_state *state, PyZoneInfo_ZoneInfo *self, PyObject *dt)
 
         long fold_int = PyLong_AsLong(fold_obj);
         Py_DECREF(fold_obj);
-        if (PyErr_Occurred()) {
+        if (fold_int == -1 && PyErr_Occurred()) {
             return NULL;
         }
         if (fold_int < 0 || fold_int > 1) {
             PyErr_Format(PyExc_ValueError,
-                         "fold must be 0 or 1, got %ld", fold_int);
+                         "fold must be 0 or 1, not %ld", fold_int);
             return NULL;
         }
         fold = (unsigned char)fold_int;
@@ -2281,7 +2281,7 @@ find_ttinfo(zoneinfo_state *state, PyZoneInfo_ZoneInfo *self, PyObject *dt)
 
             year = PyLong_AsInt(year_obj);
             Py_DECREF(year_obj);
-            if (PyErr_Occurred()) {
+            if (year == -1 && PyErr_Occurred()) {
                 return NULL;
             }