Add _operator._compare_digest

Author: coolreader18

Cargo.lock

@@ -4,8 +4,7 @@
 """
 
 import warnings as _warnings
-# XXX RustPython TODO: _operator
-#from _operator import _compare_digest as compare_digest
+from _operator import _compare_digest as compare_digest
 import hashlib as _hashlib
 
 trans_5C = bytes((x ^ 0x5C) for x in range(256))

Lib/hmac.py

@@ -0,0 +1,5 @@
+import _operator
+
+assert _operator._compare_digest("abcdef", "abcdef")
+assert not _operator._compare_digest("abcdef", "abc")
+assert not _operator._compare_digest("abc", "abcdef")

tests/snippets/stdlib_operator.py

@@ -22,6 +22,7 @@ sha-1 = "0.8"
 sha2 = "0.8"
 sha3 = "0.8"
 blake2 = "0.8"
+volatile = "0.2"
 
 num-complex = { version = "0.2.2", features = ["serde"] }
 num-bigint = { version = "0.2.4", features = ["serde"] }

vm/Cargo.toml

@@ -1,7 +1,10 @@
 use crate::function::OptionalArg;
+use crate::obj::objbyteinner::PyBytesLike;
+use crate::obj::objstr::PyStringRef;
 use crate::obj::{objiter, objtype};
-use crate::pyobject::{PyObjectRef, PyResult, TypeProtocol};
+use crate::pyobject::{Either, PyObjectRef, PyResult, TypeProtocol};
 use crate::VirtualMachine;
+use volatile::Volatile;
 
 fn operator_length_hint(obj: PyObjectRef, default: OptionalArg, vm: &VirtualMachine) -> PyResult {
     let default = default.unwrap_or_else(|| vm.new_int(0));
@@ -17,8 +20,82 @@ fn operator_length_hint(obj: PyObjectRef, default: OptionalArg, vm: &VirtualMach
     Ok(hint)
 }
 
+#[inline(never)]
+#[cold]
+fn timing_safe_cmp(a: &[u8], b: &[u8]) -> bool {
+    // we use raw pointers here to keep faithful to the C implementation and
+    // to try to avoid any optimizations rustc might do with slices
+    let len_a = a.len();
+    let a = a.as_ptr();
+    let len_b = b.len();
+    let b = b.as_ptr();
+    /* The volatile type declarations make sure that the compiler has no
+     * chance to optimize and fold the code in any way that may change
+     * the timing.
+     */
+    let length: Volatile<usize>;
+    let mut left: Volatile<*const u8>;
+    let mut right: Volatile<*const u8>;
+    let mut result: u8 = 0;
+
+    /* loop count depends on length of b */
+    length = Volatile::new(len_b);
+    left = Volatile::new(std::ptr::null());
+    right = Volatile::new(b);
+
+    /* don't use else here to keep the amount of CPU instructions constant,
+     * volatile forces re-evaluation
+     *  */
+    if len_a == length.read() {
+        left.write(Volatile::new(a).read());
+        result = 0;
+    }
+    if len_a != length.read() {
+        left.write(b);
+        result = 1;
+    }
+
+    for _ in 0..length.read() {
+        let l = left.read();
+        left.write(l.wrapping_add(1));
+        let r = right.read();
+        right.write(r.wrapping_add(1));
+        // safety: the 0..length range will always be either:
+        // * as long as the length of both a and b, if len_a and len_b are equal
+        // * as long as b, and both `left` and `right` are b
+        result |= unsafe { l.read_volatile() ^ r.read_volatile() };
+    }
+
+    result == 0
+}
+
+fn operator_compare_digest(
+    a: Either<PyStringRef, PyBytesLike>,
+    b: Either<PyStringRef, PyBytesLike>,
+    vm: &VirtualMachine,
+) -> PyResult<bool> {
+    let res = match (a, b) {
+        (Either::A(a), Either::A(b)) => {
+            if !a.as_str().is_ascii() || !b.as_str().is_ascii() {
+                return Err(vm.new_type_error(
+                    "comparing strings with non-ASCII characters is not supported".to_string(),
+                ));
+            }
+            timing_safe_cmp(a.as_str().as_bytes(), b.as_str().as_bytes())
+        }
+        (Either::B(a), Either::B(b)) => a.with_ref(|a| b.with_ref(|b| timing_safe_cmp(a, b))),
+        _ => {
+            return Err(vm.new_type_error(
+                "unsupported operand types(s) or combination of types".to_string(),
+            ))
+        }
+    };
+    Ok(res)
+}
+
 pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
     py_module!(vm, "_operator", {
         "length_hint" => vm.ctx.new_function(operator_length_hint),
+        "_compare_digest" => vm.ctx.new_function(operator_compare_digest),
     })
 }