refactor to match PR with rust ports

Author: ngoldbaum

src/cryptography/hazmat/bindings/_rust/__init__.pyi

@@ -6,8 +6,6 @@ import typing
 
 from cryptography.hazmat.primitives import padding
 
-def check_ansix923_padding(data: bytes) -> bool: ...
-
 class PKCS7PaddingContext(padding.PaddingContext):
     def __init__(self, block_size: int) -> None: ...
     def update(self, data: bytes) -> bytes: ...

src/rust/src/lib.rs

@@ -106,8 +106,8 @@ mod _rust {
     use crate::oid::ObjectIdentifier;
     #[pymodule_export]
     use crate::padding::{
-        check_ansix923_padding, ANSIX923PaddingContext, ANSIX923UnpaddingContext,
-        PKCS7PaddingContext, PKCS7UnpaddingContext,
+        ANSIX923PaddingContext, ANSIX923UnpaddingContext, PKCS7PaddingContext,
+        PKCS7UnpaddingContext,
     };
     #[pymodule_export]
     use crate::pkcs12::pkcs12;

src/rust/src/padding.rs

@@ -42,7 +42,6 @@ pub(crate) fn check_pkcs7_padding(data: &[u8]) -> bool {
     (mismatch & 1) == 0
 }
 
-#[pyo3::pyfunction]
 pub(crate) fn check_ansix923_padding(data: &[u8]) -> bool {
     let mut mismatch = 0;
     let pad_size = *data.last().unwrap();

tests/hazmat/primitives/test_padding.py

@@ -3,7 +3,6 @@
 # for complete details.
 
 
-import contextlib
 import sys
 import threading
 
@@ -12,7 +11,13 @@
 from cryptography.exceptions import AlreadyFinalized
 from cryptography.hazmat.primitives import padding
 
-from .utils import IS_FREETHREADED_BUILD, run_threaded
+from .utils import IS_FREETHREADED_BUILD, SwitchIntervalContext, run_threaded
+
+SHOULD_LOCK_BYTESTRING = (
+    IS_FREETHREADED_BUILD or
+    sys.version_info < (3, 10) or
+    sys.implementation.name == "pypy"
+)
 
 
 class TestPKCS7:
@@ -248,20 +253,6 @@ def test_bytearray(self):
         assert final == unpadded + unpadded
 
 
-class SwitchIntervalContext(contextlib.ContextDecorator):
-    def __init__(self, interval):
-        self.interval = interval
-
-    def __enter__(self):
-        self.orig_interval = sys.getswitchinterval()
-        sys.setswitchinterval(self.interval)
-        return self
-
-    def __exit__(self, *exc):
-        sys.setswitchinterval(self.orig_interval)
-        return False
-
-
 @SwitchIntervalContext(0.0000001)
 @pytest.mark.parametrize(
     "algorithm",
@@ -292,8 +283,8 @@ def pad_in_chunks(chunk_size):
         while index < len(data):
             try:
                 new_content = padder.update(data[index : index + chunk_size])
-                if IS_FREETHREADED_BUILD or sys.version_info < (3, 10):
-                    # appending to a bytestring is racey on 3.13t and < 3.10
+                if SHOULD_LOCK_BYTESTRING:
+                    # appending to a bytestring is racey on some Pythons
                     lock.acquire()
                     calculated_pad += new_content
                     lock.release()
@@ -314,7 +305,7 @@ def prepare_args(threadnum):
         assert chunk_size % len(chunk) == 0
         return (chunk_size,)
 
-    run_threaded(num_threads, chunk, pad_in_chunks, prepare_args)
+    run_threaded(num_threads, pad_in_chunks, prepare_args)
 
     calculated_pad += padder.finalize()
     assert expected_pad == calculated_pad
@@ -349,8 +340,8 @@ def unpad_in_chunks():
         while index < num_repeats:
             try:
                 new_content = padder.update(block)
-                if IS_FREETHREADED_BUILD or sys.version_info < (3, 10):
-                    # appending to a bytestring is racey on 3.13t and < 3.10
+                if SHOULD_LOCK_BYTESTRING:
+                    # appending to a bytestring is racey on some Pythons
                     lock.acquire()
                     calculated_unpadded_message += new_content
                     lock.release()
@@ -365,7 +356,7 @@ def unpad_in_chunks():
                 continue
             index += 1
 
-    run_threaded(num_threads, chunk, unpad_in_chunks, lambda x: tuple())
+    run_threaded(num_threads, unpad_in_chunks, lambda x: tuple())
 
     calculated_unpadded_message += padder.finalize()
     assert expected_unpadded_message == calculated_unpadded_message

tests/hazmat/primitives/utils.py

@@ -4,7 +4,10 @@
 
 
 import binascii
+import concurrent.futures
+import contextlib
 import os
+import sys
 import sysconfig
 import threading
 import typing
@@ -225,18 +228,6 @@ def base_hash_test(backend, algorithm, digest_size):
     assert copy.finalize() == m.finalize()
 
 
-def run_threaded(num_threads, chunk, func, prepare_args):
-    threads = []
-    for threadnum in range(num_threads):
-        thread = threading.Thread(target=func, args=prepare_args(threadnum))
-        threads.append(thread)
-
-    for thread in threads:
-        thread.start()
-    for thread in threads:
-        thread.join()
-
-
 def multithreaded_hash_test(backend, algorithm):
     # adapted from test_threaded_hashing in CPython's hashlib tests
     # Updating the same hash object from several threads at once
@@ -642,3 +633,27 @@ def skip_fips_traditional_openssl(backend, fmt):
         pytest.skip(
             "Traditional OpenSSL key format is not supported in FIPS mode."
         )
+
+
+class SwitchIntervalContext(contextlib.ContextDecorator):
+    """Context manager to track thread switch interval state"""
+
+    def __init__(self, interval):
+        self.interval = interval
+
+    def __enter__(self):
+        self.orig_interval = sys.getswitchinterval()
+        sys.setswitchinterval(self.interval)
+        return self
+
+    def __exit__(self, *exc):
+        sys.setswitchinterval(self.orig_interval)
+        return False
+
+
+def run_threaded(num_threads, func, prepare_args):
+    with concurrent.futures.ThreadPoolExecutor(max_workers=num_threads) as e:
+        futures = [
+            e.submit(func, *prepare_args(t)) for t in range(num_threads)
+        ]
+        [f.result() for f in futures]