@@ -290,6 +290,40 @@ class MyIntWithNew2(MyIntWithNew):
     __new__ = int.__new__
 
 
+# For test_newobj_metaclass_lookup
+metaclass_new_lookups = []
+
+class LookupLoggingMeta(type):
+    def __getattribute__(cls, name):
+        if name == '__new__':
+            metaclass_new_lookups.append(name)
+        return super().__getattribute__(name)
+
+class NewInheriting(metaclass=LookupLoggingMeta):
+    # __new__ is inherited from object, so tp_new is a C slot function.
+    def __init__(self, value=None):
+        self.value = value
+
+class NewDefining(metaclass=LookupLoggingMeta):
+    # __new__ is defined in Python, so tp_new is slot_tp_new, which
+    # performs its own __new__ lookup through the metaclass.
+    def __new__(cls, *args):
+        return super().__new__(cls)
+
+    def __init__(self, value=None):
+        self.value = value
+
+class NewInheritingEx(dict, metaclass=LookupLoggingMeta):
+    # Like NewInheriting, but pickled with NEWOBJ_EX (protocol 4+):
+    # non-empty kwargs force the NEWOBJ_EX opcode, and dict's C tp_new
+    # accepts them while __new__ stays inherited.
+    def __init__(self, value=None):
+        self.value = value
+
+    def __getnewargs_ex__(self):
+        return (), {'ignored': True}
+
+
 # For test_newobj_list_slots
 class SlotList(MyList):
     __slots__ = ["foo"]
 
@@ -3599,6 +3599,21 @@ def test_newobj_overridden_new(self):
                 self.assertEqual(int(y), 1)
                 self.assertEqual(y.foo, 42)
 
+    def test_newobj_metaclass_lookup(self):
+        # gh-105250: NEWOBJ and NEWOBJ_EX look __new__ up on the class,
+        # so a custom metaclass __getattribute__ hook observes the lookup.
+        for cls, min_proto in ((NewInheriting, 2),
+                               (NewDefining, 2),
+                               (NewInheritingEx, 4)):
+            for proto in protocols[min_proto:]:
+                with self.subTest(cls=cls, proto=proto):
+                    s = self.dumps(cls(42), proto)
+                    metaclass_new_lookups.clear()
+                    y = self.loads(s)
+                    self.assertIs(type(y), cls)
+                    self.assertEqual(y.value, 42)
+                    self.assertIn('__new__', metaclass_new_lookups)
+
     def test_newobj_not_class(self):
         # Issue 24552
         if self.py_version < (3, 4):
 
@@ -0,0 +1,5 @@
+Fix a difference in behavior between the C and pure Python implementations of
+:mod:`pickle` when unpickling with the ``NEWOBJ`` and ``NEWOBJ_EX`` opcodes:
+the C implementation now performs an attribute lookup of ``cls.__new__`` when
+the class has a custom metaclass, so that a metaclass ``__getattribute__``
+hook observes the lookup as documented.
@@ -6328,7 +6328,36 @@ load_newobj(PickleState *state, UnpicklerObject *self, int use_kwargs)
         goto error;
     }
 
-    obj = ((PyTypeObject *)cls)->tp_new((PyTypeObject *)cls, args, kwargs);
+    if (Py_TYPE(cls) == &PyType_Type) {
+        /* Fast path: with the default metaclass, an attribute lookup of
+           cls.__new__ is not observable, so tp_new can be called
+           directly. */
+        obj = ((PyTypeObject *)cls)->tp_new((PyTypeObject *)cls, args,
+                                            kwargs);
+    }
+    else {
+        /* Look __new__ up on the class so that a custom metaclass
+           __getattribute__ observes the lookup, as in the Python
+           implementation. */
+        PyObject *func = PyObject_GetAttr(cls, &_Py_ID(__new__));
+        if (func == NULL) {
+            goto error;
+        }
+        Py_ssize_t nargs = PyTuple_GET_SIZE(args);
+        PyObject *newargs = PyTuple_New(nargs + 1);
+        if (newargs == NULL) {
+            Py_DECREF(func);
+            goto error;
+        }
+        PyTuple_SET_ITEM(newargs, 0, Py_NewRef(cls));
+        for (Py_ssize_t i = 0; i < nargs; i++) {
+            PyTuple_SET_ITEM(newargs, i + 1,
+                             Py_NewRef(PyTuple_GET_ITEM(args, i)));
+        }
+        obj = PyObject_Call(func, newargs, kwargs);
+        Py_DECREF(newargs);
+        Py_DECREF(func);
+    }
     if (obj == NULL) {
         goto error;
     }