add missing __ne__ methods, fix __eq__ docs

on python3 it works fine but on python2 __ne__ need to be implemented
so that test work as expected

few of the __eq__ methods had incorrect docstrings so fix them by the way

Author: tomato42

src/ecdsa/ecdsa.py

@@ -145,11 +145,20 @@ def __init__(self, generator, point, verify=True):
             raise InvalidPointError("Generator point order is bad.")
 
     def __eq__(self, other):
+        """Return True if the keys are identical, False otherwise.
+
+        Note: for comparison, only placement on the same curve and point
+        equality is considered, use of the same generator point is not
+        considered.
+        """
         if isinstance(other, Public_key):
-            """Return True if the points are identical, False otherwise."""
             return self.curve == other.curve and self.point == other.point
         return NotImplemented
 
+    def __ne__(self, other):
+        """Return False if the keys are identical, True otherwise."""
+        return not self == other
+
     def verifies(self, hash, signature):
         """Verify that signature is a valid signature of hash.
         Return True if the signature is valid.
@@ -188,14 +197,18 @@ def __init__(self, public_key, secret_multiplier):
         self.secret_multiplier = secret_multiplier
 
     def __eq__(self, other):
+        """Return True if the points are identical, False otherwise."""
         if isinstance(other, Private_key):
-            """Return True if the points are identical, False otherwise."""
             return (
                 self.public_key == other.public_key
                 and self.secret_multiplier == other.secret_multiplier
             )
         return NotImplemented
 
+    def __ne__(self, other):
+        """Return False if the points are identical, True otherwise."""
+        return not self == other
+
     def sign(self, hash, random_k):
         """Return a signature for the provided hash, using the provided
         random nonce.  It is absolutely vital that random_k be an unpredictable

src/ecdsa/ellipticcurve.py

@@ -25,13 +25,12 @@
 #   Signature checking (5.4.2):
 #     - Verify that r and s are in [1,n-1].
 #
-# Version of 2008.11.25.
-#
 # Revision history:
 #    2005.12.31 - Initial version.
 #    2008.11.25 - Change CurveFp.is_on to contains_point.
 #
 # Written in 2005 by Peter Pearson and placed in the public domain.
+# Modified extensively as part of python-ecdsa.
 
 from __future__ import division
 
@@ -92,8 +91,14 @@ def __init__(self, p, a, b, h=None):
             self.__h = h
 
     def __eq__(self, other):
+        """Return True if other is an identical curve, False otherwise.
+
+        Note: the value of the cofactor of the curve is not taken into account
+        when comparing curves, as it's derived from the base point and
+        intrinsic curve characteristic (but it's complex to compute),
+        only the prime and curve parameters are considered.
+        """
         if isinstance(other, CurveFp):
-            """Return True if the curves are identical, False otherwise."""
             return (
                 self.__p == other.__p
                 and self.__a == other.__a
@@ -102,7 +107,8 @@ def __eq__(self, other):
         return NotImplemented
 
     def __ne__(self, other):
-        return not (self == other)
+        """Return False if other is an identical curve, True otherwise."""
+        return not self == other
 
     def __hash__(self):
         return hash((self.__p, self.__a, self.__b))
@@ -158,7 +164,7 @@ def __init__(self, curve, x, y, z, order=None, generator=False):
           generator=True
         :param bool generator: the point provided is a curve generator, as
           such, it will be commonly used with scalar multiplication. This will
-          cause to precompute multiplication table for it
+          cause to precompute multiplication table generation for it
         """
         self.__curve = curve
         # since it's generally better (faster) to use scaled points vs unscaled
@@ -224,7 +230,10 @@ def __setstate__(self, state):
         self._update_lock = RWLock()
 
     def __eq__(self, other):
-        """Compare two points with each-other."""
+        """Compare for equality two points with each-other.
+
+        Note: only points that lie on the same curve can be equal.
+        """
         try:
             self._update_lock.reader_acquire()
             if other is INFINITY:
@@ -256,6 +265,10 @@ def __eq__(self, other):
             y1 * zz2 * z2 - y2 * zz1 * z1
         ) % p == 0
 
+    def __ne__(self, other):
+        """Compare for inequality two points with each-other."""
+        return not self == other
+
     def order(self):
         """Return the order of the point.
 
@@ -757,7 +770,10 @@ def __init__(self, curve, x, y, order=None):
             assert self * order == INFINITY
 
     def __eq__(self, other):
-        """Return True if the points are identical, False otherwise."""
+        """Return True if the points are identical, False otherwise.
+
+        Note: only points that lie on the same curve can be equal.
+        """
         if isinstance(other, Point):
             return (
                 self.__curve == other.__curve
@@ -766,6 +782,10 @@ def __eq__(self, other):
             )
         return NotImplemented
 
+    def __ne__(self, other):
+        """Returns False if points are identical, True otherwise."""
+        return not self == other
+
     def __neg__(self):
         return Point(self.__curve, self.__x, self.__curve.p() - self.__y)
 

src/ecdsa/keys.py

@@ -191,6 +191,10 @@ def __eq__(self, other):
             return self.curve == other.curve and self.pubkey == other.pubkey
         return NotImplemented
 
+    def __ne__(self, other):
+        """Return False if the points are identical, True otherwise."""
+        return not self == other
+
     @classmethod
     def from_public_point(
         cls, point, curve=NIST192p, hashfunc=sha1, validate_point=True
@@ -817,6 +821,10 @@ def __eq__(self, other):
             )
         return NotImplemented
 
+    def __ne__(self, other):
+        """Return False if the points are identical, True otherwise."""
+        return not self == other
+
     @classmethod
     def generate(cls, curve=NIST192p, entropy=None, hashfunc=sha1):
         """

src/ecdsa/test_keys.py

@@ -198,20 +198,16 @@ def test_equality_on_verifying_keys(self):
         self.assertEqual(self.vk, self.sk.get_verifying_key())
 
     def test_inequality_on_verifying_keys(self):
-        # use `==` to workaround instrumental <-> unittest compat issue
-        self.assertFalse(self.vk == self.vk2)
+        self.assertNotEqual(self.vk, self.vk2)
 
     def test_inequality_on_verifying_keys_not_implemented(self):
-        # use `==` to workaround instrumental <-> unittest compat issue
-        self.assertFalse(self.vk == None)
+        self.assertNotEqual(self.vk, None)
 
     def test_VerifyingKey_inequality_on_same_curve(self):
-        # use `==` to workaround instrumental <-> unittest compat issue
-        self.assertFalse(self.vk == self.sk2.verifying_key)
+        self.assertNotEqual(self.vk, self.sk2.verifying_key)
 
     def test_SigningKey_inequality_on_same_curve(self):
-        # use `==` to workaround instrumental <-> unittest compat issue
-        self.assertFalse(self.sk == self.sk2)
+        self.assertNotEqual(self.sk, self.sk2)
 
 
 class TestSigningKey(unittest.TestCase):
@@ -283,12 +279,10 @@ def test_verify_with_lazy_precompute(self):
         self.assertTrue(vk.verify(sig, b"other message"))
 
     def test_inequality_on_signing_keys(self):
-        # use `==` to workaround instrumental <-> unittest compat issue
-        self.assertFalse(self.sk1 == self.sk2)
+        self.assertNotEqual(self.sk1, self.sk2)
 
     def test_inequality_on_signing_keys_not_implemented(self):
-        # use `==` to workaround instrumental <-> unittest compat issue
-        self.assertFalse(self.sk1 == None)
+        self.assertNotEqual(self.sk1, None)
 
 
 # test VerifyingKey.verify()