Implementation of bitwise XOR function for bytes object

Author: adamantike

rsa/_compat.py

@@ -105,6 +105,33 @@ def byte(num):
     return pack("B", num)
 
 
+def xor_bytes(b1, b2):
+    """
+    Returns the bitwise XOR result between two bytes objects, b1 ^ b2.
+
+    Bitwise XOR operation is commutative, so order of parameters doesn't
+    generate different results. If parameters have different length, extra
+    length of the largest one is ignored.
+
+    :param b1:
+        First bytes object.
+    :param b2:
+        Second bytes object.
+    :returns:
+        Bytes object, result of XOR operation.
+    """
+
+    try:
+        # Python 2
+        return (
+            ''.join(byte(ord(x) ^ ord(y)) for x, y in zip(b1, b2))
+            or EMPTY_BYTE
+        )
+    except TypeError:
+        # Python 3
+        return bytes([x ^ y for x, y in zip(b1, b2)])
+
+
 def get_word_alignment(num, force_arch=64,
                        _machine_word_size=MACHINE_WORD_SIZE):
     """

tests/test_compat.py

@@ -18,10 +18,12 @@
 import struct
 import sys
 
-from rsa._compat import is_bytes, byte, b
+from rsa._compat import is_bytes, byte, b, xor_bytes, EMPTY_BYTE
 
 
 class TestByte(unittest.TestCase):
+    """Tests for single bytes."""
+
     def test_byte(self):
         for i in range(256):
             byt = byte(i)
@@ -34,3 +36,32 @@ def test_raises_StructError_on_overflow(self):
 
     def test_byte_literal(self):
         self.assertIsInstance(b('abc'), bytes)
+
+
+class TestBytes(unittest.TestCase):
+    """Tests for bytes objects."""
+
+    def test_xor_bytes(self):
+        b1 = b('\xff\xff\xff\xff')
+        b2 = b('\x00\x00\x00\x00')
+        b3 = b('\xf0\xf0\xf0\xf0')
+
+        self.assertEqual(xor_bytes(b1, b2), b('\xff\xff\xff\xff'))
+        self.assertEqual(xor_bytes(b1, b3), b('\x0f\x0f\x0f\x0f'))
+        self.assertEqual(xor_bytes(b2, b3), b('\xf0\xf0\xf0\xf0'))
+        self.assertEqual(xor_bytes(b1, EMPTY_BYTE), EMPTY_BYTE)
+
+    def test_xor_bytes_length(self):
+        b1 = b('\xff\xff')
+        b2 = b('\xf0\xf0\xf0\xf0')
+
+        self.assertEqual(xor_bytes(b1, b2), b('\x0f\x0f'))
+
+    def test_xor_bytes_commutative(self):
+        b1 = b('\xff\xff\xff\xff')
+        b2 = b('\x00\x00\x00\x00')
+        b3 = b('\xf0\xf0\xf0\xf0')
+
+        self.assertEqual(xor_bytes(b1, b2), xor_bytes(b2, b1))
+        self.assertEqual(xor_bytes(b1, b3), xor_bytes(b3, b1))
+        self.assertEqual(xor_bytes(b2, b3), xor_bytes(b3, b2))