bytes input for VerifyingKey.from_string()

make the bytearray work on pythohn2.6
make multi-byte array.array objects work on all versions

Author: tomato42

src/ecdsa/_compat.py

@@ -0,0 +1,16 @@
+"""
+Common functions for providing cross-python version compatibility.
+"""
+import sys
+
+
+if sys.version_info < (3, 0):
+    def normalise_bytes(buffer_object):
+        """Cast the input into array of bytes."""
+        return buffer(buffer_object)
+
+
+else:
+    def normalise_bytes(buffer_object):
+        """Cast the input into array of bytes."""
+        return memoryview(buffer_object).cast('B')

src/ecdsa/keys.py

@@ -55,6 +55,15 @@
         Abstract Syntax Notation 1 is a standard description language for
         specifying serialisation and deserialisation of data structures in a
         portable and cross-platform way.
+
+    bytes-like object
+        All the types that implement the buffer protocol. That includes
+        ``str`` (only on python2), ``bytes``, ``bytesarray``, ``array.array`
+        and ``memoryview`` of those objects.
+        Please note that ``array.array` serialisation (converting it to byte
+        string) is endianess dependant! Signature computed over ``array.array``
+        of integers on a big-endian system will not be verified on a
+        little-endian system and vice-versa.
 """
 
 import binascii
@@ -70,6 +79,7 @@
 from .util import string_to_number, number_to_string, randrange
 from .util import sigencode_string, sigdecode_string
 from .util import oid_ecPublicKey, encoded_oid_ecPublicKey, MalformedSignature
+from ._compat import normalise_bytes
 
 
 __all__ = ["BadSignatureError", "BadDigestError", "VerifyingKey", "SigningKey",
@@ -231,8 +241,8 @@ def from_string(cls, string, curve=NIST192p, hashfunc=sha1,
         Python 2 days when there were no binary strings. In Python 3 the
         input needs to be a bytes-like object.
 
-        :param string: :term:`raw encoding` of the public key
-        :type string: bytes-like object
+        :param string: single point encoding of the public key
+        :type string: :term:`bytes-like object`
         :param curve: the curve on which the public key is expected to lie
         :type curve: ecdsa.curves.Curve
         :param hashfunc: The default hash function that will be used for
@@ -245,6 +255,7 @@ def from_string(cls, string, curve=NIST192p, hashfunc=sha1,
         :return: Initialised VerifyingKey object
         :rtype: VerifyingKey
         """
+        string = normalise_bytes(string)
         sig_len = len(string)
         if sig_len == curve.verifying_key_length:
             point = cls._from_raw_encoding(string, curve, validate_point)

src/ecdsa/test_keys.py

@@ -44,14 +44,6 @@ def test_bytes_memoryview(self):
 
         self.assertEqual(self.vk.to_string(), vk.to_string())
 
-    @unittest.skipIf(sys.version_info >= (2, 7), "fails on python2.6 only")
-    @unittest.expectedFailure
-    def test_bytearray26(self):
-        vk = VerifyingKey.from_string(bytearray(self.key_bytes))
-
-        self.assertEqual(self.vk.to_string(), vk.to_string())
-
-    @unittest.skipUnless(sys.version_info >= (2, 7), "fails on python2.6 only")
     def test_bytearray(self):
         vk = VerifyingKey.from_string(bytearray(self.key_bytes))
 
@@ -74,22 +66,12 @@ def test_array_array_of_bytes_memoryview(self):
 
         self.assertEqual(self.vk.to_string(), vk.to_string())
 
-    @unittest.expectedFailure
     def test_array_array_of_ints(self):
         arr = array.array('I', self.key_bytes)
         vk = VerifyingKey.from_string(arr)
 
         self.assertEqual(self.vk.to_string(), vk.to_string())
 
-    @unittest.skipIf(sys.version_info >= (3, 0), "Fails on python3")
-    def test_array_array_of_ints_memoryview2(self):
-        arr = array.array('I', self.key_bytes)
-        vk = VerifyingKey.from_string(buffer(arr))
-
-        self.assertEqual(self.vk.to_string(), vk.to_string())
-
-    @unittest.expectedFailure
-    @unittest.skipUnless(sys.version_info >= (3, 0), "Fails on python3")
     def test_array_array_of_ints_memoryview(self):
         arr = array.array('I', self.key_bytes)
         vk = VerifyingKey.from_string(buffer(arr))