v0.1.7

author: Determinant <[email protected]> 2022-11-17 18:08:59 -0800
committer: Determinant <[email protected]> 2022-11-17 18:08:59 -0800
commit: 8154806fe2fccacdc3dafaa68181a07bcf8d6c4c (patch)
tree: f477e6a005599bb88c18db142c267b9297c6060b /frozen_deps/ecdsa
parent: be4dc086591c9bced04a507d127c83811c5700c4 (diff)
28 files changed, 5588 insertions, 744 deletions
diff --git a/frozen_deps/ecdsa/__init__.py b/frozen_deps/ecdsa/__init__.py
index 4ae0a11..ce8749a 100644
--- a/frozen_deps/ecdsa/__init__.py
+++ b/frozen_deps/ecdsa/__init__.py
@@ -1,3 +1,6 @@
+# while we don't use six in this file, we did bundle it for a long time, so
+# keep as part of module in a virtual way (through __all__)
+import six
 from .keys import (
 SigningKey,
 VerifyingKey,
@@ -19,6 +22,12 @@ from .curves import (
 BRAINPOOLP320r1,
 BRAINPOOLP384r1,
 BRAINPOOLP512r1,
+ SECP112r1,
+ SECP112r2,
+ SECP128r1,
+ SECP160r1,
+ Ed25519,
+ Ed448,
 )
 from .ecdh import (
 ECDH,
@@ -28,13 +37,9 @@ from .ecdh import (
 InvalidSharedSecretError,
 )
 from .der import UnexpectedDER
+from . import _version
 
-# This code comes from http://github.com/warner/python-ecdsa
-from ._version import get_versions
-
-__version__ = get_versions()["version"]
-del get_versions
-
+# This code comes from http://github.com/tlsfuzzer/python-ecdsa
 __all__ = [
 "curves",
 "der",
@@ -72,5 +77,14 @@ _hush_pyflakes = [
 BRAINPOOLP320r1,
 BRAINPOOLP384r1,
 BRAINPOOLP512r1,
+ SECP112r1,
+ SECP112r2,
+ SECP128r1,
+ SECP160r1,
+ Ed25519,
+ Ed448,
+ six.b(""),
 ]
 del _hush_pyflakes
+
+__version__ = _version.get_versions()["version"]
diff --git a/frozen_deps/ecdsa/_compat.py b/frozen_deps/ecdsa/_compat.py
index 720360b..83d41a5 100644
--- a/frozen_deps/ecdsa/_compat.py
+++ b/frozen_deps/ecdsa/_compat.py
@@ -3,6 +3,7 @@ Common functions for providing cross-python version compatibility.
 """
 import sys
 import re
+import binascii
 from six import integer_types
 
 
@@ -14,7 +15,8 @@ def str_idx_as_int(string, index):
 return ord(val)
 
 
-if sys.version_info < (3, 0):
+if sys.version_info < (3, 0): # pragma: no branch
+ import platform
 
 def normalise_bytes(buffer_object):
 """Cast the input into array of bytes."""
@@ -24,37 +26,128 @@ if sys.version_info < (3, 0):
 def hmac_compat(ret):
 return ret
 
- if sys.version_info < (2, 7) or sys.version_info < (2, 7, 4):
+ if (
+ sys.version_info < (2, 7)
+ or sys.version_info < (2, 7, 4)
+ or platform.system() == "Java"
+ ): # pragma: no branch
 
 def remove_whitespace(text):
 """Removes all whitespace from passed in string"""
 return re.sub(r"\s+", "", text)
 
+ def compat26_str(val):
+ return str(val)
+
+ def bit_length(val):
+ if val == 0:
+ return 0
+ return len(bin(val)) - 2
+
 else:
 
 def remove_whitespace(text):
 """Removes all whitespace from passed in string"""
 return re.sub(r"\s+", "", text, flags=re.UNICODE)
 
+ def compat26_str(val):
+ return val
+
+ def bit_length(val):
+ """Return number of bits necessary to represent an integer."""
+ return val.bit_length()
+
+ def b2a_hex(val):
+ return binascii.b2a_hex(compat26_str(val))
+
+ def a2b_hex(val):
+ try:
+ return bytearray(binascii.a2b_hex(val))
+ except Exception as e:
+ raise ValueError("base16 error: %s" % e)
+
+ def bytes_to_int(val, byteorder):
+ """Convert bytes to an int."""
+ if not val:
+ return 0
+ if byteorder == "big":
+ return int(b2a_hex(val), 16)
+ if byteorder == "little":
+ return int(b2a_hex(val[::-1]), 16)
+ raise ValueError("Only 'big' and 'little' endian supported")
+
+ def int_to_bytes(val, length=None, byteorder="big"):
+ """Return number converted to bytes"""
+ if length is None:
+ length = byte_length(val)
+ if byteorder == "big":
+ return bytearray(
+ (val >> i) & 0xFF for i in reversed(range(0, length * 8, 8))
+ )
+ if byteorder == "little":
+ return bytearray(
+ (val >> i) & 0xFF for i in range(0, length * 8, 8)
+ )
+ raise ValueError("Only 'big' or 'little' endian supported")
 
 else:
- if sys.version_info < (3, 4):
+ if sys.version_info < (3, 4): # pragma: no branch
 # on python 3.3 hmac.hmac.update() accepts only bytes, on newer
 # versions it does accept memoryview() also
 def hmac_compat(data):
- if not isinstance(data, bytes):
+ if not isinstance(data, bytes): # pragma: no branch
 return bytes(data)
 return data
 
+ def normalise_bytes(buffer_object):
+ """Cast the input into array of bytes."""
+ if not buffer_object:
+ return b""
+ return memoryview(buffer_object).cast("B")
+
 else:
 
 def hmac_compat(data):
 return data
 
- def normalise_bytes(buffer_object):
- """Cast the input into array of bytes."""
- return memoryview(buffer_object).cast("B")
+ def normalise_bytes(buffer_object):
+ """Cast the input into array of bytes."""
+ return memoryview(buffer_object).cast("B")
+
+ def compat26_str(val):
+ return val
 
 def remove_whitespace(text):
 """Removes all whitespace from passed in string"""
 return re.sub(r"\s+", "", text, flags=re.UNICODE)
+
+ def a2b_hex(val):
+ try:
+ return bytearray(binascii.a2b_hex(bytearray(val, "ascii")))
+ except Exception as e:
+ raise ValueError("base16 error: %s" % e)
+
+ # pylint: disable=invalid-name
+ # pylint is stupid here and doesn't notice it's a function, not
+ # constant
+ bytes_to_int = int.from_bytes
+ # pylint: enable=invalid-name
+
+ def bit_length(val):
+ """Return number of bits necessary to represent an integer."""
+ return val.bit_length()
+
+ def int_to_bytes(val, length=None, byteorder="big"):
+ """Convert integer to bytes."""
+ if length is None:
+ length = byte_length(val)
+ # for gmpy we need to convert back to native int
+ if type(val) != int:
+ val = int(val)
+ return bytearray(val.to_bytes(length=length, byteorder=byteorder))
+
+
+def byte_length(val):
+ """Return number of bytes necessary to represent an integer."""
+ length = bit_length(val)
+ return (length + 7) // 8
diff --git a/frozen_deps/ecdsa/_sha3.py b/frozen_deps/ecdsa/_sha3.py
new file mode 100644
index 0000000..2db0058
--- /dev/null
+++ b/frozen_deps/ecdsa/_sha3.py
@@ -0,0 +1,181 @@
+"""
+Implementation of the SHAKE-256 algorithm for Ed448
+"""
+
+try:
+ import hashlib
+
+ hashlib.new("shake256").digest(64)
+
+ def shake_256(msg, outlen):
+ return hashlib.new("shake256", msg).digest(outlen)
+
+except (TypeError, ValueError):
+
+ from ._compat import bytes_to_int, int_to_bytes
+
+ # From little endian.
+ def _from_le(s):
+ return bytes_to_int(s, byteorder="little")
+
+ # Rotate a word x by b places to the left.
+ def _rol(x, b):
+ return ((x << b) | (x >> (64 - b))) & (2**64 - 1)
+
+ # Do the SHA-3 state transform on state s.
+ def _sha3_transform(s):
+ ROTATIONS = [
+ 0,
+ 1,
+ 62,
+ 28,
+ 27,
+ 36,
+ 44,
+ 6,
+ 55,
+ 20,
+ 3,
+ 10,
+ 43,
+ 25,
+ 39,
+ 41,
+ 45,
+ 15,
+ 21,
+ 8,
+ 18,
+ 2,
+ 61,
+ 56,
+ 14,
+ ]
+ PERMUTATION = [
+ 1,
+ 6,
+ 9,
+ 22,
+ 14,
+ 20,
+ 2,
+ 12,
+ 13,
+ 19,
+ 23,
+ 15,
+ 4,
+ 24,
+ 21,
+ 8,
+ 16,
+ 5,
+ 3,
+ 18,
+ 17,
+ 11,
+ 7,
+ 10,
+ ]
+ RC = [
+ 0x0000000000000001,
+ 0x0000000000008082,
+ 0x800000000000808A,
+ 0x8000000080008000,
+ 0x000000000000808B,
+ 0x0000000080000001,
+ 0x8000000080008081,
+ 0x8000000000008009,
+ 0x000000000000008A,
+ 0x0000000000000088,
+ 0x0000000080008009,
+ 0x000000008000000A,
+ 0x000000008000808B,
+ 0x800000000000008B,
+ 0x8000000000008089,
+ 0x8000000000008003,
+ 0x8000000000008002,
+ 0x8000000000000080,
+ 0x000000000000800A,
+ 0x800000008000000A,
+ 0x8000000080008081,
+ 0x8000000000008080,
+ 0x0000000080000001,
+ 0x8000000080008008,
+ ]
+
+ for rnd in range(0, 24):
+ # AddColumnParity (Theta)
+ c = [0] * 5
+ d = [0] * 5
+ for i in range(0, 25):
+ c[i % 5] ^= s[i]
+ for i in range(0, 5):
+ d[i] = c[(i + 4) % 5] ^ _rol(c[(i + 1) % 5], 1)
+ for i in range(0, 25):
+ s[i] ^= d[i % 5]
+ # RotateWords (Rho)
+ for i in range(0, 25):
+ s[i] = _rol(s[i], ROTATIONS[i])
+ # PermuteWords (Pi)
+ t = s[PERMUTATION[0]]
+ for i in range(0, len(PERMUTATION) - 1):
+ s[PERMUTATION[i]] = s[PERMUTATION[i + 1]]
+ s[PERMUTATION[-1]] = t
+ # NonlinearMixRows (Chi)
+ for i in range(0, 25, 5):
+ t = [
+ s[i],
+ s[i + 1],
+ s[i + 2],
+ s[i + 3],
+ s[i + 4],
+ s[i],
+ s[i + 1],
+ ]
+ for j in range(0, 5):
+ s[i + j] = t[j] ^ ((~t[j + 1]) & (t[j + 2]))
+ # AddRoundConstant (Iota)
+ s[0] ^= RC[rnd]
+
+ # Reinterpret octet array b to word array and XOR it to state s.
+ def _reinterpret_to_words_and_xor(s, b):
+ for j in range(0, len(b) // 8):
+ s[j] ^= _from_le(b[8 * j : 8 * j + 8])
+
+ # Reinterpret word array w to octet array and return it.
+ def _reinterpret_to_octets(w):
+ mp = bytearray()
+ for j in range(0, len(w)):
+ mp += int_to_bytes(w[j], 8, byteorder="little")
+ return mp
+
+ def _sha3_raw(msg, r_w, o_p, e_b):
+ """Semi-generic SHA-3 implementation"""
+ r_b = 8 * r_w
+ s = [0] * 25
+ # Handle whole blocks.
+ idx = 0
+ blocks = len(msg) // r_b
+ for i in range(0, blocks):
+ _reinterpret_to_words_and_xor(s, msg[idx : idx + r_b])
+ idx += r_b
+ _sha3_transform(s)
+ # Handle last block padding.
+ m = bytearray(msg[idx:])
+ m.append(o_p)
+ while len(m) < r_b:
+ m.append(0)
+ m[len(m) - 1] |= 128
+ # Handle padded last block.
+ _reinterpret_to_words_and_xor(s, m)
+ _sha3_transform(s)
+ # Output.
+ out = bytearray()
+ while len(out) < e_b:
+ out += _reinterpret_to_octets(s[:r_w])
+ _sha3_transform(s)
+ return out[:e_b]
+
+ def shake_256(msg, outlen):
+ return _sha3_raw(msg, 17, 31, outlen)
diff --git a/frozen_deps/ecdsa/_version.py b/frozen_deps/ecdsa/_version.py
index 9a3e5fa..96aae17 100644
--- a/frozen_deps/ecdsa/_version.py
+++ b/frozen_deps/ecdsa/_version.py
@@ -1,5 +1,5 @@
 
-# This file was generated by 'versioneer.py' (0.17) from
+# This file was generated by 'versioneer.py' (0.21) from
 # revision-control system data, or from the parent directory name of an
 # unpacked source archive. Distribution tarballs contain a pre-generated copy
 # of this file.
@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2020-11-12T20:12:49+0100",
+ "date": "2022-07-09T14:49:17+0200",
 "dirty": false,
 "error": null,
- "full-revisionid": "9d5a727c766773b8367f6dd0a49bbda21c18dbe7",
- "version": "0.16.1"
+ "full-revisionid": "341e0d8be9fedf66fbc9a95630b4ed2138343380",
+ "version": "0.18.0"
 }
 ''' # END VERSION_JSON
 
diff --git a/frozen_deps/ecdsa/curves.py b/frozen_deps/ecdsa/curves.py
index 9a10380..1119ee5 100644
--- a/frozen_deps/ecdsa/curves.py
+++ b/frozen_deps/ecdsa/curves.py
@@ -1,7 +1,9 @@
 from __future__ import division
 
-from . import der, ecdsa
-from .util import orderlen
+from six import PY2
+from . import der, ecdsa, ellipticcurve, eddsa
+from .util import orderlen, number_to_string, string_to_number
+from ._compat import normalise_bytes, bit_length
 
 
 # orderlen was defined in this module previously, so keep it in __all__,
@@ -10,6 +12,10 @@ __all__ = [
 "UnknownCurveError",
 "orderlen",
 "Curve",
+ "SECP112r1",
+ "SECP112r2",
+ "SECP128r1",
+ "SECP160r1",
 "NIST192p",
 "NIST224p",
 "NIST256p",
@@ -17,6 +23,7 @@ __all__ = [
 "NIST521p",
 "curves",
 "find_curve",
+ "curve_by_name",
 "SECP256k1",
 "BRAINPOOLP160r1",
 "BRAINPOOLP192r1",
@@ -25,9 +32,17 @@ __all__ = [
 "BRAINPOOLP320r1",
 "BRAINPOOLP384r1",
 "BRAINPOOLP512r1",
+ "PRIME_FIELD_OID",
+ "CHARACTERISTIC_TWO_FIELD_OID",
+ "Ed25519",
+ "Ed448",
 ]
 
 
+PRIME_FIELD_OID = (1, 2, 840, 10045, 1, 1)
+CHARACTERISTIC_TWO_FIELD_OID = (1, 2, 840, 10045, 1, 2)
+
+
 class UnknownCurveError(Exception):
 pass
 
@@ -39,15 +54,262 @@ class Curve:
 self.curve = curve
 self.generator = generator
 self.order = generator.order()
- self.baselen = orderlen(self.order)
- self.verifying_key_length = 2 * self.baselen
+ if isinstance(curve, ellipticcurve.CurveEdTw):
+ # EdDSA keys are special in that both private and public
+ # are the same size (as it's defined only with compressed points)
+
+ # +1 for the sign bit and then round up
+ self.baselen = (bit_length(curve.p()) + 1 + 7) // 8
+ self.verifying_key_length = self.baselen
+ else:
+ self.baselen = orderlen(self.order)
+ self.verifying_key_length = 2 * orderlen(curve.p())
 self.signature_length = 2 * self.baselen
 self.oid = oid
- self.encoded_oid = der.encode_oid(*oid)
+ if oid:
+ self.encoded_oid = der.encode_oid(*oid)
+
+ def __eq__(self, other):
+ if isinstance(other, Curve):
+ return (
+ self.curve == other.curve and self.generator == other.generator
+ )
+ return NotImplemented
+
+ def __ne__(self, other):
+ return not self == other
 
 def __repr__(self):
 return self.name
 
+ def to_der(self, encoding=None, point_encoding="uncompressed"):
+ """Serialise the curve parameters to binary string.
+
+ :param str encoding: the format to save the curve parameters in.
+ Default is ``named_curve``, with fallback being the ``explicit``
+ if the OID is not set for the curve.
+ :param str point_encoding: the point encoding of the generator when
+ explicit curve encoding is used. Ignored for ``named_curve``
+ format.
+
+ :return: DER encoded ECParameters structure
+ :rtype: bytes
+ """
+ if encoding is None:
+ if self.oid:
+ encoding = "named_curve"
+ else:
+ encoding = "explicit"
+
+ if encoding not in ("named_curve", "explicit"):
+ raise ValueError(
+ "Only 'named_curve' and 'explicit' encodings supported"
+ )
+
+ if encoding == "named_curve":
+ if not self.oid:
+ raise UnknownCurveError(
+ "Can't encode curve using named_curve encoding without "
+ "associated curve OID"
+ )
+ return der.encode_oid(*self.oid)
+ elif isinstance(self.curve, ellipticcurve.CurveEdTw):
+ assert encoding == "explicit"
+ raise UnknownCurveError(
+ "Twisted Edwards curves don't support explicit encoding"
+ )
+
+ # encode the ECParameters sequence
+ curve_p = self.curve.p()
+ version = der.encode_integer(1)
+ field_id = der.encode_sequence(
+ der.encode_oid(*PRIME_FIELD_OID), der.encode_integer(curve_p)
+ )
+ curve = der.encode_sequence(
+ der.encode_octet_string(
+ number_to_string(self.curve.a() % curve_p, curve_p)
+ ),
+ der.encode_octet_string(
+ number_to_string(self.curve.b() % curve_p, curve_p)
+ ),
+ )
+ base = der.encode_octet_string(self.generator.to_bytes(point_encoding))
+ order = der.encode_integer(self.generator.order())
+ seq_elements = [version, field_id, curve, base, order]
+ if self.curve.cofactor():
+ cofactor = der.encode_integer(self.curve.cofactor())
+ seq_elements.append(cofactor)
+
+ return der.encode_sequence(*seq_elements)
+
+ def to_pem(self, encoding=None, point_encoding="uncompressed"):
+ """
+ Serialise the curve parameters to the :term:`PEM` format.
+
+ :param str encoding: the format to save the curve parameters in.
+ Default is ``named_curve``, with fallback being the ``explicit``
+ if the OID is not set for the curve.
+ :param str point_encoding: the point encoding of the generator when
+ explicit curve encoding is used. Ignored for ``named_curve``
+ format.
+
+ :return: PEM encoded ECParameters structure
+ :rtype: str
+ """
+ return der.topem(
+ self.to_der(encoding, point_encoding), "EC PARAMETERS"
+ )
+
+ @staticmethod
+ def from_der(data, valid_encodings=None):
+ """Decode the curve parameters from DER file.
+
+ :param data: the binary string to decode the parameters from
+ :type data: :term:`bytes-like object`
+ :param valid_encodings: set of names of allowed encodings, by default
+ all (set by passing ``None``), supported ones are ``named_curve``
+ and ``explicit``
+ :type valid_encodings: :term:`set-like object`
+ """
+ if not valid_encodings:
+ valid_encodings = set(("named_curve", "explicit"))
+ if not all(i in ["named_curve", "explicit"] for i in valid_encodings):
+ raise ValueError(
+ "Only named_curve and explicit encodings supported"
+ )
+ data = normalise_bytes(data)
+ if not der.is_sequence(data):
+ if "named_curve" not in valid_encodings:
+ raise der.UnexpectedDER(
+ "named_curve curve parameters not allowed"
+ )
+ oid, empty = der.remove_object(data)
+ if empty:
+ raise der.UnexpectedDER("Unexpected data after OID")
+ return find_curve(oid)
+
+ if "explicit" not in valid_encodings:
+ raise der.UnexpectedDER("explicit curve parameters not allowed")
+
+ seq, empty = der.remove_sequence(data)
+ if empty:
+ raise der.UnexpectedDER(
+ "Unexpected data after ECParameters structure"
+ )
+ # decode the ECParameters sequence
+ version, rest = der.remove_integer(seq)
+ if version != 1:
+ raise der.UnexpectedDER("Unknown parameter encoding format")
+ field_id, rest = der.remove_sequence(rest)
+ curve, rest = der.remove_sequence(rest)
+ base_bytes, rest = der.remove_octet_string(rest)
+ order, rest = der.remove_integer(rest)
+ cofactor = None
+ if rest:
+ # the ASN.1 specification of ECParameters allows for future
+ # extensions of the sequence, so ignore the remaining bytes
+ cofactor, _ = der.remove_integer(rest)
+
+ # decode the ECParameters.fieldID sequence
+ field_type, rest = der.remove_object(field_id)
+ if field_type == CHARACTERISTIC_TWO_FIELD_OID:
+ raise UnknownCurveError("Characteristic 2 curves unsupported")
+ if field_type != PRIME_FIELD_OID:
+ raise UnknownCurveError(
+ "Unknown field type: {0}".format(field_type)
+ )
+ prime, empty = der.remove_integer(rest)
+ if empty:
+ raise der.UnexpectedDER(
+ "Unexpected data after ECParameters.fieldID.Prime-p element"
+ )
+
+ # decode the ECParameters.curve sequence
+ curve_a_bytes, rest = der.remove_octet_string(curve)
+ curve_b_bytes, rest = der.remove_octet_string(rest)
+ # seed can be defined here, but we don't parse it, so ignore `rest`
+
+ curve_a = string_to_number(curve_a_bytes)
+ curve_b = string_to_number(curve_b_bytes)
+
+ curve_fp = ellipticcurve.CurveFp(prime, curve_a, curve_b, cofactor)
+
+ # decode the ECParameters.base point
+
+ base = ellipticcurve.PointJacobi.from_bytes(
+ curve_fp,
+ base_bytes,
+ valid_encodings=("uncompressed", "compressed", "hybrid"),
+ order=order,
+ generator=True,
+ )
+ tmp_curve = Curve("unknown", curve_fp, base, None)
+
+ # if the curve matches one of the well-known ones, use the well-known
+ # one in preference, as it will have the OID and name associated
+ for i in curves:
+ if tmp_curve == i:
+ return i
+ return tmp_curve
+
+ @classmethod
+ def from_pem(cls, string, valid_encodings=None):
+ """Decode the curve parameters from PEM file.
+
+ :param str string: the text string to decode the parameters from
+ :param valid_encodings: set of names of allowed encodings, by default
+ all (set by passing ``None``), supported ones are ``named_curve``
+ and ``explicit``
+ :type valid_encodings: :term:`set-like object`
+ """
+ if not PY2 and isinstance(string, str): # pragma: no branch
+ string = string.encode()
+
+ ec_param_index = string.find(b"-----BEGIN EC PARAMETERS-----")
+ if ec_param_index == -1:
+ raise der.UnexpectedDER("EC PARAMETERS PEM header not found")
+
+ return cls.from_der(
+ der.unpem(string[ec_param_index:]), valid_encodings
+ )
+
+
+# the SEC curves
+SECP112r1 = Curve(
+ "SECP112r1",
+ ecdsa.curve_112r1,
+ ecdsa.generator_112r1,
+ (1, 3, 132, 0, 6),
+ "secp112r1",
+)
+
+
+SECP112r2 = Curve(
+ "SECP112r2",
+ ecdsa.curve_112r2,
+ ecdsa.generator_112r2,
+ (1, 3, 132, 0, 7),
+ "secp112r2",
+)
+
+
+SECP128r1 = Curve(
+ "SECP128r1",
+ ecdsa.curve_128r1,
+ ecdsa.generator_128r1,
+ (1, 3, 132, 0, 28),
+ "secp128r1",
+)
+
+
+SECP160r1 = Curve(
+ "SECP160r1",
+ ecdsa.curve_160r1,
+ ecdsa.generator_160r1,
+ (1, 3, 132, 0, 8),
+ "secp160r1",
+)
+
 
 # the NIST curves
 NIST192p = Curve(
@@ -167,6 +429,23 @@ BRAINPOOLP512r1 = Curve(
 )
 
 
+Ed25519 = Curve(
+ "Ed25519",
+ eddsa.curve_ed25519,
+ eddsa.generator_ed25519,
+ (1, 3, 101, 112),
+)
+
+
+Ed448 = Curve(
+ "Ed448",
+ eddsa.curve_ed448,
+ eddsa.generator_ed448,
+ (1, 3, 101, 113),
+)
+
+
+# no order in particular, but keep previously added curves first
 curves = [
 NIST192p,
 NIST224p,
@@ -181,10 +460,26 @@ curves = [
 BRAINPOOLP320r1,
 BRAINPOOLP384r1,
 BRAINPOOLP512r1,
+ SECP112r1,
+ SECP112r2,
+ SECP128r1,
+ SECP160r1,
+ Ed25519,
+ Ed448,
 ]
 
 
 def find_curve(oid_curve):
+ """Select a curve based on its OID
+
+ :param tuple[int,...] oid_curve: ASN.1 Object Identifier of the
+ curve to return, like ``(1, 2, 840, 10045, 3, 1, 7)`` for ``NIST256p``.
+
+ :raises UnknownCurveError: When the oid doesn't match any of the supported
+ curves
+
+ :rtype: ~ecdsa.curves.Curve
+ """
 for c in curves:
 if c.oid == oid_curve:
 return c
@@ -192,3 +487,27 @@ def find_curve(oid_curve):
 "I don't know about the curve with oid %s."
 "I only know about these: %s" % (oid_curve, [c.name for c in curves])
 )
+
+
+def curve_by_name(name):
+ """Select a curve based on its name.
+
+ Returns a :py:class:`~ecdsa.curves.Curve` object with a ``name`` name.
+ Note that ``name`` is case-sensitve.
+
+ :param str name: Name of the curve to return, like ``NIST256p`` or
+ ``prime256v1``
+
+ :raises UnknownCurveError: When the name doesn't match any of the supported
+ curves
+
+ :rtype: ~ecdsa.curves.Curve
+ """
+ for c in curves:
+ if name == c.name or (c.openssl_name and name == c.openssl_name):
+ return c
+ raise UnknownCurveError(
+ "Curve with name {0!r} unknown, only curves supported: {1}".format(
+ name, [c.name for c in curves]
+ )
+ )
diff --git a/frozen_deps/ecdsa/der.py b/frozen_deps/ecdsa/der.py
index 8c1de9b..8b27941 100644
--- a/frozen_deps/ecdsa/der.py
+++ b/frozen_deps/ecdsa/der.py
@@ -87,7 +87,7 @@ def encode_bitstring(s, unused=_sentry):
 if not s:
 raise ValueError("unused is non-zero but s is empty")
 last = str_idx_as_int(s, -1)
- if last & (2 ** unused - 1):
+ if last & (2**unused - 1):
 raise ValueError("unused bits must be zeros in DER")
 encoded_unused = int2byte(unused)
 len_extra = 1
@@ -348,7 +348,7 @@ def remove_bitstring(string, expect_unused=_sentry):
 raise UnexpectedDER("Invalid encoding of empty bit string")
 last = str_idx_as_int(body, -1)
 # verify that all the unused bits are set to zero (DER requirement)
- if last & (2 ** unused - 1):
+ if last & (2**unused - 1):
 raise UnexpectedDER("Non zero padding bits in bit string")
 if expect_unused is None:
 body = (body, unused)
@@ -386,7 +386,7 @@ def remove_bitstring(string, expect_unused=_sentry):
 
 
 def unpem(pem):
- if isinstance(pem, text_type):
+ if isinstance(pem, text_type): # pragma: no branch
 pem = pem.encode()
 
 d = b("").join(
diff --git a/frozen_deps/ecdsa/ecdh.py b/frozen_deps/ecdsa/ecdh.py
index 9173279..7f697d9 100644
--- a/frozen_deps/ecdsa/ecdh.py
+++ b/frozen_deps/ecdsa/ecdh.py
@@ -116,7 +116,7 @@ class ECDH(object):
 :raises NoCurveError: Curve must be set before key generation.
 
 :return: public (verifying) key from this private key.
- :rtype: VerifyingKey object
+ :rtype: VerifyingKey
 """
 if not self.curve:
 raise NoCurveError("Curve must be set prior to key generation.")
@@ -135,7 +135,7 @@ class ECDH(object):
 :raises InvalidCurveError: private_key curve not the same as self.curve
 
 :return: public (verifying) key from this private key.
- :rtype: VerifyingKey object
+ :rtype: VerifyingKey
 """
 if not self.curve:
 self.curve = private_key.curve
@@ -158,7 +158,7 @@ class ECDH(object):
 :raises NoCurveError: Curve must be set before loading.
 
 :return: public (verifying) key from this private key.
- :rtype: VerifyingKey object
+ :rtype: VerifyingKey
 """
 if not self.curve:
 raise NoCurveError("Curve must be set prior to key load.")
@@ -183,7 +183,7 @@ class ECDH(object):
 :raises InvalidCurveError: private_key curve not the same as self.curve
 
 :return: public (verifying) key from this private key.
- :rtype: VerifyingKey object
+ :rtype: VerifyingKey
 """
 return self.load_private_key(SigningKey.from_der(private_key_der))
 
@@ -204,7 +204,7 @@ class ECDH(object):
 :raises InvalidCurveError: private_key curve not the same as self.curve
 
 :return: public (verifying) key from this private key.
- :rtype: VerifyingKey object
+ :rtype: VerifyingKey
 """
 return self.load_private_key(SigningKey.from_pem(private_key_pem))
 
@@ -215,8 +215,8 @@ class ECDH(object):
 Needs to be sent to the remote party.
 
 :return: public (verifying) key from local private key.
- :rtype: VerifyingKey object
- """
+ :rtype: VerifyingKey
+ """
 return self.private_key.get_verifying_key()
 
 def load_received_public_key(self, public_key):
@@ -237,7 +237,9 @@ class ECDH(object):
 raise InvalidCurveError("Curve mismatch.")
 self.public_key = public_key
 
- def load_received_public_key_bytes(self, public_key_str):
+ def load_received_public_key_bytes(
+ self, public_key_str, valid_encodings=None
+ ):
 """
 Load public key from byte string.
 
@@ -247,9 +249,16 @@ class ECDH(object):
 
 :param public_key_str: public key in bytes string format
 :type public_key_str: :term:`bytes-like object`
+ :param valid_encodings: list of acceptable point encoding formats,
+ supported ones are: :term:`uncompressed`, :term:`compressed`,
+ :term:`hybrid`, and :term:`raw encoding` (specified with ``raw``
+ name). All formats by default (specified with ``None``).
+ :type valid_encodings: :term:`set-like object`
 """
 return self.load_received_public_key(
- VerifyingKey.from_string(public_key_str, self.curve)
+ VerifyingKey.from_string(
+ public_key_str, self.curve, valid_encodings
+ )
 )
 
 def load_received_public_key_der(self, public_key_der):
@@ -301,10 +310,10 @@ class ECDH(object):
 :raises NoKeyError: public_key or private_key is not set
 
 :return: shared secret
- :rtype: byte string
+ :rtype: bytes
 """
 return number_to_string(
- self.generate_sharedsecret(), self.private_key.curve.order
+ self.generate_sharedsecret(), self.private_key.curve.curve.p()
 )
 
 def generate_sharedsecret(self):
@@ -314,9 +323,9 @@ class ECDH(object):
 The objects needs to have both private key and received public key
 before generation is allowed.
 
- It's the same for local and remote party.
- shared secret(local private key, remote public key ) ==
- shared secret (local public key, remote private key)
+ It's the same for local and remote party,
+ shared secret(local private key, remote public key) ==
+ shared secret(local public key, remote private key)
 
 :raises InvalidCurveError: public_key curve not the same as self.curve
 :raises NoKeyError: public_key or private_key is not set
diff --git a/frozen_deps/ecdsa/ecdsa.py b/frozen_deps/ecdsa/ecdsa.py
index d785a45..3328281 100644
--- a/frozen_deps/ecdsa/ecdsa.py
+++ b/frozen_deps/ecdsa/ecdsa.py
@@ -1,56 +1,67 @@
 #! /usr/bin/env python
 
 """
-Implementation of Elliptic-Curve Digital Signatures.
+Low level implementation of Elliptic-Curve Digital Signatures.
+
+.. note ::
+ You're most likely looking for the :py:class:`~ecdsa.keys` module.
+ This is a low-level implementation of the ECDSA that operates on
+ integers, not byte strings.
+
+NOTE: This a low level implementation of ECDSA, for normal applications
+you should be looking at the keys.py module.
 
 Classes and methods for elliptic-curve signatures:
 private keys, public keys, signatures,
-NIST prime-modulus curves with modulus lengths of
-192, 224, 256, 384, and 521 bits.
+and definitions of prime-modulus curves.
 
 Example:
 
- # (In real-life applications, you would probably want to
- # protect against defects in SystemRandom.)
- from random import SystemRandom
- randrange = SystemRandom().randrange
+.. code-block:: python
 
- # Generate a public/private key pair using the NIST Curve P-192:
+ # (In real-life applications, you would probably want to
+ # protect against defects in SystemRandom.)
+ from random import SystemRandom
+ randrange = SystemRandom().randrange
 
- g = generator_192
- n = g.order()
- secret = randrange( 1, n )
- pubkey = Public_key( g, g * secret )
- privkey = Private_key( pubkey, secret )
+ # Generate a public/private key pair using the NIST Curve P-192:
 
- # Signing a hash value:
+ g = generator_192
+ n = g.order()
+ secret = randrange( 1, n )
+ pubkey = Public_key( g, g * secret )
+ privkey = Private_key( pubkey, secret )
 
- hash = randrange( 1, n )
- signature = privkey.sign( hash, randrange( 1, n ) )
+ # Signing a hash value:
 
- # Verifying a signature for a hash value:
+ hash = randrange( 1, n )
+ signature = privkey.sign( hash, randrange( 1, n ) )
 
- if pubkey.verifies( hash, signature ):
- print_("Demo verification succeeded.")
- else:
- print_("*** Demo verification failed.")
+ # Verifying a signature for a hash value:
 
- # Verification fails if the hash value is modified:
+ if pubkey.verifies( hash, signature ):
+ print_("Demo verification succeeded.")
+ else:
+ print_("*** Demo verification failed.")
 
- if pubkey.verifies( hash-1, signature ):
- print_("**** Demo verification failed to reject tampered hash.")
- else:
- print_("Demo verification correctly rejected tampered hash.")
+ # Verification fails if the hash value is modified:
 
-Version of 2009.05.16.
+ if pubkey.verifies( hash-1, signature ):
+ print_("**** Demo verification failed to reject tampered hash.")
+ else:
+ print_("Demo verification correctly rejected tampered hash.")
 
 Revision history:
 2005.12.31 - Initial version.
+
 2008.11.25 - Substantial revisions introducing new classes.
+
 2009.05.16 - Warn against using random.randrange in real applications.
+
 2009.05.17 - Use random.SystemRandom by default.
 
-Written in 2005 by Peter Pearson and placed in the public domain.
+Originally written in 2005 by Peter Pearson and placed in the public domain,
+modified as part of the python-ecdsa package.
 """
 
 from six import int2byte, b
@@ -69,16 +80,26 @@ class InvalidPointError(RuntimeError):
 
 
 class Signature(object):
- """ECDSA signature."""
+ """
+ ECDSA signature.
+
+ :ivar int r: the ``r`` element of the ECDSA signature
+ :ivar int s: the ``s`` element of the ECDSA signature
+ """
 
 def __init__(self, r, s):
 self.r = r
 self.s = s
 
 def recover_public_keys(self, hash, generator):
- """Returns two public keys for which the signature is valid
- hash is signed hash
- generator is the used generator of the signature
+ """
+ Returns two public keys for which the signature is valid
+
+ :param int hash: signed hash
+ :param AbstractPoint generator: is the generator used in creation
+ of the signature
+ :rtype: tuple(Public_key, Public_key)
+ :return: a pair of public keys that can validate the signature
 """
 curve = generator.curve()
 n = generator.order()
@@ -118,7 +139,7 @@ class Public_key(object):
 :param bool verify: if True check if point is valid point on curve
 
 :raises InvalidPointError: if the point parameters are invalid or
- point does not lie on the curve
+ point does not lay on the curve
 """
 
 self.curve = generator.curve()
@@ -131,7 +152,7 @@ class Public_key(object):
 "The public point has x or y out of range."
 )
 if verify and not self.curve.contains_point(point.x(), point.y()):
- raise InvalidPointError("Point does not lie on the curve")
+ raise InvalidPointError("Point does not lay on the curve")
 if not n:
 raise InvalidPointError("Generator point must have order.")
 # for curve parameters with base point with cofactor 1, all points
@@ -145,11 +166,20 @@ class Public_key(object):
 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 +218,18 @@ class Private_key(object):
 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
@@ -262,7 +296,7 @@ def string_to_int(s):
 
 def digest_integer(m):
 """Convert an integer into a string of bytes, compute
- its SHA-1 hash, and convert the result to an integer."""
+ its SHA-1 hash, and convert the result to an integer."""
 #
 # I don't expect this function to be used much. I wrote
 # it in order to be able to duplicate the examples
@@ -294,6 +328,77 @@ def point_is_valid(generator, x, y):
 return True
 
 
+# secp112r1 curve
+_p = int(remove_whitespace("DB7C 2ABF62E3 5E668076 BEAD208B"), 16)
+# s = 00F50B02 8E4D696E 67687561 51752904 72783FB1
+_a = int(remove_whitespace("DB7C 2ABF62E3 5E668076 BEAD2088"), 16)
+_b = int(remove_whitespace("659E F8BA0439 16EEDE89 11702B22"), 16)
+_Gx = int(remove_whitespace("09487239 995A5EE7 6B55F9C2 F098"), 16)
+_Gy = int(remove_whitespace("A89C E5AF8724 C0A23E0E 0FF77500"), 16)
+_r = int(remove_whitespace("DB7C 2ABF62E3 5E7628DF AC6561C5"), 16)
+_h = 1
+curve_112r1 = ellipticcurve.CurveFp(_p, _a, _b, _h)
+generator_112r1 = ellipticcurve.PointJacobi(
+ curve_112r1, _Gx, _Gy, 1, _r, generator=True
+)
+
+
+# secp112r2 curve
+_p = int(remove_whitespace("DB7C 2ABF62E3 5E668076 BEAD208B"), 16)
+# s = 022757A1 114D69E 67687561 51755316 C05E0BD4
+_a = int(remove_whitespace("6127 C24C05F3 8A0AAAF6 5C0EF02C"), 16)
+_b = int(remove_whitespace("51DE F1815DB5 ED74FCC3 4C85D709"), 16)
+_Gx = int(remove_whitespace("4BA30AB5 E892B4E1 649DD092 8643"), 16)
+_Gy = int(remove_whitespace("ADCD 46F5882E 3747DEF3 6E956E97"), 16)
+_r = int(remove_whitespace("36DF 0AAFD8B8 D7597CA1 0520D04B"), 16)
+_h = 4
+curve_112r2 = ellipticcurve.CurveFp(_p, _a, _b, _h)
+generator_112r2 = ellipticcurve.PointJacobi(
+ curve_112r2, _Gx, _Gy, 1, _r, generator=True
+)
+
+
+# secp128r1 curve
+_p = int(remove_whitespace("FFFFFFFD FFFFFFFF FFFFFFFF FFFFFFFF"), 16)
+# S = 000E0D4D 69E6768 75615175 0CC03A44 73D03679
+# a and b are mod p, so a is equal to p-3, or simply -3
+# _a = -3
+_b = int(remove_whitespace("E87579C1 1079F43D D824993C 2CEE5ED3"), 16)
+_Gx = int(remove_whitespace("161FF752 8B899B2D 0C28607C A52C5B86"), 16)
+_Gy = int(remove_whitespace("CF5AC839 5BAFEB13 C02DA292 DDED7A83"), 16)
+_r = int(remove_whitespace("FFFFFFFE 00000000 75A30D1B 9038A115"), 16)
+_h = 1
+curve_128r1 = ellipticcurve.CurveFp(_p, -3, _b, _h)
+generator_128r1 = ellipticcurve.PointJacobi(
+ curve_128r1, _Gx, _Gy, 1, _r, generator=True
+)
+
+
+# secp160r1
+_p = int(remove_whitespace("FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF 7FFFFFFF"), 16)
+# S = 1053CDE4 2C14D696 E6768756 1517533B F3F83345
+# a and b are mod p, so a is equal to p-3, or simply -3
+# _a = -3
+_b = int(remove_whitespace("1C97BEFC 54BD7A8B 65ACF89F 81D4D4AD C565FA45"), 16)
+_Gx = int(
+ remove_whitespace("4A96B568 8EF57328 46646989 68C38BB9 13CBFC82"),
+ 16,
+)
+_Gy = int(
+ remove_whitespace("23A62855 3168947D 59DCC912 04235137 7AC5FB32"),
+ 16,
+)
+_r = int(
+ remove_whitespace("01 00000000 00000000 0001F4C8 F927AED3 CA752257"),
+ 16,
+)
+_h = 1
+curve_160r1 = ellipticcurve.CurveFp(_p, -3, _b, _h)
+generator_160r1 = ellipticcurve.PointJacobi(
+ curve_160r1, _Gx, _Gy, 1, _r, generator=True
+)
+
+
 # NIST Curve P-192:
 _p = 6277101735386680763835789423207666416083908700390324961279
 _r = 6277101735386680763835789423176059013767194773182842284081
diff --git a/frozen_deps/ecdsa/eddsa.py b/frozen_deps/ecdsa/eddsa.py
new file mode 100644
index 0000000..9769cfd
--- /dev/null
+++ b/frozen_deps/ecdsa/eddsa.py
@@ -0,0 +1,252 @@
+"""Implementation of Edwards Digital Signature Algorithm."""
+
+import hashlib
+from ._sha3 import shake_256
+from . import ellipticcurve
+from ._compat import (
+ remove_whitespace,
+ bit_length,
+ bytes_to_int,
+ int_to_bytes,
+ compat26_str,
+)
+
+# edwards25519, defined in RFC7748
+_p = 2**255 - 19
+_a = -1
+_d = int(
+ remove_whitespace(
+ "370957059346694393431380835087545651895421138798432190163887855330"
+ "85940283555"
+ )
+)
+_h = 8
+
+_Gx = int(
+ remove_whitespace(
+ "151122213495354007725011514095885315114540126930418572060461132"
+ "83949847762202"
+ )
+)
+_Gy = int(
+ remove_whitespace(
+ "463168356949264781694283940034751631413079938662562256157830336"
+ "03165251855960"
+ )
+)
+_r = 2**252 + 0x14DEF9DEA2F79CD65812631A5CF5D3ED
+
+
+def _sha512(data):
+ return hashlib.new("sha512", compat26_str(data)).digest()
+
+
+curve_ed25519 = ellipticcurve.CurveEdTw(_p, _a, _d, _h, _sha512)
+generator_ed25519 = ellipticcurve.PointEdwards(
+ curve_ed25519, _Gx, _Gy, 1, _Gx * _Gy % _p, _r, generator=True
+)
+
+
+# edwards448, defined in RFC7748
+_p = 2**448 - 2**224 - 1
+_a = 1
+_d = -39081 % _p
+_h = 4
+
+_Gx = int(
+ remove_whitespace(
+ "224580040295924300187604334099896036246789641632564134246125461"
+ "686950415467406032909029192869357953282578032075146446173674602635"
+ "247710"
+ )
+)
+_Gy = int(
+ remove_whitespace(
+ "298819210078481492676017930443930673437544040154080242095928241"
+ "372331506189835876003536878655418784733982303233503462500531545062"
+ "832660"
+ )
+)
+_r = 2**446 - 0x8335DC163BB124B65129C96FDE933D8D723A70AADC873D6D54A7BB0D
+
+
+def _shake256(data):
+ return shake_256(data, 114)
+
+
+curve_ed448 = ellipticcurve.CurveEdTw(_p, _a, _d, _h, _shake256)
+generator_ed448 = ellipticcurve.PointEdwards(
+ curve_ed448, _Gx, _Gy, 1, _Gx * _Gy % _p, _r, generator=True
+)
+
+
+class PublicKey(object):
+ """Public key for the Edwards Digital Signature Algorithm."""
+
+ def __init__(self, generator, public_key, public_point=None):
+ self.generator = generator
+ self.curve = generator.curve()
+ self.__encoded = public_key
+ # plus one for the sign bit and round up
+ self.baselen = (bit_length(self.curve.p()) + 1 + 7) // 8
+ if len(public_key) != self.baselen:
+ raise ValueError(
+ "Incorrect size of the public key, expected: {0} bytes".format(
+ self.baselen
+ )
+ )
+ if public_point:
+ self.__point = public_point
+ else:
+ self.__point = ellipticcurve.PointEdwards.from_bytes(
+ self.curve, public_key
+ )
+
+ def __eq__(self, other):
+ if isinstance(other, PublicKey):
+ return (
+ self.curve == other.curve and self.__encoded == other.__encoded
+ )
+ return NotImplemented
+
+ def __ne__(self, other):
+ return not self == other
+
+ @property
+ def point(self):
+ return self.__point
+
+ @point.setter
+ def point(self, other):
+ if self.__point != other:
+ raise ValueError("Can't change the coordinates of the point")
+ self.__point = other
+
+ def public_point(self):
+ return self.__point
+
+ def public_key(self):
+ return self.__encoded
+
+ def verify(self, data, signature):
+ """Verify a Pure EdDSA signature over data."""
+ data = compat26_str(data)
+ if len(signature) != 2 * self.baselen:
+ raise ValueError(
+ "Invalid signature length, expected: {0} bytes".format(
+ 2 * self.baselen
+ )
+ )
+ R = ellipticcurve.PointEdwards.from_bytes(
+ self.curve, signature[: self.baselen]
+ )
+ S = bytes_to_int(signature[self.baselen :], "little")
+ if S >= self.generator.order():
+ raise ValueError("Invalid signature")
+
+ dom = bytearray()
+ if self.curve == curve_ed448:
+ dom = bytearray(b"SigEd448" + b"\x00\x00")
+
+ k = bytes_to_int(
+ self.curve.hash_func(dom + R.to_bytes() + self.__encoded + data),
+ "little",
+ )
+
+ if self.generator * S != self.__point * k + R:
+ raise ValueError("Invalid signature")
+
+ return True
+
+
+class PrivateKey(object):
+ """Private key for the Edwards Digital Signature Algorithm."""
+
+ def __init__(self, generator, private_key):
+ self.generator = generator
+ self.curve = generator.curve()
+ # plus one for the sign bit and round up
+ self.baselen = (bit_length(self.curve.p()) + 1 + 7) // 8
+ if len(private_key) != self.baselen:
+ raise ValueError(
+ "Incorrect size of private key, expected: {0} bytes".format(
+ self.baselen
+ )
+ )
+ self.__private_key = bytes(private_key)
+ self.__h = bytearray(self.curve.hash_func(private_key))
+ self.__public_key = None
+
+ a = self.__h[: self.baselen]
+ a = self._key_prune(a)
+ scalar = bytes_to_int(a, "little")
+ self.__s = scalar
+
+ @property
+ def private_key(self):
+ return self.__private_key
+
+ def __eq__(self, other):
+ if isinstance(other, PrivateKey):
+ return (
+ self.curve == other.curve
+ and self.__private_key == other.__private_key
+ )
+ return NotImplemented
+
+ def __ne__(self, other):
+ return not self == other
+
+ def _key_prune(self, key):
+ # make sure the key is not in a small subgroup
+ h = self.curve.cofactor()
+ if h == 4:
+ h_log = 2
+ elif h == 8:
+ h_log = 3
+ else:
+ raise ValueError("Only cofactor 4 and 8 curves supported")
+ key[0] &= ~((1 << h_log) - 1)
+
+ # ensure the highest bit is set but no higher
+ l = bit_length(self.curve.p())
+ if l % 8 == 0:
+ key[-1] = 0
+ key[-2] |= 0x80
+ else:
+ key[-1] = key[-1] & (1 << (l % 8)) - 1 | 1 << (l % 8) - 1
+ return key
+
+ def public_key(self):
+ """Generate the public key based on the included private key"""
+ if self.__public_key:
+ return self.__public_key
+
+ public_point = self.generator * self.__s
+
+ self.__public_key = PublicKey(
+ self.generator, public_point.to_bytes(), public_point
+ )
+
+ return self.__public_key
+
+ def sign(self, data):
+ """Perform a Pure EdDSA signature over data."""
+ data = compat26_str(data)
+ A = self.public_key().public_key()
+
+ prefix = self.__h[self.baselen :]
+
+ dom = bytearray()
+ if self.curve == curve_ed448:
+ dom = bytearray(b"SigEd448" + b"\x00\x00")
+
+ r = bytes_to_int(self.curve.hash_func(dom + prefix + data), "little")
+ R = (self.generator * r).to_bytes()
+
+ k = bytes_to_int(self.curve.hash_func(dom + R + A + data), "little")
+ k %= self.generator.order()
+
+ S = (r + k * self.__s) % self.generator.order()
+
+ return R + int_to_bytes(S, self.baselen, "little")
diff --git a/frozen_deps/ecdsa/ellipticcurve.py b/frozen_deps/ecdsa/ellipticcurve.py
index 25565df..d6f7146 100644
--- a/frozen_deps/ecdsa/ellipticcurve.py
+++ b/frozen_deps/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
 
@@ -39,7 +38,7 @@ try:
 from gmpy2 import mpz
 
 GMPY = True
-except ImportError:
+except ImportError: # pragma: no branch
 try:
 from gmpy import mpz
 
@@ -50,14 +49,19 @@ except ImportError:
 
 from six import python_2_unicode_compatible
 from . import numbertheory
-from ._rwlock import RWLock
+from ._compat import normalise_bytes, int_to_bytes, bit_length, bytes_to_int
+from .errors import MalformedPointError
+from .util import orderlen, string_to_number, number_to_string
 
 
 @python_2_unicode_compatible
 class CurveFp(object):
- """Elliptic Curve over the field of integers modulo a prime."""
+ """
+ :term:`Short Weierstrass Elliptic Curve <short Weierstrass curve>` over a
+ prime field.
+ """
 
- if GMPY:
+ if GMPY: # pragma: no branch
 
 def __init__(self, p, a, b, h=None):
 """
@@ -75,7 +79,7 @@ class CurveFp(object):
 # gmpy with it
 self.__h = h
 
- else:
+ else: # pragma: no branch
 
 def __init__(self, p, a, b, h=None):
 """
@@ -92,17 +96,25 @@ class CurveFp(object):
 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."""
+ p = self.__p
 return (
 self.__p == other.__p
- and self.__a == other.__a
- and self.__b == other.__b
+ and self.__a % p == other.__a % p
+ and self.__b % p == other.__b % p
 )
 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))
@@ -132,9 +144,356 @@ class CurveFp(object):
 )
 
 
-class PointJacobi(object):
+class CurveEdTw(object):
+ """Parameters for a Twisted Edwards Elliptic Curve"""
+
+ if GMPY: # pragma: no branch
+
+ def __init__(self, p, a, d, h=None, hash_func=None):
+ """
+ The curve of points satisfying a*x^2 + y^2 = 1 + d*x^2*y^2 (mod p).
+
+ h is the cofactor of the curve.
+ hash_func is the hash function associated with the curve
+ (like SHA-512 for Ed25519)
+ """
+ self.__p = mpz(p)
+ self.__a = mpz(a)
+ self.__d = mpz(d)
+ self.__h = h
+ self.__hash_func = hash_func
+
+ else:
+
+ def __init__(self, p, a, d, h=None, hash_func=None):
+ """
+ The curve of points satisfying a*x^2 + y^2 = 1 + d*x^2*y^2 (mod p).
+
+ h is the cofactor of the curve.
+ hash_func is the hash function associated with the curve
+ (like SHA-512 for Ed25519)
+ """
+ self.__p = p
+ self.__a = a
+ self.__d = d
+ self.__h = h
+ self.__hash_func = hash_func
+
+ def __eq__(self, other):
+ """Returns True if other is an identical curve."""
+ if isinstance(other, CurveEdTw):
+ p = self.__p
+ return (
+ self.__p == other.__p
+ and self.__a % p == other.__a % p
+ and self.__d % p == other.__d % p
+ )
+ return NotImplemented
+
+ def __ne__(self, other):
+ """Return False if the other is an identical curve, True otherwise."""
+ return not self == other
+
+ def __hash__(self):
+ return hash((self.__p, self.__a, self.__d))
+
+ def contains_point(self, x, y):
+ """Is the point (x, y) on this curve?"""
+ return (
+ self.__a * x * x + y * y - 1 - self.__d * x * x * y * y
+ ) % self.__p == 0
+
+ def p(self):
+ return self.__p
+
+ def a(self):
+ return self.__a
+
+ def d(self):
+ return self.__d
+
+ def hash_func(self, data):
+ return self.__hash_func(data)
+
+ def cofactor(self):
+ return self.__h
+
+ def __str__(self):
+ return "CurveEdTw(p={0}, a={1}, d={2}, h={3})".format(
+ self.__p,
+ self.__a,
+ self.__d,
+ self.__h,
+ )
+
+
+class AbstractPoint(object):
+ """Class for common methods of elliptic curve points."""
+
+ @staticmethod
+ def _from_raw_encoding(data, raw_encoding_length):
+ """
+ Decode public point from :term:`raw encoding`.
+
+ :term:`raw encoding` is the same as the :term:`uncompressed` encoding,
+ but without the 0x04 byte at the beginning.
+ """
+ # real assert, from_bytes() should not call us with different length
+ assert len(data) == raw_encoding_length
+ xs = data[: raw_encoding_length // 2]
+ ys = data[raw_encoding_length // 2 :]
+ # real assert, raw_encoding_length is calculated by multiplying an
+ # integer by two so it will always be even
+ assert len(xs) == raw_encoding_length // 2
+ assert len(ys) == raw_encoding_length // 2
+ coord_x = string_to_number(xs)
+ coord_y = string_to_number(ys)
+
+ return coord_x, coord_y
+
+ @staticmethod
+ def _from_compressed(data, curve):
+ """Decode public point from compressed encoding."""
+ if data[:1] not in (b"\x02", b"\x03"):
+ raise MalformedPointError("Malformed compressed point encoding")
+
+ is_even = data[:1] == b"\x02"
+ x = string_to_number(data[1:])
+ p = curve.p()
+ alpha = (pow(x, 3, p) + (curve.a() * x) + curve.b()) % p
+ try:
+ beta = numbertheory.square_root_mod_prime(alpha, p)
+ except numbertheory.Error as e:
+ raise MalformedPointError(
+ "Encoding does not correspond to a point on curve", e
+ )
+ if is_even == bool(beta & 1):
+ y = p - beta
+ else:
+ y = beta
+ return x, y
+
+ @classmethod
+ def _from_hybrid(cls, data, raw_encoding_length, validate_encoding):
+ """Decode public point from hybrid encoding."""
+ # real assert, from_bytes() should not call us with different types
+ assert data[:1] in (b"\x06", b"\x07")
+
+ # primarily use the uncompressed as it's easiest to handle
+ x, y = cls._from_raw_encoding(data[1:], raw_encoding_length)
+
+ # but validate if it's self-consistent if we're asked to do that
+ if validate_encoding and (
+ y & 1
+ and data[:1] != b"\x07"
+ or (not y & 1)
+ and data[:1] != b"\x06"
+ ):
+ raise MalformedPointError("Inconsistent hybrid point encoding")
+
+ return x, y
+
+ @classmethod
+ def _from_edwards(cls, curve, data):
+ """Decode a point on an Edwards curve."""
+ data = bytearray(data)
+ p = curve.p()
+ # add 1 for the sign bit and then round up
+ exp_len = (bit_length(p) + 1 + 7) // 8
+ if len(data) != exp_len:
+ raise MalformedPointError("Point length doesn't match the curve.")
+ x_0 = (data[-1] & 0x80) >> 7
+
+ data[-1] &= 0x80 - 1
+
+ y = bytes_to_int(data, "little")
+ if GMPY:
+ y = mpz(y)
+
+ x2 = (
+ (y * y - 1)
+ * numbertheory.inverse_mod(curve.d() * y * y - curve.a(), p)
+ % p
+ )
+
+ try:
+ x = numbertheory.square_root_mod_prime(x2, p)
+ except numbertheory.Error as e:
+ raise MalformedPointError(
+ "Encoding does not correspond to a point on curve", e
+ )
+
+ if x % 2 != x_0:
+ x = -x % p
+
+ return x, y
+
+ @classmethod
+ def from_bytes(
+ cls, curve, data, validate_encoding=True, valid_encodings=None
+ ):
+ """
+ Initialise the object from byte encoding of a point.
+
+ The method does accept and automatically detect the type of point
+ encoding used. It supports the :term:`raw encoding`,
+ :term:`uncompressed`, :term:`compressed`, and :term:`hybrid` encodings.
+
+ Note: generally you will want to call the ``from_bytes()`` method of
+ either a child class, PointJacobi or Point.
+
+ :param data: single point encoding of the public key
+ :type data: :term:`bytes-like object`
+ :param curve: the curve on which the public key is expected to lay
+ :type curve: ~ecdsa.ellipticcurve.CurveFp
+ :param validate_encoding: whether to verify that the encoding of the
+ point is self-consistent, defaults to True, has effect only
+ on ``hybrid`` encoding
+ :type validate_encoding: bool
+ :param valid_encodings: list of acceptable point encoding formats,
+ supported ones are: :term:`uncompressed`, :term:`compressed`,
+ :term:`hybrid`, and :term:`raw encoding` (specified with ``raw``
+ name). All formats by default (specified with ``None``).
+ :type valid_encodings: :term:`set-like object`
+
+ :raises `~ecdsa.errors.MalformedPointError`: if the public point does
+ not lay on the curve or the encoding is invalid
+
+ :return: x and y coordinates of the encoded point
+ :rtype: tuple(int, int)
+ """
+ if not valid_encodings:
+ valid_encodings = set(
+ ["uncompressed", "compressed", "hybrid", "raw"]
+ )
+ if not all(
+ i in set(("uncompressed", "compressed", "hybrid", "raw"))
+ for i in valid_encodings
+ ):
+ raise ValueError(
+ "Only uncompressed, compressed, hybrid or raw encoding "
+ "supported."
+ )
+ data = normalise_bytes(data)
+
+ if isinstance(curve, CurveEdTw):
+ return cls._from_edwards(curve, data)
+
+ key_len = len(data)
+ raw_encoding_length = 2 * orderlen(curve.p())
+ if key_len == raw_encoding_length and "raw" in valid_encodings:
+ coord_x, coord_y = cls._from_raw_encoding(
+ data, raw_encoding_length
+ )
+ elif key_len == raw_encoding_length + 1 and (
+ "hybrid" in valid_encodings or "uncompressed" in valid_encodings
+ ):
+ if data[:1] in (b"\x06", b"\x07") and "hybrid" in valid_encodings:
+ coord_x, coord_y = cls._from_hybrid(
+ data, raw_encoding_length, validate_encoding
+ )
+ elif data[:1] == b"\x04" and "uncompressed" in valid_encodings:
+ coord_x, coord_y = cls._from_raw_encoding(
+ data[1:], raw_encoding_length
+ )
+ else:
+ raise MalformedPointError(
+ "Invalid X9.62 encoding of the public point"
+ )
+ elif (
+ key_len == raw_encoding_length // 2 + 1
+ and "compressed" in valid_encodings
+ ):
+ coord_x, coord_y = cls._from_compressed(data, curve)
+ else:
+ raise MalformedPointError(
+ "Length of string does not match lengths of "
+ "any of the enabled ({0}) encodings of the "
+ "curve.".format(", ".join(valid_encodings))
+ )
+ return coord_x, coord_y
+
+ def _raw_encode(self):
+ """Convert the point to the :term:`raw encoding`."""
+ prime = self.curve().p()
+ x_str = number_to_string(self.x(), prime)
+ y_str = number_to_string(self.y(), prime)
+ return x_str + y_str
+
+ def _compressed_encode(self):
+ """Encode the point into the compressed form."""
+ prime = self.curve().p()
+ x_str = number_to_string(self.x(), prime)
+ if self.y() & 1:
+ return b"\x03" + x_str
+ return b"\x02" + x_str
+
+ def _hybrid_encode(self):
+ """Encode the point into the hybrid form."""
+ raw_enc = self._raw_encode()
+ if self.y() & 1:
+ return b"\x07" + raw_enc
+ return b"\x06" + raw_enc
+
+ def _edwards_encode(self):
+ """Encode the point according to RFC8032 encoding."""
+ self.scale()
+ x, y, p = self.x(), self.y(), self.curve().p()
+
+ # add 1 for the sign bit and then round up
+ enc_len = (bit_length(p) + 1 + 7) // 8
+ y_str = int_to_bytes(y, enc_len, "little")
+ if x % 2:
+ y_str[-1] |= 0x80
+ return y_str
+
+ def to_bytes(self, encoding="raw"):
+ """
+ Convert the point to a byte string.
+
+ The method by default uses the :term:`raw encoding` (specified
+ by `encoding="raw"`. It can also output points in :term:`uncompressed`,
+ :term:`compressed`, and :term:`hybrid` formats.
+
+ For points on Edwards curves `encoding` is ignored and only the
+ encoding defined in RFC 8032 is supported.
+
+ :return: :term:`raw encoding` of a public on the curve
+ :rtype: bytes
+ """
+ assert encoding in ("raw", "uncompressed", "compressed", "hybrid")
+ curve = self.curve()
+ if isinstance(curve, CurveEdTw):
+ return self._edwards_encode()
+ elif encoding == "raw":
+ return self._raw_encode()
+ elif encoding == "uncompressed":
+ return b"\x04" + self._raw_encode()
+ elif encoding == "hybrid":
+ return self._hybrid_encode()
+ else:
+ return self._compressed_encode()
+
+ @staticmethod
+ def _naf(mult):
+ """Calculate non-adjacent form of number."""
+ ret = []
+ while mult:
+ if mult % 2:
+ nd = mult % 4
+ if nd >= 2:
+ nd -= 4
+ ret.append(nd)
+ mult -= nd
+ else:
+ ret.append(0)
+ mult //= 2
+ return ret
+
+
+class PointJacobi(AbstractPoint):
 """
- Point on an elliptic curve. Uses Jacobi coordinates.
+ Point on a short Weierstrass elliptic curve. Uses Jacobi coordinates.
 
 In Jacobian coordinates, there are three parameters, X, Y and Z.
 They correspond to affine parameters 'x' and 'y' like so:
@@ -158,88 +517,115 @@ class PointJacobi(object):
 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
 """
+ super(PointJacobi, self).__init__()
 self.__curve = curve
- # since it's generally better (faster) to use scaled points vs unscaled
- # ones, use writer-biased RWLock for locking:
- self._update_lock = RWLock()
- if GMPY:
- self.__x = mpz(x)
- self.__y = mpz(y)
- self.__z = mpz(z)
+ if GMPY: # pragma: no branch
+ self.__coords = (mpz(x), mpz(y), mpz(z))
 self.__order = order and mpz(order)
- else:
- self.__x = x
- self.__y = y
- self.__z = z
+ else: # pragma: no branch
+ self.__coords = (x, y, z)
 self.__order = order
 self.__generator = generator
 self.__precompute = []
 
- def _maybe_precompute(self):
- if self.__generator:
- # since we lack promotion of read-locks to write-locks, we do a
- # "acquire-read-lock, check, acquire-write-lock plus recheck" cycle
- try:
- self._update_lock.reader_acquire()
- if self.__precompute:
- return
- finally:
- self._update_lock.reader_release()
-
- try:
- self._update_lock.writer_acquire()
- if self.__precompute:
- return
- order = self.__order
- assert order
- i = 1
- order *= 2
- doubler = PointJacobi(
- self.__curve, self.__x, self.__y, self.__z, order
- )
- order *= 2
- self.__precompute.append((doubler.x(), doubler.y()))
+ @classmethod
+ def from_bytes(
+ cls,
+ curve,
+ data,
+ validate_encoding=True,
+ valid_encodings=None,
+ order=None,
+ generator=False,
+ ):
+ """
+ Initialise the object from byte encoding of a point.
+
+ The method does accept and automatically detect the type of point
+ encoding used. It supports the :term:`raw encoding`,
+ :term:`uncompressed`, :term:`compressed`, and :term:`hybrid` encodings.
+
+ :param data: single point encoding of the public key
+ :type data: :term:`bytes-like object`
+ :param curve: the curve on which the public key is expected to lay
+ :type curve: ~ecdsa.ellipticcurve.CurveFp
+ :param validate_encoding: whether to verify that the encoding of the
+ point is self-consistent, defaults to True, has effect only
+ on ``hybrid`` encoding
+ :type validate_encoding: bool
+ :param valid_encodings: list of acceptable point encoding formats,
+ supported ones are: :term:`uncompressed`, :term:`compressed`,
+ :term:`hybrid`, and :term:`raw encoding` (specified with ``raw``
+ name). All formats by default (specified with ``None``).
+ :type valid_encodings: :term:`set-like object`
+ :param int order: the point order, must be non zero when using
+ 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 generation for it
+
+ :raises `~ecdsa.errors.MalformedPointError`: if the public point does
+ not lay on the curve or the encoding is invalid
 
- while i < order:
- i *= 2
- doubler = doubler.double().scale()
- self.__precompute.append((doubler.x(), doubler.y()))
+ :return: Point on curve
+ :rtype: PointJacobi
+ """
+ coord_x, coord_y = super(PointJacobi, cls).from_bytes(
+ curve, data, validate_encoding, valid_encodings
+ )
+ return PointJacobi(curve, coord_x, coord_y, 1, order, generator)
 
- finally:
- self._update_lock.writer_release()
+ def _maybe_precompute(self):
+ if not self.__generator or self.__precompute:
+ return
+
+ # since this code will execute just once, and it's fully deterministic,
+ # depend on atomicity of the last assignment to switch from empty
+ # self.__precompute to filled one and just ignore the unlikely
+ # situation when two threads execute it at the same time (as it won't
+ # lead to inconsistent __precompute)
+ order = self.__order
+ assert order
+ precompute = []
+ i = 1
+ order *= 2
+ coord_x, coord_y, coord_z = self.__coords
+ doubler = PointJacobi(self.__curve, coord_x, coord_y, coord_z, order)
+ order *= 2
+ precompute.append((doubler.x(), doubler.y()))
+
+ while i < order:
+ i *= 2
+ doubler = doubler.double().scale()
+ precompute.append((doubler.x(), doubler.y()))
+
+ self.__precompute = precompute
 
 def __getstate__(self):
- try:
- self._update_lock.reader_acquire()
- state = self.__dict__.copy()
- finally:
- self._update_lock.reader_release()
- del state["_update_lock"]
+ # while this code can execute at the same time as _maybe_precompute()
+ # is updating the __precompute or scale() is updating the __coords,
+ # there is no requirement for consistency between __coords and
+ # __precompute
+ state = self.__dict__.copy()
 return state
 
 def __setstate__(self, state):
 self.__dict__.update(state)
- self._update_lock = RWLock()
 
 def __eq__(self, other):
- """Compare two points with each-other."""
- try:
- self._update_lock.reader_acquire()
- if other is INFINITY:
- return not self.__y or not self.__z
- x1, y1, z1 = self.__x, self.__y, self.__z
- finally:
- self._update_lock.reader_release()
+ """Compare for equality two points with each-other.
+
+ Note: only points that lay on the same curve can be equal.
+ """
+ x1, y1, z1 = self.__coords
+ if other is INFINITY:
+ return not y1 or not z1
 if isinstance(other, Point):
 x2, y2, z2 = other.x(), other.y(), 1
 elif isinstance(other, PointJacobi):
- try:
- other._update_lock.reader_acquire()
- x2, y2, z2 = other.__x, other.__y, other.__z
- finally:
- other._update_lock.reader_release()
+ x2, y2, z2 = other.__coords
 else:
 return NotImplemented
 if self.__curve != other.curve():
@@ -256,6 +642,10 @@ class PointJacobi(object):
 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.
 
@@ -276,17 +666,12 @@ class PointJacobi(object):
 call x() and y() on the returned instance. Or call `scale()`
 and then x() and y() on the returned instance.
 """
- try:
- self._update_lock.reader_acquire()
- if self.__z == 1:
- return self.__x
- x = self.__x
- z = self.__z
- finally:
- self._update_lock.reader_release()
+ x, _, z = self.__coords
+ if z == 1:
+ return x
 p = self.__curve.p()
 z = numbertheory.inverse_mod(z, p)
- return x * z ** 2 % p
+ return x * z**2 % p
 
 def y(self):
 """
@@ -297,17 +682,12 @@ class PointJacobi(object):
 call x() and y() on the returned instance. Or call `scale()`
 and then x() and y() on the returned instance.
 """
- try:
- self._update_lock.reader_acquire()
- if self.__z == 1:
- return self.__y
- y = self.__y
- z = self.__z
- finally:
- self._update_lock.reader_release()
+ _, y, z = self.__coords
+ if z == 1:
+ return y
 p = self.__curve.p()
 z = numbertheory.inverse_mod(z, p)
- return y * z ** 3 % p
+ return y * z**3 % p
 
 def scale(self):
 """
@@ -315,37 +695,28 @@ class PointJacobi(object):
 
 Modifies point in place, returns self.
 """
- try:
- self._update_lock.reader_acquire()
- if self.__z == 1:
- return self
- finally:
- self._update_lock.reader_release()
+ x, y, z = self.__coords
+ if z == 1:
+ return self
 
- try:
- self._update_lock.writer_acquire()
- # scaling already scaled point is safe (as inverse of 1 is 1) and
- # quick so we don't need to optimise for the unlikely event when
- # two threads hit the lock at the same time
- p = self.__curve.p()
- z_inv = numbertheory.inverse_mod(self.__z, p)
- zz_inv = z_inv * z_inv % p
- self.__x = self.__x * zz_inv % p
- self.__y = self.__y * zz_inv * z_inv % p
- # we are setting the z last so that the check above will return
- # true only after all values were already updated
- self.__z = 1
- finally:
- self._update_lock.writer_release()
+ # scaling is deterministic, so even if two threads execute the below
+ # code at the same time, they will set __coords to the same value
+ p = self.__curve.p()
+ z_inv = numbertheory.inverse_mod(z, p)
+ zz_inv = z_inv * z_inv % p
+ x = x * zz_inv % p
+ y = y * zz_inv * z_inv % p
+ self.__coords = (x, y, 1)
 return self
 
 def to_affine(self):
 """Return point in affine form."""
- if not self.__y or not self.__z:
+ _, y, z = self.__coords
+ if not y or not z:
 return INFINITY
 self.scale()
- # after point is scaled, it's immutable, so no need to perform locking
- return Point(self.__curve, self.__x, self.__y, self.__order)
+ x, y, z = self.__coords
+ return Point(self.__curve, x, y, self.__order)
 
 @staticmethod
 def from_affine(point, generator=False):
@@ -359,7 +730,8 @@ class PointJacobi(object):
 point.curve(), point.x(), point.y(), 1, point.order(), generator
 )
 
- # plese note that all the methods that use the equations from hyperelliptic
+ # please note that all the methods that use the equations from
+ # hyperelliptic
 # are formatted in a way to maximise performance.
 # Things that make code faster: multiplying instead of taking to the power
 # (`xx = x * x; xxxx = xx * xx % p` is faster than `xxxx = x**4 % p` and
@@ -389,7 +761,7 @@ class PointJacobi(object):
 """Add a point to itself, arbitrary z."""
 if Z1 == 1:
 return self._double_with_z_1(X1, Y1, p, a)
- if not Z1:
+ if not Y1 or not Z1:
 return 0, 0, 1
 # after:
 # http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#doubling-dbl-2007-bl
@@ -409,17 +781,13 @@ class PointJacobi(object):
 
 def double(self):
 """Add a point to itself."""
- if not self.__y:
+ X1, Y1, Z1 = self.__coords
+
+ if not Y1:
 return INFINITY
 
 p, a = self.__curve.p(), self.__curve.a()
 
- try:
- self._update_lock.reader_acquire()
- X1, Y1, Z1 = self.__x, self.__y, self.__z
- finally:
- self._update_lock.reader_release()
-
 X3, Y3, Z3 = self._double(X1, Y1, Z1, p, a)
 
 if not Y3 or not Z3:
@@ -438,7 +806,7 @@ class PointJacobi(object):
 if not H and not r:
 return self._double_with_z_1(X1, Y1, p, self.__curve.a())
 V = X1 * I
- X3 = (r ** 2 - J - 2 * V) % p
+ X3 = (r**2 - J - 2 * V) % p
 Y3 = (r * (V - X3) - 2 * Y1 * J) % p
 Z3 = 2 * H % p
 return X3, Y3, Z3
@@ -532,16 +900,9 @@ class PointJacobi(object):
 raise ValueError("The other point is on different curve")
 
 p = self.__curve.p()
- try:
- self._update_lock.reader_acquire()
- X1, Y1, Z1 = self.__x, self.__y, self.__z
- finally:
- self._update_lock.reader_release()
- try:
- other._update_lock.reader_acquire()
- X2, Y2, Z2 = other.__x, other.__y, other.__z
- finally:
- other._update_lock.reader_release()
+ X1, Y1, Z1 = self.__coords
+ X2, Y2, Z2 = other.__coords
+
 X3, Y3, Z3 = self._add(X1, Y1, Z1, X2, Y2, Z2, p)
 
 if not Y3 or not Z3:
@@ -571,25 +932,9 @@ class PointJacobi(object):
 return INFINITY
 return PointJacobi(self.__curve, X3, Y3, Z3, self.__order)
 
- @staticmethod
- def _naf(mult):
- """Calculate non-adjacent form of number."""
- ret = []
- while mult:
- if mult % 2:
- nd = mult % 4
- if nd >= 2:
- nd = nd - 4
- ret += [nd]
- mult -= nd
- else:
- ret += [0]
- mult //= 2
- return ret
-
 def __mul__(self, other):
 """Multiply point by an integer."""
- if not self.__y or not other:
+ if not self.__coords[1] or not other:
 return INFINITY
 if other == 1:
 return self
@@ -601,8 +946,7 @@ class PointJacobi(object):
 return self._mul_precompute(other)
 
 self = self.scale()
- # once scaled, point is immutable, not need to lock
- X2, Y2 = self.__x, self.__y
+ X2, Y2, _ = self.__coords
 X3, Y3, Z3 = 0, 0, 1
 p, a = self.__curve.p(), self.__curve.a()
 _double = self._double
@@ -621,29 +965,20 @@ class PointJacobi(object):
 
 return PointJacobi(self.__curve, X3, Y3, Z3, self.__order)
 
- @staticmethod
- def _leftmost_bit(x):
- """Return integer with the same magnitude as x but only one bit set"""
- assert x > 0
- result = 1
- while result <= x:
- result = 2 * result
- return result // 2
-
 def mul_add(self, self_mul, other, other_mul):
 """
 Do two multiplications at the same time, add results.
 
 calculates self*self_mul + other*other_mul
 """
- if other is INFINITY or other_mul == 0:
+ if other == INFINITY or other_mul == 0:
 return self * self_mul
 if self_mul == 0:
 return other * other_mul
 if not isinstance(other, PointJacobi):
 other = PointJacobi.from_affine(other)
 # when the points have precomputed answers, then multiplying them alone
- # is faster (as it uses NAF)
+ # is faster (as it uses NAF and no point doublings)
 self._maybe_precompute()
 other._maybe_precompute()
 if self.__precompute and other.__precompute:
@@ -653,32 +988,75 @@ class PointJacobi(object):
 self_mul = self_mul % self.__order
 other_mul = other_mul % self.__order
 
- i = self._leftmost_bit(max(self_mul, other_mul)) * 2
+ # (X3, Y3, Z3) is the accumulator
 X3, Y3, Z3 = 0, 0, 1
 p, a = self.__curve.p(), self.__curve.a()
- self = self.scale()
- # after scaling, point is immutable, no need for locking
- X1, Y1 = self.__x, self.__y
- other = other.scale()
- X2, Y2 = other.__x, other.__y
- both = self + other
- if both is INFINITY:
- X4, Y4 = 0, 0
- else:
- both.scale()
- X4, Y4 = both.__x, both.__y
+
+ # as we have 6 unique points to work with, we can't scale all of them,
+ # but do scale the ones that are used most often
+ self.scale()
+ X1, Y1, Z1 = self.__coords
+ other.scale()
+ X2, Y2, Z2 = other.__coords
+
 _double = self._double
 _add = self._add
- while i > 1:
+
+ # with NAF we have 3 options: no add, subtract, add
+ # so with 2 points, we have 9 combinations:
+ # 0, -A, +A, -B, -A-B, +A-B, +B, -A+B, +A+B
+ # so we need 4 combined points:
+ mAmB_X, mAmB_Y, mAmB_Z = _add(X1, -Y1, Z1, X2, -Y2, Z2, p)
+ pAmB_X, pAmB_Y, pAmB_Z = _add(X1, Y1, Z1, X2, -Y2, Z2, p)
+ mApB_X, mApB_Y, mApB_Z = _add(X1, -Y1, Z1, X2, Y2, Z2, p)
+ pApB_X, pApB_Y, pApB_Z = _add(X1, Y1, Z1, X2, Y2, Z2, p)
+ # when the self and other sum to infinity, we need to add them
+ # one by one to get correct result but as that's very unlikely to
+ # happen in regular operation, we don't need to optimise this case
+ if not pApB_Y or not pApB_Z:
+ return self * self_mul + other * other_mul
+
+ # gmp object creation has cumulatively higher overhead than the
+ # speedup we get from calculating the NAF using gmp so ensure use
+ # of int()
+ self_naf = list(reversed(self._naf(int(self_mul))))
+ other_naf = list(reversed(self._naf(int(other_mul))))
+ # ensure that the lists are the same length (zip() will truncate
+ # longer one otherwise)
+ if len(self_naf) < len(other_naf):
+ self_naf = [0] * (len(other_naf) - len(self_naf)) + self_naf
+ elif len(self_naf) > len(other_naf):
+ other_naf = [0] * (len(self_naf) - len(other_naf)) + other_naf
+
+ for A, B in zip(self_naf, other_naf):
 X3, Y3, Z3 = _double(X3, Y3, Z3, p, a)
- i = i // 2
 
- if self_mul & i and other_mul & i:
- X3, Y3, Z3 = _add(X3, Y3, Z3, X4, Y4, 1, p)
- elif self_mul & i:
- X3, Y3, Z3 = _add(X3, Y3, Z3, X1, Y1, 1, p)
- elif other_mul & i:
- X3, Y3, Z3 = _add(X3, Y3, Z3, X2, Y2, 1, p)
+ # conditions ordered from most to least likely
+ if A == 0:
+ if B == 0:
+ pass
+ elif B < 0:
+ X3, Y3, Z3 = _add(X3, Y3, Z3, X2, -Y2, Z2, p)
+ else:
+ assert B > 0
+ X3, Y3, Z3 = _add(X3, Y3, Z3, X2, Y2, Z2, p)
+ elif A < 0:
+ if B == 0:
+ X3, Y3, Z3 = _add(X3, Y3, Z3, X1, -Y1, Z1, p)
+ elif B < 0:
+ X3, Y3, Z3 = _add(X3, Y3, Z3, mAmB_X, mAmB_Y, mAmB_Z, p)
+ else:
+ assert B > 0
+ X3, Y3, Z3 = _add(X3, Y3, Z3, mApB_X, mApB_Y, mApB_Z, p)
+ else:
+ assert A > 0
+ if B == 0:
+ X3, Y3, Z3 = _add(X3, Y3, Z3, X1, Y1, Z1, p)
+ elif B < 0:
+ X3, Y3, Z3 = _add(X3, Y3, Z3, pAmB_X, pAmB_Y, pAmB_Z, p)
+ else:
+ assert B > 0
+ X3, Y3, Z3 = _add(X3, Y3, Z3, pApB_X, pApB_Y, pApB_Z, p)
 
 if not Y3 or not Z3:
 return INFINITY
@@ -687,21 +1065,17 @@ class PointJacobi(object):
 
 def __neg__(self):
 """Return negated point."""
- try:
- self._update_lock.reader_acquire()
- return PointJacobi(
- self.__curve, self.__x, -self.__y, self.__z, self.__order
- )
- finally:
- self._update_lock.reader_release()
+ x, y, z = self.__coords
+ return PointJacobi(self.__curve, x, -y, z, self.__order)
 
 
-class Point(object):
- """A point on an elliptic curve. Altering x and y is forbidding,
- but they can be read by the x() and y() methods."""
+class Point(AbstractPoint):
+ """A point on a short Weierstrass elliptic curve. Altering x and y is
+ forbidden, but they can be read by the x() and y() methods."""
 
 def __init__(self, curve, x, y, order=None):
 """curve, x, y, order; order (optional) is the order of this point."""
+ super(Point, self).__init__()
 self.__curve = curve
 if GMPY:
 self.__x = x and mpz(x)
@@ -720,8 +1094,54 @@ class Point(object):
 if curve and curve.cofactor() != 1 and order:
 assert self * order == INFINITY
 
+ @classmethod
+ def from_bytes(
+ cls,
+ curve,
+ data,
+ validate_encoding=True,
+ valid_encodings=None,
+ order=None,
+ ):
+ """
+ Initialise the object from byte encoding of a point.
+
+ The method does accept and automatically detect the type of point
+ encoding used. It supports the :term:`raw encoding`,
+ :term:`uncompressed`, :term:`compressed`, and :term:`hybrid` encodings.
+
+ :param data: single point encoding of the public key
+ :type data: :term:`bytes-like object`
+ :param curve: the curve on which the public key is expected to lay
+ :type curve: ~ecdsa.ellipticcurve.CurveFp
+ :param validate_encoding: whether to verify that the encoding of the
+ point is self-consistent, defaults to True, has effect only
+ on ``hybrid`` encoding
+ :type validate_encoding: bool
+ :param valid_encodings: list of acceptable point encoding formats,
+ supported ones are: :term:`uncompressed`, :term:`compressed`,
+ :term:`hybrid`, and :term:`raw encoding` (specified with ``raw``
+ name). All formats by default (specified with ``None``).
+ :type valid_encodings: :term:`set-like object`
+ :param int order: the point order, must be non zero when using
+ generator=True
+
+ :raises `~ecdsa.errors.MalformedPointError`: if the public point does
+ not lay on the curve or the encoding is invalid
+
+ :return: Point on curve
+ :rtype: Point
+ """
+ coord_x, coord_y = super(Point, cls).from_bytes(
+ curve, data, validate_encoding, valid_encodings
+ )
+ return Point(curve, coord_x, coord_y, order)
+
 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 lay on the same curve can be equal.
+ """
 if isinstance(other, Point):
 return (
 self.__curve == other.__curve
@@ -730,6 +1150,10 @@ class Point(object):
 )
 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)
 
@@ -843,5 +1267,318 @@ class Point(object):
 return self.__order
 
 
+class PointEdwards(AbstractPoint):
+ """Point on Twisted Edwards curve.
+
+ Internally represents the coordinates on the curve using four parameters,
+ X, Y, Z, T. They correspond to affine parameters 'x' and 'y' like so:
+
+ x = X / Z
+ y = Y / Z
+ x*y = T / Z
+ """
+
+ def __init__(self, curve, x, y, z, t, order=None, generator=False):
+ """
+ Initialise a point that uses the extended coordinates internally.
+ """
+ super(PointEdwards, self).__init__()
+ self.__curve = curve
+ if GMPY: # pragma: no branch
+ self.__coords = (mpz(x), mpz(y), mpz(z), mpz(t))
+ self.__order = order and mpz(order)
+ else: # pragma: no branch
+ self.__coords = (x, y, z, t)
+ self.__order = order
+ self.__generator = generator
+ self.__precompute = []
+
+ @classmethod
+ def from_bytes(
+ cls,
+ curve,
+ data,
+ validate_encoding=None,
+ valid_encodings=None,
+ order=None,
+ generator=False,
+ ):
+ """
+ Initialise the object from byte encoding of a point.
+
+ `validate_encoding` and `valid_encodings` are provided for
+ compatibility with Weierstrass curves, they are ignored for Edwards
+ points.
+
+ :param data: single point encoding of the public key
+ :type data: :term:`bytes-like object`
+ :param curve: the curve on which the public key is expected to lay
+ :type curve: ecdsa.ellipticcurve.CurveEdTw
+ :param None validate_encoding: Ignored, encoding is always validated
+ :param None valid_encodings: Ignored, there is just one encoding
+ supported
+ :param int order: the point order, must be non zero when using
+ generator=True
+ :param bool generator: Flag to mark the point as a curve generator,
+ this will cause the library to pre-compute some values to
+ make repeated usages of the point much faster
+
+ :raises `~ecdsa.errors.MalformedPointError`: if the public point does
+ not lay on the curve or the encoding is invalid
+
+ :return: Initialised point on an Edwards curve
+ :rtype: PointEdwards
+ """
+ coord_x, coord_y = super(PointEdwards, cls).from_bytes(
+ curve, data, validate_encoding, valid_encodings
+ )
+ return PointEdwards(
+ curve, coord_x, coord_y, 1, coord_x * coord_y, order, generator
+ )
+
+ def _maybe_precompute(self):
+ if not self.__generator or self.__precompute:
+ return self.__precompute
+
+ # since this code will execute just once, and it's fully deterministic,
+ # depend on atomicity of the last assignment to switch from empty
+ # self.__precompute to filled one and just ignore the unlikely
+ # situation when two threads execute it at the same time (as it won't
+ # lead to inconsistent __precompute)
+ order = self.__order
+ assert order
+ precompute = []
+ i = 1
+ order *= 2
+ coord_x, coord_y, coord_z, coord_t = self.__coords
+ prime = self.__curve.p()
+
+ doubler = PointEdwards(
+ self.__curve, coord_x, coord_y, coord_z, coord_t, order
+ )
+ # for "protection" against Minerva we need 1 or 2 more bits depending
+ # on order bit size, but it's easier to just calculate one
+ # point more always
+ order *= 4
+
+ while i < order:
+ doubler = doubler.scale()
+ coord_x, coord_y = doubler.x(), doubler.y()
+ coord_t = coord_x * coord_y % prime
+ precompute.append((coord_x, coord_y, coord_t))
+
+ i *= 2
+ doubler = doubler.double()
+
+ self.__precompute = precompute
+ return self.__precompute
+
+ def x(self):
+ """Return affine x coordinate."""
+ X1, _, Z1, _ = self.__coords
+ if Z1 == 1:
+ return X1
+ p = self.__curve.p()
+ z_inv = numbertheory.inverse_mod(Z1, p)
+ return X1 * z_inv % p
+
+ def y(self):
+ """Return affine y coordinate."""
+ _, Y1, Z1, _ = self.__coords
+ if Z1 == 1:
+ return Y1
+ p = self.__curve.p()
+ z_inv = numbertheory.inverse_mod(Z1, p)
+ return Y1 * z_inv % p
+
+ def curve(self):
+ """Return the curve of the point."""
+ return self.__curve
+
+ def order(self):
+ return self.__order
+
+ def scale(self):
+ """
+ Return point scaled so that z == 1.
+
+ Modifies point in place, returns self.
+ """
+ X1, Y1, Z1, _ = self.__coords
+ if Z1 == 1:
+ return self
+
+ p = self.__curve.p()
+ z_inv = numbertheory.inverse_mod(Z1, p)
+ x = X1 * z_inv % p
+ y = Y1 * z_inv % p
+ t = x * y % p
+ self.__coords = (x, y, 1, t)
+ return self
+
+ def __eq__(self, other):
+ """Compare for equality two points with each-other.
+
+ Note: only points on the same curve can be equal.
+ """
+ x1, y1, z1, t1 = self.__coords
+ if other is INFINITY:
+ return not x1 or not t1
+ if isinstance(other, PointEdwards):
+ x2, y2, z2, t2 = other.__coords
+ else:
+ return NotImplemented
+ if self.__curve != other.curve():
+ return False
+ p = self.__curve.p()
+
+ # cross multiply to eliminate divisions
+ xn1 = x1 * z2 % p
+ xn2 = x2 * z1 % p
+ yn1 = y1 * z2 % p
+ yn2 = y2 * z1 % p
+ return xn1 == xn2 and yn1 == yn2
+
+ def __ne__(self, other):
+ """Compare for inequality two points with each-other."""
+ return not self == other
+
+ def _add(self, X1, Y1, Z1, T1, X2, Y2, Z2, T2, p, a):
+ """add two points, assume sane parameters."""
+ # after add-2008-hwcd-2
+ # from https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html
+ # NOTE: there are more efficient formulas for Z1 or Z2 == 1
+ A = X1 * X2 % p
+ B = Y1 * Y2 % p
+ C = Z1 * T2 % p
+ D = T1 * Z2 % p
+ E = D + C
+ F = ((X1 - Y1) * (X2 + Y2) + B - A) % p
+ G = B + a * A
+ H = D - C
+ if not H:
+ return self._double(X1, Y1, Z1, T1, p, a)
+ X3 = E * F % p
+ Y3 = G * H % p
+ T3 = E * H % p
+ Z3 = F * G % p
+
+ return X3, Y3, Z3, T3
+
+ def __add__(self, other):
+ """Add point to another."""
+ if other == INFINITY:
+ return self
+ if (
+ not isinstance(other, PointEdwards)
+ or self.__curve != other.__curve
+ ):
+ raise ValueError("The other point is on a different curve.")
+
+ p, a = self.__curve.p(), self.__curve.a()
+ X1, Y1, Z1, T1 = self.__coords
+ X2, Y2, Z2, T2 = other.__coords
+
+ X3, Y3, Z3, T3 = self._add(X1, Y1, Z1, T1, X2, Y2, Z2, T2, p, a)
+
+ if not X3 or not T3:
+ return INFINITY
+ return PointEdwards(self.__curve, X3, Y3, Z3, T3, self.__order)
+
+ def __radd__(self, other):
+ """Add other to self."""
+ return self + other
+
+ def _double(self, X1, Y1, Z1, T1, p, a):
+ """Double the point, assume sane parameters."""
+ # after "dbl-2008-hwcd"
+ # from https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html
+ # NOTE: there are more efficient formulas for Z1 == 1
+ A = X1 * X1 % p
+ B = Y1 * Y1 % p
+ C = 2 * Z1 * Z1 % p
+ D = a * A % p
+ E = ((X1 + Y1) * (X1 + Y1) - A - B) % p
+ G = D + B
+ F = G - C
+ H = D - B
+ X3 = E * F % p
+ Y3 = G * H % p
+ T3 = E * H % p
+ Z3 = F * G % p
+
+ return X3, Y3, Z3, T3
+
+ def double(self):
+ """Return point added to itself."""
+ X1, Y1, Z1, T1 = self.__coords
+
+ if not X1 or not T1:
+ return INFINITY
+
+ p, a = self.__curve.p(), self.__curve.a()
+
+ X3, Y3, Z3, T3 = self._double(X1, Y1, Z1, T1, p, a)
+
+ if not X3 or not T3:
+ return INFINITY
+ return PointEdwards(self.__curve, X3, Y3, Z3, T3, self.__order)
+
+ def __rmul__(self, other):
+ """Multiply point by an integer."""
+ return self * other
+
+ def _mul_precompute(self, other):
+ """Multiply point by integer with precomputation table."""
+ X3, Y3, Z3, T3, p, a = 0, 1, 1, 0, self.__curve.p(), self.__curve.a()
+ _add = self._add
+ for X2, Y2, T2 in self.__precompute:
+ rem = other % 4
+ if rem == 0 or rem == 2:
+ other //= 2
+ elif rem == 3:
+ other = (other + 1) // 2
+ X3, Y3, Z3, T3 = _add(X3, Y3, Z3, T3, -X2, Y2, 1, -T2, p, a)
+ else:
+ assert rem == 1
+ other = (other - 1) // 2
+ X3, Y3, Z3, T3 = _add(X3, Y3, Z3, T3, X2, Y2, 1, T2, p, a)
+
+ if not X3 or not T3:
+ return INFINITY
+
+ return PointEdwards(self.__curve, X3, Y3, Z3, T3, self.__order)
+
+ def __mul__(self, other):
+ """Multiply point by an integer."""
+ X2, Y2, Z2, T2 = self.__coords
+ if not X2 or not T2 or not other:
+ return INFINITY
+ if other == 1:
+ return self
+ if self.__order:
+ # order*2 as a "protection" for Minerva
+ other = other % (self.__order * 2)
+ if self._maybe_precompute():
+ return self._mul_precompute(other)
+
+ X3, Y3, Z3, T3 = 0, 1, 1, 0 # INFINITY in extended coordinates
+ p, a = self.__curve.p(), self.__curve.a()
+ _double = self._double
+ _add = self._add
+
+ for i in reversed(self._naf(other)):
+ X3, Y3, Z3, T3 = _double(X3, Y3, Z3, T3, p, a)
+ if i < 0:
+ X3, Y3, Z3, T3 = _add(X3, Y3, Z3, T3, -X2, Y2, Z2, -T2, p, a)
+ elif i > 0:
+ X3, Y3, Z3, T3 = _add(X3, Y3, Z3, T3, X2, Y2, Z2, T2, p, a)
+
+ if not X3 or not T3:
+ return INFINITY
+
+ return PointEdwards(self.__curve, X3, Y3, Z3, T3, self.__order)
+
+
 # This one point is the Point At Infinity for all purposes:
 INFINITY = Point(None, None, None)
diff --git a/frozen_deps/ecdsa/errors.py b/frozen_deps/ecdsa/errors.py
new file mode 100644
index 0000000..0184c05
--- /dev/null
+++ b/frozen_deps/ecdsa/errors.py
@@ -0,0 +1,4 @@
+class MalformedPointError(AssertionError):
+ """Raised in case the encoding of private or public key is malformed."""
+
+ pass
diff --git a/frozen_deps/ecdsa/keys.py b/frozen_deps/ecdsa/keys.py
index a6fc13f..2b7d316 100644
--- a/frozen_deps/ecdsa/keys.py
+++ b/frozen_deps/ecdsa/keys.py
@@ -1,80 +1,16 @@
 """
 Primary classes for performing signing and verification operations.
-
-.. glossary::
-
- raw encoding
- Conversion of public, private keys and signatures (which in
- mathematical sense are integers or pairs of integers) to strings of
- bytes that does not use any special tags or encoding rules.
- For any given curve, all keys of the same type or signatures will be
- encoded to byte strings of the same length. In more formal sense,
- the integers are encoded as big-endian, constant length byte strings,
- where the string length is determined by the curve order (e.g.
- for NIST256p the order is 256 bits long, so the private key will be 32
- bytes long while public key will be 64 bytes long). The encoding of a
- single integer is zero-padded on the left if the numerical value is
- low. In case of public keys and signatures, which are comprised of two
- integers, the integers are simply concatenated.
-
- uncompressed
- The most common formatting specified in PKIX standards. Specified in
- X9.62 and SEC1 standards. The only difference between it and
- :term:`raw encoding` is the prepending of a 0x04 byte. Thus an
- uncompressed NIST256p public key encoding will be 65 bytes long.
-
- compressed
- The public point representation that uses half of bytes of the
- :term:`uncompressed` encoding (rounded up). It uses the first byte of
- the encoding to specify the sign of the y coordinate and encodes the
- x coordinate as-is. The first byte of the encoding is equal to
- 0x02 or 0x03. Compressed encoding of NIST256p public key will be 33
- bytes long.
-
- hybrid
- A combination of :term:`uncompressed` and :term:`compressed` encodings.
- Both x and y coordinates are stored just as in :term:`compressed`
- encoding, but the first byte reflects the sign of the y coordinate. The
- first byte of the encoding will be equal to 0x06 or 0x7. Hybrid
- encoding of NIST256p public key will be 65 bytes long.
-
- PEM
- The acronym stands for Privacy Enhanced Email, but currently it is used
- primarily as the way to encode :term:`DER` objects into text that can
- be either easily copy-pasted or transferred over email.
- It uses headers like ``-----BEGIN <type of contents>-----`` and footers
- like ``-----END <type of contents>-----`` to separate multiple
- types of objects in the same file or the object from the surrounding
- comments. The actual object stored is base64 encoded.
-
- DER
- Distinguished Encoding Rules, the way to encode :term:`ASN.1` objects
- deterministically and uniquely into byte strings.
-
- ASN.1
- 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
 from hashlib import sha1
+import os
 from six import PY2, b
-from . import ecdsa
+from . import ecdsa, eddsa
 from . import der
 from . import rfc6979
 from . import ellipticcurve
-from .curves import NIST192p, find_curve
-from .numbertheory import square_root_mod_prime, SquareRootError
+from .curves import NIST192p, Curve, Ed25519, Ed448
 from .ecdsa import RSZeroError
 from .util import string_to_number, number_to_string, randrange
 from .util import sigencode_string, sigdecode_string, bit_length
@@ -86,6 +22,8 @@ from .util import (
 MalformedSignature,
 )
 from ._compat import normalise_bytes
+from .errors import MalformedPointError
+from .ellipticcurve import PointJacobi, CurveEdTw
 
 
 __all__ = [
@@ -118,23 +56,49 @@ class BadDigestError(Exception):
 pass
 
 
-class MalformedPointError(AssertionError):
- """Raised in case the encoding of private or public key is malformed."""
+def _truncate_and_convert_digest(digest, curve, allow_truncate):
+ """Truncates and converts digest to an integer."""
+ if not allow_truncate:
+ if len(digest) > curve.baselen:
+ raise BadDigestError(
+ "this curve ({0}) is too short "
+ "for the length of your digest ({1})".format(
+ curve.name, 8 * len(digest)
+ )
+ )
+ else:
+ digest = digest[: curve.baselen]
+ number = string_to_number(digest)
+ if allow_truncate:
+ max_length = bit_length(curve.order)
+ # we don't use bit_length(number) as that truncates leading zeros
+ length = len(digest) * 8
+
+ # See NIST FIPS 186-4:
+ #
+ # When the length of the output of the hash function is greater
+ # than N (i.e., the bit length of q), then the leftmost N bits of
+ # the hash function output block shall be used in any calculation
+ # using the hash function output during the generation or
+ # verification of a digital signature.
+ #
+ # as such, we need to shift-out the low-order bits:
+ number >>= max(0, length - max_length)
 
- pass
+ return number
 
 
 class VerifyingKey(object):
 """
 Class for handling keys that can verify signatures (public keys).
 
- :ivar ecdsa.curves.Curve curve: The Curve over which all the cryptographic
- operations will take place
+ :ivar `~ecdsa.curves.Curve` ~.curve: The Curve over which all the
+ cryptographic operations will take place
 :ivar default_hashfunc: the function that will be used for hashing the
 data. Should implement the same API as hashlib.sha1
 :vartype default_hashfunc: callable
 :ivar pubkey: the actual public key
- :vartype pubkey: ecdsa.ecdsa.Public_key
+ :vartype pubkey: ~ecdsa.ecdsa.Public_key
 """
 
 def __init__(self, _error__please_use_generate=None):
@@ -149,8 +113,12 @@ class VerifyingKey(object):
 
 def __repr__(self):
 pub_key = self.to_string("compressed")
+ if self.default_hashfunc:
+ hash_name = self.default_hashfunc().name
+ else:
+ hash_name = "None"
 return "VerifyingKey.from_string({0!r}, {1!r}, {2})".format(
- pub_key, self.curve, self.default_hashfunc().name
+ pub_key, self.curve, hash_name
 )
 
 def __eq__(self, other):
@@ -159,6 +127,10 @@ class VerifyingKey(object):
 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
@@ -169,25 +141,27 @@ class VerifyingKey(object):
 This is a low-level method, generally you will not want to use it.
 
 :param point: The point to wrap around, the actual public key
- :type point: ecdsa.ellipticcurve.Point
+ :type point: ~ecdsa.ellipticcurve.AbstractPoint
 :param curve: The curve on which the point needs to reside, defaults
 to NIST192p
- :type curve: ecdsa.curves.Curve
+ :type curve: ~ecdsa.curves.Curve
 :param hashfunc: The default hash function that will be used for
 verification, needs to implement the same interface
- as hashlib.sha1
+ as :py:class:`hashlib.sha1`
 :type hashfunc: callable
- :type bool validate_point: whether to check if the point lies on curve
+ :type bool validate_point: whether to check if the point lays on curve
 should always be used if the public point is not a result
 of our own calculation
 
- :raises MalformedPointError: if the public point does not lie on the
+ :raises MalformedPointError: if the public point does not lay on the
 curve
 
 :return: Initialised VerifyingKey object
 :rtype: VerifyingKey
 """
 self = cls(_error__please_use_generate=True)
+ if isinstance(curve.curve, CurveEdTw):
+ raise ValueError("Method incompatible with Edwards curves")
 if not isinstance(point, ellipticcurve.PointJacobi):
 point = ellipticcurve.PointJacobi.from_affine(point)
 self.curve = curve
@@ -197,7 +171,7 @@ class VerifyingKey(object):
 curve.generator, point, validate_point
 )
 except ecdsa.InvalidPointError:
- raise MalformedPointError("Point does not lie on the curve")
+ raise MalformedPointError("Point does not lay on the curve")
 self.pubkey.order = curve.order
 return self
 
@@ -220,90 +194,45 @@ class VerifyingKey(object):
 (if set to False) or if it should be delayed to the time of first
 use (when set to True)
 """
- self.pubkey.point = ellipticcurve.PointJacobi.from_affine(
- self.pubkey.point, True
- )
+ if isinstance(self.curve.curve, CurveEdTw):
+ pt = self.pubkey.point
+ self.pubkey.point = ellipticcurve.PointEdwards(
+ pt.curve(),
+ pt.x(),
+ pt.y(),
+ 1,
+ pt.x() * pt.y(),
+ self.curve.order,
+ generator=True,
+ )
+ else:
+ self.pubkey.point = ellipticcurve.PointJacobi.from_affine(
+ self.pubkey.point, True
+ )
 # as precomputation in now delayed to the time of first use of the
 # point and we were asked specifically to precompute now, make
 # sure the precomputation is performed now to preserve the behaviour
 if not lazy:
 self.pubkey.point * 2
 
- @staticmethod
- def _from_raw_encoding(string, curve):
- """
- Decode public point from :term:`raw encoding`.
-
- :term:`raw encoding` is the same as the :term:`uncompressed` encoding,
- but without the 0x04 byte at the beginning.
- """
- order = curve.order
- # real assert, from_string() should not call us with different length
- assert len(string) == curve.verifying_key_length
- xs = string[: curve.baselen]
- ys = string[curve.baselen :]
- if len(xs) != curve.baselen:
- raise MalformedPointError("Unexpected length of encoded x")
- if len(ys) != curve.baselen:
- raise MalformedPointError("Unexpected length of encoded y")
- x = string_to_number(xs)
- y = string_to_number(ys)
-
- return ellipticcurve.PointJacobi(curve.curve, x, y, 1, order)
-
- @staticmethod
- def _from_compressed(string, curve):
- """Decode public point from compressed encoding."""
- if string[:1] not in (b("\x02"), b("\x03")):
- raise MalformedPointError("Malformed compressed point encoding")
-
- is_even = string[:1] == b("\x02")
- x = string_to_number(string[1:])
- order = curve.order
- p = curve.curve.p()
- alpha = (pow(x, 3, p) + (curve.curve.a() * x) + curve.curve.b()) % p
- try:
- beta = square_root_mod_prime(alpha, p)
- except SquareRootError as e:
- raise MalformedPointError(
- "Encoding does not correspond to a point on curve", e
- )
- if is_even == bool(beta & 1):
- y = p - beta
- else:
- y = beta
- return ellipticcurve.PointJacobi(curve.curve, x, y, 1, order)
-
- @classmethod
- def _from_hybrid(cls, string, curve, validate_point):
- """Decode public point from hybrid encoding."""
- # real assert, from_string() should not call us with different types
- assert string[:1] in (b("\x06"), b("\x07"))
-
- # primarily use the uncompressed as it's easiest to handle
- point = cls._from_raw_encoding(string[1:], curve)
-
- # but validate if it's self-consistent if we're asked to do that
- if validate_point and (
- point.y() & 1
- and string[:1] != b("\x07")
- or (not point.y() & 1)
- and string[:1] != b("\x06")
- ):
- raise MalformedPointError("Inconsistent hybrid point encoding")
-
- return point
-
 @classmethod
 def from_string(
- cls, string, curve=NIST192p, hashfunc=sha1, validate_point=True
+ cls,
+ string,
+ curve=NIST192p,
+ hashfunc=sha1,
+ validate_point=True,
+ valid_encodings=None,
 ):
 """
 Initialise the object from byte encoding of public key.
 
 The method does accept and automatically detect the type of point
 encoding used. It supports the :term:`raw encoding`,
- :term:`uncompressed`, :term:`compressed` and :term:`hybrid` encodings.
+ :term:`uncompressed`, :term:`compressed`, and :term:`hybrid` encodings.
+ It also works with the native encoding of Ed25519 and Ed448 public
+ keys (technically those are compressed, but encoded differently than
+ in other signature systems).
 
 Note, while the method is named "from_string" it's a misnomer from
 Python 2 days when there were no binary strings. In Python 3 the
@@ -311,46 +240,54 @@ class VerifyingKey(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 curve: the curve on which the public key is expected to lay
+ :type curve: ~ecdsa.curves.Curve
 :param hashfunc: The default hash function that will be used for
- verification, needs to implement the same interface as hashlib.sha1
+ verification, needs to implement the same interface as
+ hashlib.sha1. Ignored for EdDSA.
 :type hashfunc: callable
- :param validate_point: whether to verify that the point lies on the
- provided curve or not, defaults to True
+ :param validate_point: whether to verify that the point lays on the
+ provided curve or not, defaults to True. Ignored for EdDSA.
 :type validate_point: bool
-
- :raises MalformedPointError: if the public point does not lie on the
+ :param valid_encodings: list of acceptable point encoding formats,
+ supported ones are: :term:`uncompressed`, :term:`compressed`,
+ :term:`hybrid`, and :term:`raw encoding` (specified with ``raw``
+ name). All formats by default (specified with ``None``).
+ Ignored for EdDSA.
+ :type valid_encodings: :term:`set-like object`
+
+ :raises MalformedPointError: if the public point does not lay on the
 curve or the encoding is invalid
 
 :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)
- elif sig_len == curve.verifying_key_length + 1:
- if string[:1] in (b("\x06"), b("\x07")):
- point = cls._from_hybrid(string, curve, validate_point)
- elif string[:1] == b("\x04"):
- point = cls._from_raw_encoding(string[1:], curve)
- else:
- raise MalformedPointError(
- "Invalid X9.62 encoding of the public point"
- )
- elif sig_len == curve.baselen + 1:
- point = cls._from_compressed(string, curve)
- else:
- raise MalformedPointError(
- "Length of string does not match lengths of "
- "any of the supported encodings of {0} "
- "curve.".format(curve.name)
- )
+ if isinstance(curve.curve, CurveEdTw):
+ self = cls(_error__please_use_generate=True)
+ self.curve = curve
+ self.default_hashfunc = None # ignored for EdDSA
+ try:
+ self.pubkey = eddsa.PublicKey(curve.generator, string)
+ except ValueError:
+ raise MalformedPointError("Malformed point for the curve")
+ return self
+
+ point = PointJacobi.from_bytes(
+ curve.curve,
+ string,
+ validate_encoding=validate_point,
+ valid_encodings=valid_encodings,
+ )
 return cls.from_public_point(point, curve, hashfunc, validate_point)
 
 @classmethod
- def from_pem(cls, string, hashfunc=sha1):
+ def from_pem(
+ cls,
+ string,
+ hashfunc=sha1,
+ valid_encodings=None,
+ valid_curve_encodings=None,
+ ):
 """
 Initialise from public key stored in :term:`PEM` format.
 
@@ -359,19 +296,40 @@ class VerifyingKey(object):
 See the :func:`~VerifyingKey.from_der()` method for details of the
 format supported.
 
- Note: only a single PEM object encoding is supported in provided
+ Note: only a single PEM object decoding is supported in provided
 string.
 
 :param string: text with PEM-encoded public ECDSA key
 :type string: str
+ :param valid_encodings: list of allowed point encodings.
+ By default :term:`uncompressed`, :term:`compressed`, and
+ :term:`hybrid`. To read malformed files, include
+ :term:`raw encoding` with ``raw`` in the list.
+ :type valid_encodings: :term:`set-like object`
+ :param valid_curve_encodings: list of allowed encoding formats
+ for curve parameters. By default (``None``) all are supported:
+ ``named_curve`` and ``explicit``.
+ :type valid_curve_encodings: :term:`set-like object`
+
 
 :return: Initialised VerifyingKey object
 :rtype: VerifyingKey
 """
- return cls.from_der(der.unpem(string), hashfunc=hashfunc)
+ return cls.from_der(
+ der.unpem(string),
+ hashfunc=hashfunc,
+ valid_encodings=valid_encodings,
+ valid_curve_encodings=valid_curve_encodings,
+ )
 
 @classmethod
- def from_der(cls, string, hashfunc=sha1):
+ def from_der(
+ cls,
+ string,
+ hashfunc=sha1,
+ valid_encodings=None,
+ valid_curve_encodings=None,
+ ):
 """
 Initialise the key stored in :term:`DER` format.
 
@@ -396,10 +354,21 @@ class VerifyingKey(object):
 
 :param string: binary string with the DER encoding of public ECDSA key
 :type string: bytes-like object
+ :param valid_encodings: list of allowed point encodings.
+ By default :term:`uncompressed`, :term:`compressed`, and
+ :term:`hybrid`. To read malformed files, include
+ :term:`raw encoding` with ``raw`` in the list.
+ :type valid_encodings: :term:`set-like object`
+ :param valid_curve_encodings: list of allowed encoding formats
+ for curve parameters. By default (``None``) all are supported:
+ ``named_curve`` and ``explicit``.
+ :type valid_curve_encodings: :term:`set-like object`
 
 :return: Initialised VerifyingKey object
 :rtype: VerifyingKey
 """
+ if valid_encodings is None:
+ valid_encodings = set(["uncompressed", "compressed", "hybrid"])
 string = normalise_bytes(string)
 # [[oid_ecPublicKey,oid_curve], point_str_bitstring]
 s1, empty = der.remove_sequence(string)
@@ -410,18 +379,22 @@ class VerifyingKey(object):
 s2, point_str_bitstring = der.remove_sequence(s1)
 # s2 = oid_ecPublicKey,oid_curve
 oid_pk, rest = der.remove_object(s2)
- oid_curve, empty = der.remove_object(rest)
- if empty != b"":
- raise der.UnexpectedDER(
- "trailing junk after DER pubkey objects: %s"
- % binascii.hexlify(empty)
- )
+ if oid_pk in (Ed25519.oid, Ed448.oid):
+ if oid_pk == Ed25519.oid:
+ curve = Ed25519
+ else:
+ assert oid_pk == Ed448.oid
+ curve = Ed448
+ point_str, empty = der.remove_bitstring(point_str_bitstring, 0)
+ if empty:
+ raise der.UnexpectedDER("trailing junk after public key")
+ return cls.from_string(point_str, curve, None)
 if not oid_pk == oid_ecPublicKey:
 raise der.UnexpectedDER(
 "Unexpected object identifier in DER "
 "encoding: {0!r}".format(oid_pk)
 )
- curve = find_curve(oid_curve)
+ curve = Curve.from_der(rest, valid_curve_encodings)
 point_str, empty = der.remove_bitstring(point_str_bitstring, 0)
 if empty != b"":
 raise der.UnexpectedDER(
@@ -431,11 +404,22 @@ class VerifyingKey(object):
 # raw encoding of point is invalid in DER files
 if len(point_str) == curve.verifying_key_length:
 raise der.UnexpectedDER("Malformed encoding of public point")
- return cls.from_string(point_str, curve, hashfunc=hashfunc)
+ return cls.from_string(
+ point_str,
+ curve,
+ hashfunc=hashfunc,
+ valid_encodings=valid_encodings,
+ )
 
 @classmethod
 def from_public_key_recovery(
- cls, signature, data, curve, hashfunc=sha1, sigdecode=sigdecode_string
+ cls,
+ signature,
+ data,
+ curve,
+ hashfunc=sha1,
+ sigdecode=sigdecode_string,
+ allow_truncate=True,
 ):
 """
 Return keys that can be used as verifiers of the provided signature.
@@ -448,7 +432,7 @@ class VerifyingKey(object):
 :param data: the data to be hashed for signature verification
 :type data: bytes-like object
 :param curve: the curve over which the signature was performed
- :type curve: ecdsa.curves.Curve
+ :type curve: ~ecdsa.curves.Curve
 :param hashfunc: The default hash function that will be used for
 verification, needs to implement the same interface as hashlib.sha1
 :type hashfunc: callable
@@ -458,15 +442,25 @@ class VerifyingKey(object):
 a tuple with two integers, "r" as the first one and "s" as the
 second one. See :func:`ecdsa.util.sigdecode_string` and
 :func:`ecdsa.util.sigdecode_der` for examples.
+ :param bool allow_truncate: if True, the provided hashfunc can generate
+ values larger than the bit size of the order of the curve, the
+ extra bits (at the end of the digest) will be truncated.
 :type sigdecode: callable
 
 :return: Initialised VerifyingKey objects
 :rtype: list of VerifyingKey
 """
+ if isinstance(curve.curve, CurveEdTw):
+ raise ValueError("Method unsupported for Edwards curves")
 data = normalise_bytes(data)
 digest = hashfunc(data).digest()
 return cls.from_public_key_recovery_with_digest(
- signature, digest, curve, hashfunc=hashfunc, sigdecode=sigdecode
+ signature,
+ digest,
+ curve,
+ hashfunc=hashfunc,
+ sigdecode=sigdecode,
+ allow_truncate=allow_truncate,
 )
 
 @classmethod
@@ -477,6 +471,7 @@ class VerifyingKey(object):
 curve,
 hashfunc=sha1,
 sigdecode=sigdecode_string,
+ allow_truncate=False,
 ):
 """
 Return keys that can be used as verifiers of the provided signature.
@@ -489,7 +484,7 @@ class VerifyingKey(object):
 :param digest: the hash value of the message signed by the signature
 :type digest: bytes-like object
 :param curve: the curve over which the signature was performed
- :type curve: ecdsa.curves.Curve
+ :type curve: ~ecdsa.curves.Curve
 :param hashfunc: The default hash function that will be used for
 verification, needs to implement the same interface as hashlib.sha1
 :type hashfunc: callable
@@ -500,17 +495,24 @@ class VerifyingKey(object):
 second one. See :func:`ecdsa.util.sigdecode_string` and
 :func:`ecdsa.util.sigdecode_der` for examples.
 :type sigdecode: callable
-
+ :param bool allow_truncate: if True, the provided hashfunc can generate
+ values larger than the bit size of the order of the curve (and
+ the length of provided `digest`), the extra bits (at the end of the
+ digest) will be truncated.
 
 :return: Initialised VerifyingKey object
 :rtype: VerifyingKey
 """
+ if isinstance(curve.curve, CurveEdTw):
+ raise ValueError("Method unsupported for Edwards curves")
 generator = curve.generator
 r, s = sigdecode(signature, generator.order())
 sig = ecdsa.Signature(r, s)
 
 digest = normalise_bytes(digest)
- digest_as_number = string_to_number(digest)
+ digest_as_number = _truncate_and_convert_digest(
+ digest, curve, allow_truncate
+ )
 pks = sig.recover_public_keys(digest_as_number, generator)
 
 # Transforms the ecdsa.Public_key object into a VerifyingKey
@@ -519,30 +521,6 @@ class VerifyingKey(object):
 ]
 return verifying_keys
 
- def _raw_encode(self):
- """Convert the public key to the :term:`raw encoding`."""
- order = self.pubkey.order
- x_str = number_to_string(self.pubkey.point.x(), order)
- y_str = number_to_string(self.pubkey.point.y(), order)
- return x_str + y_str
-
- def _compressed_encode(self):
- """Encode the public point into the compressed form."""
- order = self.pubkey.order
- x_str = number_to_string(self.pubkey.point.x(), order)
- if self.pubkey.point.y() & 1:
- return b("\x03") + x_str
- else:
- return b("\x02") + x_str
-
- def _hybrid_encode(self):
- """Encode the public point into the hybrid form."""
- raw_enc = self._raw_encode()
- if self.pubkey.point.y() & 1:
- return b("\x07") + raw_enc
- else:
- return b("\x06") + raw_enc
-
 def to_string(self, encoding="raw"):
 """
 Convert the public key to a byte string.
@@ -564,16 +542,11 @@ class VerifyingKey(object):
 :rtype: bytes
 """
 assert encoding in ("raw", "uncompressed", "compressed", "hybrid")
- if encoding == "raw":
- return self._raw_encode()
- elif encoding == "uncompressed":
- return b("\x04") + self._raw_encode()
- elif encoding == "hybrid":
- return self._hybrid_encode()
- else:
- return self._compressed_encode()
+ return self.pubkey.point.to_bytes(encoding)
 
- def to_pem(self, point_encoding="uncompressed"):
+ def to_pem(
+ self, point_encoding="uncompressed", curve_parameters_encoding=None
+ ):
 """
 Convert the public key to the :term:`PEM` format.
 
@@ -587,6 +560,9 @@ class VerifyingKey(object):
 of public keys. "uncompressed" is most portable, "compressed" is
 smallest. "hybrid" is uncommon and unsupported by most
 implementations, it is as big as "uncompressed".
+ :param str curve_parameters_encoding: the encoding for curve parameters
+ to use, by default tries to use ``named_curve`` encoding,
+ if that is not possible, falls back to ``explicit`` encoding.
 
 :return: portable encoding of the public key
 :rtype: bytes
@@ -594,9 +570,14 @@ class VerifyingKey(object):
 .. warning:: The PEM is encoded to US-ASCII, it needs to be
 re-encoded if the system is incompatible (e.g. uses UTF-16)
 """
- return der.topem(self.to_der(point_encoding), "PUBLIC KEY")
+ return der.topem(
+ self.to_der(point_encoding, curve_parameters_encoding),
+ "PUBLIC KEY",
+ )
 
- def to_der(self, point_encoding="uncompressed"):
+ def to_der(
+ self, point_encoding="uncompressed", curve_parameters_encoding=None
+ ):
 """
 Convert the public key to the :term:`DER` format.
 
@@ -608,6 +589,9 @@ class VerifyingKey(object):
 of public keys. "uncompressed" is most portable, "compressed" is
 smallest. "hybrid" is uncommon and unsupported by most
 implementations, it is as big as "uncompressed".
+ :param str curve_parameters_encoding: the encoding for curve parameters
+ to use, by default tries to use ``named_curve`` encoding,
+ if that is not possible, falls back to ``explicit`` encoding.
 
 :return: DER encoding of the public key
 :rtype: bytes
@@ -615,9 +599,15 @@ class VerifyingKey(object):
 if point_encoding == "raw":
 raise ValueError("raw point_encoding not allowed in DER")
 point_str = self.to_string(point_encoding)
+ if isinstance(self.curve.curve, CurveEdTw):
+ return der.encode_sequence(
+ der.encode_sequence(der.encode_oid(*self.curve.oid)),
+ der.encode_bitstring(bytes(point_str), 0),
+ )
 return der.encode_sequence(
 der.encode_sequence(
- encoded_oid_ecPublicKey, self.curve.encoded_oid
+ encoded_oid_ecPublicKey,
+ self.curve.to_der(curve_parameters_encoding, point_encoding),
 ),
 # 0 is the number of unused bits in the
 # bit string
@@ -643,10 +633,10 @@ class VerifyingKey(object):
 as the `sigdecode` parameter.
 
 :param signature: encoding of the signature
- :type signature: sigdecode method dependant
+ :type signature: sigdecode method dependent
 :param data: data signed by the `signature`, will be hashed using
 `hashfunc`, if specified, or default hash function
- :type data: bytes like object
+ :type data: :term:`bytes-like object`
 :param hashfunc: The default hash function that will be used for
 verification, needs to implement the same interface as hashlib.sha1
 :type hashfunc: callable
@@ -671,6 +661,12 @@ class VerifyingKey(object):
 # signature doesn't have to be a bytes-like-object so don't normalise
 # it, the decoders will do that
 data = normalise_bytes(data)
+ if isinstance(self.curve.curve, CurveEdTw):
+ signature = normalise_bytes(signature)
+ try:
+ return self.pubkey.verify(data, signature)
+ except (ValueError, MalformedPointError) as e:
+ raise BadSignatureError("Signature verification failed", e)
 
 hashfunc = hashfunc or self.default_hashfunc
 digest = hashfunc(data).digest()
@@ -692,9 +688,9 @@ class VerifyingKey(object):
 as the `sigdecode` parameter.
 
 :param signature: encoding of the signature
- :type signature: sigdecode method dependant
+ :type signature: sigdecode method dependent
 :param digest: raw hash value that the signature authenticates.
- :type digest: bytes like object
+ :type digest: :term:`bytes-like object`
 :param sigdecode: Callable to define the way the signature needs to
 be decoded to an object, needs to handle `signature` as the
 first parameter, the curve order (an int) as the second and return
@@ -717,27 +713,11 @@ class VerifyingKey(object):
 # signature doesn't have to be a bytes-like-object so don't normalise
 # it, the decoders will do that
 digest = normalise_bytes(digest)
- if not allow_truncate and len(digest) > self.curve.baselen:
- raise BadDigestError(
- "this curve (%s) is too short "
- "for your digest (%d)" % (self.curve.name, 8 * len(digest))
- )
- number = string_to_number(digest)
- if allow_truncate:
- max_length = bit_length(self.curve.order)
- # we don't use bit_length(number) as that truncates leading zeros
- length = len(digest) * 8
-
- # See NIST FIPS 186-4:
- #
- # When the length of the output of the hash function is greater
- # than N (i.e., the bit length of q), then the leftmost N bits of
- # the hash function output block shall be used in any calculation
- # using the hash function output during the generation or
- # verification of a digital signature.
- #
- # as such, we need to shift-out the low-order bits:
- number >>= max(0, length - max_length)
+ number = _truncate_and_convert_digest(
+ digest,
+ self.curve,
+ allow_truncate,
+ )
 
 try:
 r, s = sigdecode(signature, self.pubkey.order)
@@ -753,14 +733,14 @@ class SigningKey(object):
 """
 Class for handling keys that can create signatures (private keys).
 
- :ivar ecdsa.curves.Curve curve: The Curve over which all the cryptographic
- operations will take place
+ :ivar `~ecdsa.curves.Curve` curve: The Curve over which all the
+ cryptographic operations will take place
 :ivar default_hashfunc: the function that will be used for hashing the
- data. Should implement the same API as hashlib.sha1
+ data. Should implement the same API as :py:class:`hashlib.sha1`
 :ivar int baselen: the length of a :term:`raw encoding` of private key
- :ivar ecdsa.keys.VerifyingKey verifying_key: the public key
+ :ivar `~ecdsa.keys.VerifyingKey` verifying_key: the public key
 associated with this private key
- :ivar ecdsa.ecdsa.Private_key privkey: the actual private key
+ :ivar `~ecdsa.ecdsa.Private_key` privkey: the actual private key
 """
 
 def __init__(self, _error__please_use_generate=None):
@@ -783,6 +763,37 @@ class SigningKey(object):
 )
 return NotImplemented
 
+ def __ne__(self, other):
+ """Return False if the points are identical, True otherwise."""
+ return not self == other
+
+ @classmethod
+ def _twisted_edwards_keygen(cls, curve, entropy):
+ """Generate a private key on a Twisted Edwards curve."""
+ if not entropy:
+ entropy = os.urandom
+ random = entropy(curve.baselen)
+ private_key = eddsa.PrivateKey(curve.generator, random)
+ public_key = private_key.public_key()
+
+ verifying_key = VerifyingKey.from_string(
+ public_key.public_key(), curve
+ )
+
+ self = cls(_error__please_use_generate=True)
+ self.curve = curve
+ self.default_hashfunc = None
+ self.baselen = curve.baselen
+ self.privkey = private_key
+ self.verifying_key = verifying_key
+ return self
+
+ @classmethod
+ def _weierstrass_keygen(cls, curve, entropy, hashfunc):
+ """Generate a private key on a Weierstrass curve."""
+ secexp = randrange(curve.order, entropy)
+ return cls.from_secret_exponent(secexp, curve, hashfunc)
+
 @classmethod
 def generate(cls, curve=NIST192p, entropy=None, hashfunc=sha1):
 """
@@ -790,7 +801,7 @@ class SigningKey(object):
 
 :param curve: The curve on which the point needs to reside, defaults
 to NIST192p
- :type curve: ecdsa.curves.Curve
+ :type curve: ~ecdsa.curves.Curve
 :param entropy: Source of randomness for generating the private keys,
 should provide cryptographically secure random numbers if the keys
 need to be secure. Uses os.urandom() by default.
@@ -803,8 +814,9 @@ class SigningKey(object):
 :return: Initialised SigningKey object
 :rtype: SigningKey
 """
- secexp = randrange(curve.order, entropy)
- return cls.from_secret_exponent(secexp, curve, hashfunc)
+ if isinstance(curve.curve, CurveEdTw):
+ return cls._twisted_edwards_keygen(curve, entropy)
+ return cls._weierstrass_keygen(curve, entropy, hashfunc)
 
 @classmethod
 def from_secret_exponent(cls, secexp, curve=NIST192p, hashfunc=sha1):
@@ -817,7 +829,7 @@ class SigningKey(object):
 :param int secexp: secret multiplier (the actual private key in ECDSA).
 Needs to be an integer between 1 and the curve order.
 :param curve: The curve on which the point needs to reside
- :type curve: ecdsa.curves.Curve
+ :type curve: ~ecdsa.curves.Curve
 :param hashfunc: The default hash function that will be used for
 signing, needs to implement the same interface
 as hashlib.sha1
@@ -831,6 +843,11 @@ class SigningKey(object):
 :return: Initialised SigningKey object
 :rtype: SigningKey
 """
+ if isinstance(curve.curve, CurveEdTw):
+ raise ValueError(
+ "Edwards keys don't support setting the secret scalar "
+ "(exponent) directly"
+ )
 self = cls(_error__please_use_generate=True)
 self.curve = curve
 self.default_hashfunc = hashfunc
@@ -862,9 +879,9 @@ class SigningKey(object):
 In Python 3, the expected type is `bytes`.
 
 :param string: the raw encoding of the private key
- :type string: bytes like object
+ :type string: :term:`bytes-like object`
 :param curve: The curve on which the point needs to reside
- :type curve: ecdsa.curves.Curve
+ :type curve: ~ecdsa.curves.Curve
 :param hashfunc: The default hash function that will be used for
 signing, needs to implement the same interface
 as hashlib.sha1
@@ -879,16 +896,27 @@ class SigningKey(object):
 :rtype: SigningKey
 """
 string = normalise_bytes(string)
+
 if len(string) != curve.baselen:
 raise MalformedPointError(
 "Invalid length of private key, received {0}, "
 "expected {1}".format(len(string), curve.baselen)
 )
+ if isinstance(curve.curve, CurveEdTw):
+ self = cls(_error__please_use_generate=True)
+ self.curve = curve
+ self.default_hashfunc = None # Ignored for EdDSA
+ self.baselen = curve.baselen
+ self.privkey = eddsa.PrivateKey(curve.generator, string)
+ self.verifying_key = VerifyingKey.from_string(
+ self.privkey.public_key().public_key(), curve
+ )
+ return self
 secexp = string_to_number(string)
 return cls.from_secret_exponent(secexp, curve, hashfunc)
 
 @classmethod
- def from_pem(cls, string, hashfunc=sha1):
+ def from_pem(cls, string, hashfunc=sha1, valid_curve_encodings=None):
 """
 Initialise from key stored in :term:`PEM` format.
 
@@ -908,6 +936,11 @@ class SigningKey(object):
 
 :param string: text with PEM-encoded private ECDSA key
 :type string: str
+ :param valid_curve_encodings: list of allowed encoding formats
+ for curve parameters. By default (``None``) all are supported:
+ ``named_curve`` and ``explicit``.
+ :type valid_curve_encodings: :term:`set-like object`
+
 
 :raises MalformedPointError: if the length of encoding doesn't match
 the provided curve or the encoded values is too large
@@ -918,7 +951,7 @@ class SigningKey(object):
 :return: Initialised SigningKey object
 :rtype: SigningKey
 """
- if not PY2 and isinstance(string, str):
+ if not PY2 and isinstance(string, str): # pragma: no branch
 string = string.encode()
 
 # The privkey pem may have multiple sections, commonly it also has
@@ -928,10 +961,14 @@ class SigningKey(object):
 if private_key_index == -1:
 private_key_index = string.index(b"-----BEGIN PRIVATE KEY-----")
 
- return cls.from_der(der.unpem(string[private_key_index:]), hashfunc)
+ return cls.from_der(
+ der.unpem(string[private_key_index:]),
+ hashfunc,
+ valid_curve_encodings,
+ )
 
 @classmethod
- def from_der(cls, string, hashfunc=sha1):
+ def from_der(cls, string, hashfunc=sha1, valid_curve_encodings=None):
 """
 Initialise from key stored in :term:`DER` format.
 
@@ -952,14 +989,14 @@ class SigningKey(object):
 `publicKey` field is ignored completely (errors, if any, in it will
 be undetected).
 
- The only format supported for the `parameters` field is the named
- curve method. Explicit encoding of curve parameters is not supported.
+ Two formats are supported for the `parameters` field: the named
+ curve and the explicit encoding of curve parameters.
 In the legacy ssleay format, this implementation requires the optional
 `parameters` field to get the curve name. In PKCS #8 format, the curve
 is part of the PrivateKeyAlgorithmIdentifier.
 
 The PKCS #8 format includes an ECPrivateKey object as the `privateKey`
- field within a larger structure:
+ field within a larger structure::
 
 OneAsymmetricKey ::= SEQUENCE {
 version Version,
@@ -975,7 +1012,12 @@ class SigningKey(object):
 in them will not be detected.
 
 :param string: binary string with DER-encoded private ECDSA key
- :type string: bytes like object
+ :type string: :term:`bytes-like object`
+ :param valid_curve_encodings: list of allowed encoding formats
+ for curve parameters. By default (``None``) all are supported:
+ ``named_curve`` and ``explicit``.
+ Ignored for EdDSA.
+ :type valid_curve_encodings: :term:`set-like object`
 
 :raises MalformedPointError: if the length of encoding doesn't match
 the provided curve or the encoded values is too large
@@ -1010,13 +1052,44 @@ class SigningKey(object):
 
 sequence, s = der.remove_sequence(s)
 algorithm_oid, algorithm_identifier = der.remove_object(sequence)
- curve_oid, empty = der.remove_object(algorithm_identifier)
- curve = find_curve(curve_oid)
+
+ if algorithm_oid in (Ed25519.oid, Ed448.oid):
+ if algorithm_identifier:
+ raise der.UnexpectedDER(
+ "Non NULL parameters for a EdDSA key"
+ )
+ key_str_der, s = der.remove_octet_string(s)
+
+ # As RFC5958 describe, there are may be optional Attributes
+ # and Publickey. Don't raise error if something after
+ # Privatekey
+
+ # TODO parse attributes or validate publickey
+ # if s:
+ # raise der.UnexpectedDER(
+ # "trailing junk inside the privateKey"
+ # )
+ key_str, s = der.remove_octet_string(key_str_der)
+ if s:
+ raise der.UnexpectedDER(
+ "trailing junk after the encoded private key"
+ )
+
+ if algorithm_oid == Ed25519.oid:
+ curve = Ed25519
+ else:
+ assert algorithm_oid == Ed448.oid
+ curve = Ed448
+
+ return cls.from_string(key_str, curve, None)
 
 if algorithm_oid not in (oid_ecPublicKey, oid_ecDH, oid_ecMQV):
 raise der.UnexpectedDER(
 "unexpected algorithm identifier '%s'" % (algorithm_oid,)
 )
+
+ curve = Curve.from_der(algorithm_identifier, valid_curve_encodings)
+
 if empty != b"":
 raise der.UnexpectedDER(
 "unexpected data after algorithm identifier: %s"
@@ -1053,13 +1126,7 @@ class SigningKey(object):
 raise der.UnexpectedDER(
 "expected tag 0 in DER privkey, got %d" % tag
 )
- curve_oid, empty = der.remove_object(curve_oid_str)
- if empty != b(""):
- raise der.UnexpectedDER(
- "trailing junk after DER privkey "
- "curve_oid: %s" % binascii.hexlify(empty)
- )
- curve = find_curve(curve_oid)
+ curve = Curve.from_der(curve_oid_str, valid_curve_encodings)
 
 # we don't actually care about the following fields
 #
@@ -1091,11 +1158,18 @@ class SigningKey(object):
 :return: raw encoding of private key
 :rtype: bytes
 """
+ if isinstance(self.curve.curve, CurveEdTw):
+ return bytes(self.privkey.private_key)
 secexp = self.privkey.secret_multiplier
 s = number_to_string(secexp, self.privkey.order)
 return s
 
- def to_pem(self, point_encoding="uncompressed", format="ssleay"):
+ def to_pem(
+ self,
+ point_encoding="uncompressed",
+ format="ssleay",
+ curve_parameters_encoding=None,
+ ):
 """
 Convert the private key to the :term:`PEM` format.
 
@@ -1109,6 +1183,11 @@ class SigningKey(object):
 
 :param str point_encoding: format to use for encoding public point
 :param str format: either ``ssleay`` (default) or ``pkcs8``
+ :param str curve_parameters_encoding: format of encoded curve
+ parameters, default depends on the curve, if the curve has
+ an associated OID, ``named_curve`` format will be used,
+ if no OID is associated with the curve, the fallback of
+ ``explicit`` parameters will be used.
 
 :return: PEM encoded private key
 :rtype: bytes
@@ -1119,9 +1198,26 @@ class SigningKey(object):
 # TODO: "BEGIN ECPARAMETERS"
 assert format in ("ssleay", "pkcs8")
 header = "EC PRIVATE KEY" if format == "ssleay" else "PRIVATE KEY"
- return der.topem(self.to_der(point_encoding, format), header)
+ return der.topem(
+ self.to_der(point_encoding, format, curve_parameters_encoding),
+ header,
+ )
+
+ def _encode_eddsa(self):
+ """Create a PKCS#8 encoding of EdDSA keys."""
+ ec_private_key = der.encode_octet_string(self.to_string())
+ return der.encode_sequence(
+ der.encode_integer(0),
+ der.encode_sequence(der.encode_oid(*self.curve.oid)),
+ der.encode_octet_string(ec_private_key),
+ )
 
- def to_der(self, point_encoding="uncompressed", format="ssleay"):
+ def to_der(
+ self,
+ point_encoding="uncompressed",
+ format="ssleay",
+ curve_parameters_encoding=None,
+ ):
 """
 Convert the private key to the :term:`DER` format.
 
@@ -1131,7 +1227,15 @@ class SigningKey(object):
 The public key will be included in the generated string.
 
 :param str point_encoding: format to use for encoding public point
- :param str format: either ``ssleay`` (default) or ``pkcs8``
+ Ignored for EdDSA
+ :param str format: either ``ssleay`` (default) or ``pkcs8``.
+ EdDSA keys require ``pkcs8``.
+ :param str curve_parameters_encoding: format of encoded curve
+ parameters, default depends on the curve, if the curve has
+ an associated OID, ``named_curve`` format will be used,
+ if no OID is associated with the curve, the fallback of
+ ``explicit`` parameters will be used.
+ Ignored for EdDSA.
 
 :return: DER encoded private key
 :rtype: bytes
@@ -1141,15 +1245,27 @@ class SigningKey(object):
 if point_encoding == "raw":
 raise ValueError("raw encoding not allowed in DER")
 assert format in ("ssleay", "pkcs8")
+ if isinstance(self.curve.curve, CurveEdTw):
+ if format != "pkcs8":
+ raise ValueError("Only PKCS#8 format supported for EdDSA keys")
+ return self._encode_eddsa()
 encoded_vk = self.get_verifying_key().to_string(point_encoding)
- # the 0 in encode_bitstring specifies the number of unused bits
- # in the `encoded_vk` string
- ec_private_key = der.encode_sequence(
+ priv_key_elems = [
 der.encode_integer(1),
 der.encode_octet_string(self.to_string()),
- der.encode_constructed(0, self.curve.encoded_oid),
- der.encode_constructed(1, der.encode_bitstring(encoded_vk, 0)),
+ ]
+ if format == "ssleay":
+ priv_key_elems.append(
+ der.encode_constructed(
+ 0, self.curve.to_der(curve_parameters_encoding)
+ )
+ )
+ # the 0 in encode_bitstring specifies the number of unused bits
+ # in the `encoded_vk` string
+ priv_key_elems.append(
+ der.encode_constructed(1, der.encode_bitstring(encoded_vk, 0))
 )
+ ec_private_key = der.encode_sequence(*priv_key_elems)
 
 if format == "ssleay":
 return ec_private_key
@@ -1159,7 +1275,8 @@ class SigningKey(object):
 # top-level structure.
 der.encode_integer(1),
 der.encode_sequence(
- der.encode_oid(*oid_ecPublicKey), self.curve.encoded_oid
+ der.encode_oid(*oid_ecPublicKey),
+ self.curve.to_der(curve_parameters_encoding),
 ),
 der.encode_octet_string(ec_private_key),
 )
@@ -1184,20 +1301,27 @@ class SigningKey(object):
 extra_entropy=b"",
 ):
 """
- Create signature over data using the deterministic RFC6679 algorithm.
+ Create signature over data.
 
- The data will be hashed using the `hashfunc` function before signing.
+ For Weierstrass curves it uses the deterministic RFC6979 algorithm.
+ For Edwards curves it uses the standard EdDSA algorithm.
+
+ For ECDSA the data will be hashed using the `hashfunc` function before
+ signing.
+ For EdDSA the data will be hashed with the hash associated with the
+ curve (SHA-512 for Ed25519 and SHAKE-256 for Ed448).
 
 This is the recommended method for performing signatures when hashing
 of data is necessary.
 
 :param data: data to be hashed and computed signature over
- :type data: bytes like object
+ :type data: :term:`bytes-like object`
 :param hashfunc: hash function to use for computing the signature,
 if unspecified, the default hash function selected during
 object initialisation will be used (see
 `VerifyingKey.default_hashfunc`). The object needs to implement
 the same interface as hashlib.sha1.
+ Ignored with EdDSA.
 :type hashfunc: callable
 :param sigencode: function used to encode the signature.
 The function needs to accept three parameters: the two integers
@@ -1205,16 +1329,22 @@ class SigningKey(object):
 signature was computed. It needs to return an encoded signature.
 See `ecdsa.util.sigencode_string` and `ecdsa.util.sigencode_der`
 as examples of such functions.
+ Ignored with EdDSA.
 :type sigencode: callable
 :param extra_entropy: additional data that will be fed into the random
 number generator used in the RFC6979 process. Entirely optional.
- :type extra_entropy: bytes like object
+ Ignored with EdDSA.
+ :type extra_entropy: :term:`bytes-like object`
 
 :return: encoded signature over `data`
- :rtype: bytes or sigencode function dependant type
+ :rtype: bytes or sigencode function dependent type
 """
 hashfunc = hashfunc or self.default_hashfunc
 data = normalise_bytes(data)
+
+ if isinstance(self.curve.curve, CurveEdTw):
+ return self.privkey.sign(data)
+
 extra_entropy = normalise_bytes(extra_entropy)
 digest = hashfunc(data).digest()
 
@@ -1235,7 +1365,7 @@ class SigningKey(object):
 allow_truncate=False,
 ):
 """
- Create signature for digest using the deterministic RFC6679 algorithm.
+ Create signature for digest using the deterministic RFC6979 algorithm.
 
 `digest` should be the output of cryptographically secure hash function
 like SHA256 or SHA-3-256.
@@ -1244,32 +1374,36 @@ class SigningKey(object):
 hashing of data is necessary.
 
 :param digest: hash of data that will be signed
- :type digest: bytes like object
+ :type digest: :term:`bytes-like object`
 :param hashfunc: hash function to use for computing the random "k"
 value from RFC6979 process,
 if unspecified, the default hash function selected during
 object initialisation will be used (see
- `VerifyingKey.default_hashfunc`). The object needs to implement
- the same interface as hashlib.sha1.
+ :attr:`.VerifyingKey.default_hashfunc`). The object needs to
+ implement
+ the same interface as :func:`~hashlib.sha1` from :py:mod:`hashlib`.
 :type hashfunc: callable
 :param sigencode: function used to encode the signature.
 The function needs to accept three parameters: the two integers
 that are the signature and the order of the curve over which the
 signature was computed. It needs to return an encoded signature.
- See `ecdsa.util.sigencode_string` and `ecdsa.util.sigencode_der`
+ See :func:`~ecdsa.util.sigencode_string` and
+ :func:`~ecdsa.util.sigencode_der`
 as examples of such functions.
 :type sigencode: callable
 :param extra_entropy: additional data that will be fed into the random
 number generator used in the RFC6979 process. Entirely optional.
- :type extra_entropy: bytes like object
+ :type extra_entropy: :term:`bytes-like object`
 :param bool allow_truncate: if True, the provided digest can have
 bigger bit-size than the order of the curve, the extra bits (at
 the end of the digest) will be truncated. Use it when signing
 SHA-384 output using NIST256p or in similar situations.
 
 :return: encoded signature for the `digest` hash
- :rtype: bytes or sigencode function dependant type
+ :rtype: bytes or sigencode function dependent type
 """
+ if isinstance(self.curve.curve, CurveEdTw):
+ raise ValueError("Method unsupported for Edwards curves")
 secexp = self.privkey.secret_multiplier
 hashfunc = hashfunc or self.default_hashfunc
 digest = normalise_bytes(digest)
@@ -1311,7 +1445,11 @@ class SigningKey(object):
 allow_truncate=True,
 ):
 """
- Create signature over data using the probabilistic ECDSA algorithm.
+ Create signature over data.
+
+ Uses the probabilistic ECDSA algorithm for Weierstrass curves
+ (NIST256p, etc.) and the deterministic EdDSA algorithm for the
+ Edwards curves (Ed25519, Ed448).
 
 This method uses the standard ECDSA algorithm that requires a
 cryptographically secure random number generator.
@@ -1320,46 +1458,62 @@ class SigningKey(object):
 method instead of this one.
 
 :param data: data that will be hashed for signing
- :type data: bytes like object
- :param callable entropy: randomness source, os.urandom by default
- :param hashfunc: hash function to use for hashing the provided `data`.
+ :type data: :term:`bytes-like object`
+ :param callable entropy: randomness source, :func:`os.urandom` by
+ default. Ignored with EdDSA.
+ :param hashfunc: hash function to use for hashing the provided
+ ``data``.
 If unspecified the default hash function selected during
 object initialisation will be used (see
- `VerifyingKey.default_hashfunc`).
- Should behave like hashlib.sha1. The output length of the
+ :attr:`.VerifyingKey.default_hashfunc`).
+ Should behave like :func:`~hashlib.sha1` from :py:mod:`hashlib`.
+ The output length of the
 hash (in bytes) must not be longer than the length of the curve
 order (rounded up to the nearest byte), so using SHA256 with
 NIST256p is ok, but SHA256 with NIST192p is not. (In the 2**-96ish
 unlikely event of a hash output larger than the curve order, the
 hash will effectively be wrapped mod n).
- Use hashfunc=hashlib.sha1 to match openssl's -ecdsa-with-SHA1 mode,
- or hashfunc=hashlib.sha256 for openssl-1.0.0's -ecdsa-with-SHA256.
+ If you want to explicitly allow use of large hashes with small
+ curves set the ``allow_truncate`` to ``True``.
+ Use ``hashfunc=hashlib.sha1`` to match openssl's
+ ``-ecdsa-with-SHA1`` mode,
+ or ``hashfunc=hashlib.sha256`` for openssl-1.0.0's
+ ``-ecdsa-with-SHA256``.
+ Ignored for EdDSA
 :type hashfunc: callable
 :param sigencode: function used to encode the signature.
 The function needs to accept three parameters: the two integers
 that are the signature and the order of the curve over which the
 signature was computed. It needs to return an encoded signature.
- See `ecdsa.util.sigencode_string` and `ecdsa.util.sigencode_der`
+ See :func:`~ecdsa.util.sigencode_string` and
+ :func:`~ecdsa.util.sigencode_der`
 as examples of such functions.
+ Ignored for EdDSA
 :type sigencode: callable
 :param int k: a pre-selected nonce for calculating the signature.
 In typical use cases, it should be set to None (the default) to
 allow its generation from an entropy source.
- :param bool allow_truncate: if True, the provided digest can have
+ Ignored for EdDSA.
+ :param bool allow_truncate: if ``True``, the provided digest can have
 bigger bit-size than the order of the curve, the extra bits (at
 the end of the digest) will be truncated. Use it when signing
 SHA-384 output using NIST256p or in similar situations. True by
 default.
+ Ignored for EdDSA.
 
- :raises RSZeroError: in the unlikely event when "r" parameter or
- "s" parameter is equal 0 as that would leak the key. Calee should
- try a better entropy source or different 'k' in such case.
+ :raises RSZeroError: in the unlikely event when *r* parameter or
+ *s* parameter of the created signature is equal 0, as that would
+ leak the key. Caller should try a better entropy source, retry with
+ different ``k``, or use the
+ :func:`~SigningKey.sign_deterministic` in such case.
 
 :return: encoded signature of the hash of `data`
- :rtype: bytes or sigencode function dependant type
+ :rtype: bytes or sigencode function dependent type
 """
 hashfunc = hashfunc or self.default_hashfunc
 data = normalise_bytes(data)
+ if isinstance(self.curve.curve, CurveEdTw):
+ return self.sign_deterministic(data)
 h = hashfunc(data).digest()
 return self.sign_digest(h, entropy, sigencode, k, allow_truncate)
 
@@ -1384,7 +1538,7 @@ class SigningKey(object):
 instead of this one.
 
 :param digest: hash value that will be signed
- :type digest: bytes like object
+ :type digest: :term:`bytes-like object`
 :param callable entropy: randomness source, os.urandom by default
 :param sigencode: function used to encode the signature.
 The function needs to accept three parameters: the two integers
@@ -1402,21 +1556,22 @@ class SigningKey(object):
 SHA-384 output using NIST256p or in similar situations.
 
 :raises RSZeroError: in the unlikely event when "r" parameter or
- "s" parameter is equal 0 as that would leak the key. Calee should
- try a better entropy source in such case.
+ "s" parameter of the created signature is equal 0, as that would
+ leak the key. Caller should try a better entropy source, retry with
+ different 'k', or use the
+ :func:`~SigningKey.sign_digest_deterministic` in such case.
 
 :return: encoded signature for the `digest` hash
- :rtype: bytes or sigencode function dependant type
+ :rtype: bytes or sigencode function dependent type
 """
+ if isinstance(self.curve.curve, CurveEdTw):
+ raise ValueError("Method unsupported for Edwards curves")
 digest = normalise_bytes(digest)
- if allow_truncate:
- digest = digest[: self.curve.baselen]
- if len(digest) > self.curve.baselen:
- raise BadDigestError(
- "this curve (%s) is too short "
- "for your digest (%d)" % (self.curve.name, 8 * len(digest))
- )
- number = string_to_number(digest)
+ number = _truncate_and_convert_digest(
+ digest,
+ self.curve,
+ allow_truncate,
+ )
 r, s = self.sign_number(number, entropy, k)
 return sigencode(r, s, self.privkey.order)
 
@@ -1435,12 +1590,16 @@ class SigningKey(object):
 it will be selected at random using the entropy source.
 
 :raises RSZeroError: in the unlikely event when "r" parameter or
- "s" parameter is equal 0 as that would leak the key. Calee should
- try a different 'k' in such case.
+ "s" parameter of the created signature is equal 0, as that would
+ leak the key. Caller should try a better entropy source, retry with
+ different 'k', or use the
+ :func:`~SigningKey.sign_digest_deterministic` in such case.
 
 :return: the "r" and "s" parameters of the signature
 :rtype: tuple of ints
 """
+ if isinstance(self.curve.curve, CurveEdTw):
+ raise ValueError("Method unsupported for Edwards curves")
 order = self.privkey.order
 
 if k is not None:
diff --git a/frozen_deps/ecdsa/numbertheory.py b/frozen_deps/ecdsa/numbertheory.py
index e5cc888..d3500c7 100644
--- a/frozen_deps/ecdsa/numbertheory.py
+++ b/frozen_deps/ecdsa/numbertheory.py
@@ -7,10 +7,11 @@
 # Written in 2005 and 2006 by Peter Pearson and placed in the public domain.
 # Revision history:
 # 2008.11.14: Use pow(base, exponent, modulus) for modular_exp.
-# Make gcd and lcm accept arbitrarly many arguments.
+# Make gcd and lcm accept arbitrarily many arguments.
 
 from __future__ import division
 
+import sys
 from six import integer_types, PY2
 from six.moves import reduce
 
@@ -42,6 +43,10 @@ class Error(Exception):
 pass
 
 
+class JacobiError(Error):
+ pass
+
+
 class SquareRootError(Error):
 pass
 
@@ -153,8 +158,10 @@ def jacobi(a, n):
 # table printed in HAC, and by extensive use in calculating
 # modular square roots.
 
- assert n >= 3
- assert n % 2 == 1
+ if not n >= 3:
+ raise JacobiError("n must be larger than 2")
+ if not n % 2 == 1:
+ raise JacobiError("n must be odd")
 a = a % n
 if a == 0:
 return 0
@@ -201,9 +208,8 @@ def square_root_mod_prime(a, p):
 d = pow(a, (p - 1) // 4, p)
 if d == 1:
 return pow(a, (p + 3) // 8, p)
- if d == p - 1:
- return (2 * a * pow(4 * a, (p - 5) // 8, p)) % p
- raise RuntimeError("Shouldn't get here.")
+ assert d == p - 1
+ return (2 * a * pow(4 * a, (p - 5) // 8, p)) % p
 
 if PY2:
 # xrange on python2 can take integers representable as C long only
@@ -214,53 +220,63 @@ def square_root_mod_prime(a, p):
 if jacobi(b * b - 4 * a, p) == -1:
 f = (a, -b, 1)
 ff = polynomial_exp_mod((0, 1), (p + 1) // 2, f, p)
- assert ff[1] == 0
+ if ff[1]:
+ raise SquareRootError("p is not prime")
 return ff[0]
 raise RuntimeError("No b found.")
 
 
-if GMPY2:
+# because all the inverse_mod code is arch/environment specific, and coveralls
+# expects it to execute equal number of times, we need to waive it by
+# adding the "no branch" pragma to all branches
+if GMPY2: # pragma: no branch
 
 def inverse_mod(a, m):
 """Inverse of a mod m."""
- if a == 0:
+ if a == 0: # pragma: no branch
 return 0
 return powmod(a, -1, m)
 
-
-elif GMPY:
+elif GMPY: # pragma: no branch
 
 def inverse_mod(a, m):
 """Inverse of a mod m."""
- # while libgmp likely does support inverses modulo, it is accessible
- # only using the native `pow()` function, and `pow()` sanity checks
- # the parameters before passing them on to underlying implementation
- # on Python2
- if a == 0:
+ # while libgmp does support inverses modulo, it is accessible
+ # only using the native `pow()` function, and `pow()` in gmpy sanity
+ # checks the parameters before passing them on to underlying
+ # implementation
+ if a == 0: # pragma: no branch
 return 0
 a = mpz(a)
 m = mpz(m)
 
 lm, hm = mpz(1), mpz(0)
 low, high = a % m, m
- while low > 1:
+ while low > 1: # pragma: no branch
 r = high // low
 lm, low, hm, high = hm - lm * r, high - low * r, lm, low
 
 return lm % m
 
+elif sys.version_info >= (3, 8): # pragma: no branch
+
+ def inverse_mod(a, m):
+ """Inverse of a mod m."""
+ if a == 0: # pragma: no branch
+ return 0
+ return pow(a, -1, m)
 
-else:
+else: # pragma: no branch
 
 def inverse_mod(a, m):
 """Inverse of a mod m."""
 
- if a == 0:
+ if a == 0: # pragma: no branch
 return 0
 
 lm, hm = 1, 0
 low, high = a % m, m
- while low > 1:
+ while low > 1: # pragma: no branch
 r = high // low
 lm, low, hm, high = hm - lm * r, high - low * r, lm, low
 
@@ -321,7 +337,6 @@ def factorization(n):
 return []
 
 result = []
- d = 2
 
 # Test the small primes:
 
@@ -374,7 +389,7 @@ def phi(n): # pragma: no cover
 warnings.warn(
 "Function is unused by library code. If you use this code, "
 "please open an issue in "
- "https://github.com/warner/python-ecdsa",
+ "https://github.com/tlsfuzzer/python-ecdsa",
 DeprecationWarning,
 )
 
@@ -404,7 +419,7 @@ def carmichael(n): # pragma: no cover
 warnings.warn(
 "Function is unused by library code. If you use this code, "
 "please open an issue in "
- "https://github.com/warner/python-ecdsa",
+ "https://github.com/tlsfuzzer/python-ecdsa",
 DeprecationWarning,
 )
 
@@ -419,7 +434,7 @@ def carmichael_of_factorized(f_list): # pragma: no cover
 warnings.warn(
 "Function is unused by library code. If you use this code, "
 "please open an issue in "
- "https://github.com/warner/python-ecdsa",
+ "https://github.com/tlsfuzzer/python-ecdsa",
 DeprecationWarning,
 )
 
@@ -439,7 +454,7 @@ def carmichael_of_ppower(pp): # pragma: no cover
 warnings.warn(
 "Function is unused by library code. If you use this code, "
 "please open an issue in "
- "https://github.com/warner/python-ecdsa",
+ "https://github.com/tlsfuzzer/python-ecdsa",
 DeprecationWarning,
 )
 
@@ -456,7 +471,7 @@ def order_mod(x, m): # pragma: no cover
 warnings.warn(
 "Function is unused by library code. If you use this code, "
 "please open an issue in "
- "https://github.com/warner/python-ecdsa",
+ "https://github.com/tlsfuzzer/python-ecdsa",
 DeprecationWarning,
 )
 
@@ -482,7 +497,7 @@ def largest_factor_relatively_prime(a, b): # pragma: no cover
 warnings.warn(
 "Function is unused by library code. If you use this code, "
 "please open an issue in "
- "https://github.com/warner/python-ecdsa",
+ "https://github.com/tlsfuzzer/python-ecdsa",
 DeprecationWarning,
 )
 
@@ -507,7 +522,7 @@ def kinda_order_mod(x, m): # pragma: no cover
 warnings.warn(
 "Function is unused by library code. If you use this code, "
 "please open an issue in "
- "https://github.com/warner/python-ecdsa",
+ "https://github.com/tlsfuzzer/python-ecdsa",
 DeprecationWarning,
 )
 
diff --git a/frozen_deps/ecdsa/rfc6979.py b/frozen_deps/ecdsa/rfc6979.py
index 1e577c0..0728b5a 100644
--- a/frozen_deps/ecdsa/rfc6979.py
+++ b/frozen_deps/ecdsa/rfc6979.py
@@ -42,14 +42,17 @@ def bits2octets(data, order):
 # https://tools.ietf.org/html/rfc6979#section-3.2
 def generate_k(order, secexp, hash_func, data, retry_gen=0, extra_entropy=b""):
 """
- order - order of the DSA generator used in the signature
- secexp - secure exponent (private key) in numeric form
- hash_func - reference to the same hash function used for generating
- hash
- data - hash in binary form of the signing data
- retry_gen - int - how many good 'k' values to skip before returning
- extra_entropy - extra added data in binary form as per section-3.6 of
- rfc6979
+ Generate the ``k`` value - the nonce for DSA.
+
+ :param int order: order of the DSA generator used in the signature
+ :param int secexp: secure exponent (private key) in numeric form
+ :param hash_func: reference to the same hash function used for generating
+ hash, like :py:class:`hashlib.sha1`
+ :param bytes data: hash in binary form of the signing data
+ :param int retry_gen: how many good 'k' values to skip before returning
+ :param bytes extra_entropy: additional added data in binary form as per
+ section-3.6 of rfc6979
+ :rtype: int
 """
 
 qlen = bit_length(order)
diff --git a/frozen_deps/ecdsa/test_curves.py b/frozen_deps/ecdsa/test_curves.py
new file mode 100644
index 0000000..93b6c9b
--- /dev/null
+++ b/frozen_deps/ecdsa/test_curves.py
@@ -0,0 +1,361 @@
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+
+import base64
+import pytest
+from .curves import (
+ Curve,
+ NIST256p,
+ curves,
+ UnknownCurveError,
+ PRIME_FIELD_OID,
+ curve_by_name,
+)
+from .ellipticcurve import CurveFp, PointJacobi, CurveEdTw
+from . import der
+from .util import number_to_string
+
+
+class TestParameterEncoding(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ # minimal, but with cofactor (excludes seed when compared to
+ # OpenSSL output)
+ cls.base64_params = (
+ "MIHgAgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP/////////"
+ "//////zBEBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12K"
+ "o6k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsEQQRrF9Hy4SxCR/i85uVjpEDyd"
+ "wN9gS3rM6D0oTlF2JjClk/jQuL+Gn+bjufrSnwPnhYrzjNXazFezsu2QGg3v1H1"
+ "AiEA/////wAAAAD//////////7zm+q2nF56E87nKwvxjJVECAQE="
+ )
+
+ def test_from_pem(self):
+ pem_params = (
+ "-----BEGIN EC PARAMETERS-----\n"
+ "MIHgAgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP/////////\n"
+ "//////zBEBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12K\n"
+ "o6k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsEQQRrF9Hy4SxCR/i85uVjpEDyd\n"
+ "wN9gS3rM6D0oTlF2JjClk/jQuL+Gn+bjufrSnwPnhYrzjNXazFezsu2QGg3v1H1\n"
+ "AiEA/////wAAAAD//////////7zm+q2nF56E87nKwvxjJVECAQE=\n"
+ "-----END EC PARAMETERS-----\n"
+ )
+ curve = Curve.from_pem(pem_params)
+
+ self.assertIs(curve, NIST256p)
+
+ def test_from_pem_with_explicit_when_explicit_disabled(self):
+ pem_params = (
+ "-----BEGIN EC PARAMETERS-----\n"
+ "MIHgAgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP/////////\n"
+ "//////zBEBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12K\n"
+ "o6k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsEQQRrF9Hy4SxCR/i85uVjpEDyd\n"
+ "wN9gS3rM6D0oTlF2JjClk/jQuL+Gn+bjufrSnwPnhYrzjNXazFezsu2QGg3v1H1\n"
+ "AiEA/////wAAAAD//////////7zm+q2nF56E87nKwvxjJVECAQE=\n"
+ "-----END EC PARAMETERS-----\n"
+ )
+ with self.assertRaises(der.UnexpectedDER) as e:
+ Curve.from_pem(pem_params, ["named_curve"])
+
+ self.assertIn("explicit curve parameters not", str(e.exception))
+
+ def test_from_pem_with_named_curve_with_named_curve_disabled(self):
+ pem_params = (
+ "-----BEGIN EC PARAMETERS-----\n"
+ "BggqhkjOPQMBBw==\n"
+ "-----END EC PARAMETERS-----\n"
+ )
+ with self.assertRaises(der.UnexpectedDER) as e:
+ Curve.from_pem(pem_params, ["explicit"])
+
+ self.assertIn("named_curve curve parameters not", str(e.exception))
+
+ def test_from_pem_with_wrong_header(self):
+ pem_params = (
+ "-----BEGIN PARAMETERS-----\n"
+ "MIHgAgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP/////////\n"
+ "//////zBEBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12K\n"
+ "o6k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsEQQRrF9Hy4SxCR/i85uVjpEDyd\n"
+ "wN9gS3rM6D0oTlF2JjClk/jQuL+Gn+bjufrSnwPnhYrzjNXazFezsu2QGg3v1H1\n"
+ "AiEA/////wAAAAD//////////7zm+q2nF56E87nKwvxjJVECAQE=\n"
+ "-----END PARAMETERS-----\n"
+ )
+ with self.assertRaises(der.UnexpectedDER) as e:
+ Curve.from_pem(pem_params)
+
+ self.assertIn("PARAMETERS PEM header", str(e.exception))
+
+ def test_to_pem(self):
+ pem_params = (
+ b"-----BEGIN EC PARAMETERS-----\n"
+ b"BggqhkjOPQMBBw==\n"
+ b"-----END EC PARAMETERS-----\n"
+ )
+ encoding = NIST256p.to_pem()
+
+ self.assertEqual(pem_params, encoding)
+
+ def test_compare_with_different_object(self):
+ self.assertNotEqual(NIST256p, 256)
+
+ def test_named_curve_params_der(self):
+ encoded = NIST256p.to_der()
+
+ # just the encoding of the NIST256p OID (prime256v1)
+ self.assertEqual(b"\x06\x08\x2a\x86\x48\xce\x3d\x03\x01\x07", encoded)
+
+ def test_verify_that_default_is_named_curve_der(self):
+ encoded_default = NIST256p.to_der()
+ encoded_named = NIST256p.to_der("named_curve")
+
+ self.assertEqual(encoded_default, encoded_named)
+
+ def test_encoding_to_explicit_params(self):
+ encoded = NIST256p.to_der("explicit")
+
+ self.assertEqual(encoded, bytes(base64.b64decode(self.base64_params)))
+
+ def test_encoding_to_unsupported_type(self):
+ with self.assertRaises(ValueError) as e:
+ NIST256p.to_der("unsupported")
+
+ self.assertIn("Only 'named_curve'", str(e.exception))
+
+ def test_encoding_to_explicit_compressed_params(self):
+ encoded = NIST256p.to_der("explicit", "compressed")
+
+ compressed_base_point = (
+ "MIHAAgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP//////////"
+ "/////zBEBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12Ko6"
+ "k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsEIQNrF9Hy4SxCR/i85uVjpEDydwN9"
+ "gS3rM6D0oTlF2JjClgIhAP////8AAAAA//////////+85vqtpxeehPO5ysL8YyVR"
+ "AgEB"
+ )
+
+ self.assertEqual(
+ encoded, bytes(base64.b64decode(compressed_base_point))
+ )
+
+ def test_decoding_explicit_from_openssl(self):
+ # generated with openssl 1.1.1k using
+ # openssl ecparam -name P-256 -param_enc explicit -out /tmp/file.pem
+ p256_explicit = (
+ "MIH3AgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP//////////"
+ "/////zBbBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12Ko6"
+ "k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsDFQDEnTYIhucEk2pmeOETnSa3gZ9+"
+ "kARBBGsX0fLhLEJH+Lzm5WOkQPJ3A32BLeszoPShOUXYmMKWT+NC4v4af5uO5+tK"
+ "fA+eFivOM1drMV7Oy7ZAaDe/UfUCIQD/////AAAAAP//////////vOb6racXnoTz"
+ "ucrC/GMlUQIBAQ=="
+ )
+
+ decoded = Curve.from_der(bytes(base64.b64decode(p256_explicit)))
+
+ self.assertEqual(NIST256p, decoded)
+
+ def test_decoding_well_known_from_explicit_params(self):
+ curve = Curve.from_der(bytes(base64.b64decode(self.base64_params)))
+
+ self.assertIs(curve, NIST256p)
+
+ def test_decoding_with_incorrect_valid_encodings(self):
+ with self.assertRaises(ValueError) as e:
+ Curve.from_der(b"", ["explicitCA"])
+
+ self.assertIn("Only named_curve", str(e.exception))
+
+ def test_compare_curves_with_different_generators(self):
+ curve_fp = CurveFp(23, 1, 7)
+ base_a = PointJacobi(curve_fp, 13, 3, 1, 9, generator=True)
+ base_b = PointJacobi(curve_fp, 1, 20, 1, 9, generator=True)
+
+ curve_a = Curve("unknown", curve_fp, base_a, None)
+ curve_b = Curve("unknown", curve_fp, base_b, None)
+
+ self.assertNotEqual(curve_a, curve_b)
+
+ def test_default_encode_for_custom_curve(self):
+ curve_fp = CurveFp(23, 1, 7)
+ base_point = PointJacobi(curve_fp, 13, 3, 1, 9, generator=True)
+
+ curve = Curve("unknown", curve_fp, base_point, None)
+
+ encoded = curve.to_der()
+
+ decoded = Curve.from_der(encoded)
+
+ self.assertEqual(curve, decoded)
+
+ expected = "MCECAQEwDAYHKoZIzj0BAQIBFzAGBAEBBAEHBAMEDQMCAQk="
+
+ self.assertEqual(encoded, bytes(base64.b64decode(expected)))
+
+ def test_named_curve_encode_for_custom_curve(self):
+ curve_fp = CurveFp(23, 1, 7)
+ base_point = PointJacobi(curve_fp, 13, 3, 1, 9, generator=True)
+
+ curve = Curve("unknown", curve_fp, base_point, None)
+
+ with self.assertRaises(UnknownCurveError) as e:
+ curve.to_der("named_curve")
+
+ self.assertIn("Can't encode curve", str(e.exception))
+
+ def test_try_decoding_binary_explicit(self):
+ sect113r1_explicit = (
+ "MIGRAgEBMBwGByqGSM49AQIwEQIBcQYJKoZIzj0BAgMCAgEJMDkEDwAwiCUMpufH"
+ "/mSc6Fgg9wQPAOi+5NPiJgdEGIvg6ccjAxUAEOcjqxTWluZ2h1YVF1b+v4/LSakE"
+ "HwQAnXNhbzX0qxQH1zViwQ8ApSgwJ3lY7oTRMV7TGIYCDwEAAAAAAAAA2czsijnl"
+ "bwIBAg=="
+ )
+
+ with self.assertRaises(UnknownCurveError) as e:
+ Curve.from_der(base64.b64decode(sect113r1_explicit))
+
+ self.assertIn("Characteristic 2 curves unsupported", str(e.exception))
+
+ def test_decode_malformed_named_curve(self):
+ bad_der = der.encode_oid(*NIST256p.oid) + der.encode_integer(1)
+
+ with self.assertRaises(der.UnexpectedDER) as e:
+ Curve.from_der(bad_der)
+
+ self.assertIn("Unexpected data after OID", str(e.exception))
+
+ def test_decode_malformed_explicit_garbage_after_ECParam(self):
+ bad_der = bytes(
+ base64.b64decode(self.base64_params)
+ ) + der.encode_integer(1)
+
+ with self.assertRaises(der.UnexpectedDER) as e:
+ Curve.from_der(bad_der)
+
+ self.assertIn("Unexpected data after ECParameters", str(e.exception))
+
+ def test_decode_malformed_unknown_version_number(self):
+ bad_der = der.encode_sequence(der.encode_integer(2))
+
+ with self.assertRaises(der.UnexpectedDER) as e:
+ Curve.from_der(bad_der)
+
+ self.assertIn("Unknown parameter encoding format", str(e.exception))
+
+ def test_decode_malformed_unknown_field_type(self):
+ curve_p = NIST256p.curve.p()
+ bad_der = der.encode_sequence(
+ der.encode_integer(1),
+ der.encode_sequence(
+ der.encode_oid(1, 2, 3), der.encode_integer(curve_p)
+ ),
+ der.encode_sequence(
+ der.encode_octet_string(
+ number_to_string(NIST256p.curve.a() % curve_p, curve_p)
+ ),
+ der.encode_octet_string(
+ number_to_string(NIST256p.curve.b(), curve_p)
+ ),
+ ),
+ der.encode_octet_string(
+ NIST256p.generator.to_bytes("uncompressed")
+ ),
+ der.encode_integer(NIST256p.generator.order()),
+ )
+
+ with self.assertRaises(UnknownCurveError) as e:
+ Curve.from_der(bad_der)
+
+ self.assertIn("Unknown field type: (1, 2, 3)", str(e.exception))
+
+ def test_decode_malformed_garbage_after_prime(self):
+ curve_p = NIST256p.curve.p()
+ bad_der = der.encode_sequence(
+ der.encode_integer(1),
+ der.encode_sequence(
+ der.encode_oid(*PRIME_FIELD_OID),
+ der.encode_integer(curve_p),
+ der.encode_integer(1),
+ ),
+ der.encode_sequence(
+ der.encode_octet_string(
+ number_to_string(NIST256p.curve.a() % curve_p, curve_p)
+ ),
+ der.encode_octet_string(
+ number_to_string(NIST256p.curve.b(), curve_p)
+ ),
+ ),
+ der.encode_octet_string(
+ NIST256p.generator.to_bytes("uncompressed")
+ ),
+ der.encode_integer(NIST256p.generator.order()),
+ )
+
+ with self.assertRaises(der.UnexpectedDER) as e:
+ Curve.from_der(bad_der)
+
+ self.assertIn("Prime-p element", str(e.exception))
+
+
+class TestCurveSearching(unittest.TestCase):
+ def test_correct_name(self):
+ c = curve_by_name("NIST256p")
+ self.assertIs(c, NIST256p)
+
+ def test_openssl_name(self):
+ c = curve_by_name("prime256v1")
+ self.assertIs(c, NIST256p)
+
+ def test_unknown_curve(self):
+ with self.assertRaises(UnknownCurveError) as e:
+ curve_by_name("foo bar")
+
+ self.assertIn(
+ "name 'foo bar' unknown, only curves supported: "
+ "['NIST192p', 'NIST224p'",
+ str(e.exception),
+ )
+
+ def test_with_None_as_parameter(self):
+ with self.assertRaises(UnknownCurveError) as e:
+ curve_by_name(None)
+
+ self.assertIn(
+ "name None unknown, only curves supported: "
+ "['NIST192p', 'NIST224p'",
+ str(e.exception),
+ )
+
+
+[email protected]("curve", curves, ids=[i.name for i in curves])
+def test_curve_params_encode_decode_named(curve):
+ ret = Curve.from_der(curve.to_der("named_curve"))
+
+ assert curve == ret
+
+
+[email protected]("curve", curves, ids=[i.name for i in curves])
+def test_curve_params_encode_decode_explicit(curve):
+ if isinstance(curve.curve, CurveEdTw):
+ with pytest.raises(UnknownCurveError):
+ curve.to_der("explicit")
+ else:
+ ret = Curve.from_der(curve.to_der("explicit"))
+
+ assert curve == ret
+
+
+[email protected]("curve", curves, ids=[i.name for i in curves])
+def test_curve_params_encode_decode_default(curve):
+ ret = Curve.from_der(curve.to_der())
+
+ assert curve == ret
+
+
+[email protected]("curve", curves, ids=[i.name for i in curves])
+def test_curve_params_encode_decode_explicit_compressed(curve):
+ if isinstance(curve.curve, CurveEdTw):
+ with pytest.raises(UnknownCurveError):
+ curve.to_der("explicit", "compressed")
+ else:
+ ret = Curve.from_der(curve.to_der("explicit", "compressed"))
+
+ assert curve == ret
diff --git a/frozen_deps/ecdsa/test_der.py b/frozen_deps/ecdsa/test_der.py
index 746d927..0ca5bd7 100644
--- a/frozen_deps/ecdsa/test_der.py
+++ b/frozen_deps/ecdsa/test_der.py
@@ -9,7 +9,7 @@ except ImportError:
 import unittest
 from six import b
 import hypothesis.strategies as st
-from hypothesis import given, example
+from hypothesis import given
 import pytest
 from ._compat import str_idx_as_int
 from .curves import NIST256p, NIST224p
@@ -21,6 +21,9 @@ from .der import (
 remove_bitstring,
 remove_object,
 encode_oid,
+ remove_constructed,
+ remove_octet_string,
+ remove_sequence,
 )
 
 
@@ -39,7 +42,7 @@ class TestRemoveInteger(unittest.TestCase):
 val, rem = remove_integer(b("\x02\x02\x00\x80"))
 
 self.assertEqual(val, 0x80)
- self.assertFalse(rem)
+ self.assertEqual(rem, b"")
 
 def test_two_zero_bytes_with_high_bit_set(self):
 with self.assertRaises(UnexpectedDER):
@@ -57,19 +60,31 @@ class TestRemoveInteger(unittest.TestCase):
 val, rem = remove_integer(b("\x02\x01\x00"))
 
 self.assertEqual(val, 0)
- self.assertFalse(rem)
+ self.assertEqual(rem, b"")
 
 def test_encoding_of_127(self):
 val, rem = remove_integer(b("\x02\x01\x7f"))
 
 self.assertEqual(val, 127)
- self.assertFalse(rem)
+ self.assertEqual(rem, b"")
 
 def test_encoding_of_128(self):
 val, rem = remove_integer(b("\x02\x02\x00\x80"))
 
 self.assertEqual(val, 128)
- self.assertFalse(rem)
+ self.assertEqual(rem, b"")
+
+ def test_wrong_tag(self):
+ with self.assertRaises(UnexpectedDER) as e:
+ remove_integer(b"\x01\x02\x00\x80")
+
+ self.assertIn("wanted type 'integer'", str(e.exception))
+
+ def test_wrong_length(self):
+ with self.assertRaises(UnexpectedDER) as e:
+ remove_integer(b"\x02\x03\x00\x80")
+
+ self.assertIn("Length longer", str(e.exception))
 
 
 class TestReadLength(unittest.TestCase):
@@ -368,8 +383,72 @@ class TestRemoveObject(unittest.TestCase):
 remove_object(b"\x06\x03\x88\x37")
 
 
+class TestRemoveConstructed(unittest.TestCase):
+ def test_simple(self):
+ data = b"\xa1\x02\xff\xaa"
+
+ tag, body, rest = remove_constructed(data)
+
+ self.assertEqual(tag, 0x01)
+ self.assertEqual(body, b"\xff\xaa")
+ self.assertEqual(rest, b"")
+
+ def test_with_malformed_tag(self):
+ data = b"\x01\x02\xff\xaa"
+
+ with self.assertRaises(UnexpectedDER) as e:
+ remove_constructed(data)
+
+ self.assertIn("constructed tag", str(e.exception))
+
+
+class TestRemoveOctetString(unittest.TestCase):
+ def test_simple(self):
+ data = b"\x04\x03\xaa\xbb\xcc"
+ body, rest = remove_octet_string(data)
+ self.assertEqual(body, b"\xaa\xbb\xcc")
+ self.assertEqual(rest, b"")
+
+ def test_with_malformed_tag(self):
+ data = b"\x03\x03\xaa\xbb\xcc"
+ with self.assertRaises(UnexpectedDER) as e:
+ remove_octet_string(data)
+
+ self.assertIn("octetstring", str(e.exception))
+
+
+class TestRemoveSequence(unittest.TestCase):
+ def test_simple(self):
+ data = b"\x30\x02\xff\xaa"
+ body, rest = remove_sequence(data)
+ self.assertEqual(body, b"\xff\xaa")
+ self.assertEqual(rest, b"")
+
+ def test_with_empty_string(self):
+ with self.assertRaises(UnexpectedDER) as e:
+ remove_sequence(b"")
+
+ self.assertIn("Empty string", str(e.exception))
+
+ def test_with_wrong_tag(self):
+ data = b"\x20\x02\xff\xaa"
+
+ with self.assertRaises(UnexpectedDER) as e:
+ remove_sequence(data)
+
+ self.assertIn("wanted type 'sequence'", str(e.exception))
+
+ def test_with_wrong_length(self):
+ data = b"\x30\x03\xff\xaa"
+
+ with self.assertRaises(UnexpectedDER) as e:
+ remove_sequence(data)
+
+ self.assertIn("Length longer", str(e.exception))
+
+
 @st.composite
-def st_oid(draw, max_value=2 ** 512, max_size=50):
+def st_oid(draw, max_value=2**512, max_size=50):
 """
 Hypothesis strategy that returns valid OBJECT IDENTIFIERs as tuples
 
diff --git a/frozen_deps/ecdsa/test_ecdh.py b/frozen_deps/ecdsa/test_ecdh.py
index caf6835..872d4d1 100644
--- a/frozen_deps/ecdsa/test_ecdh.py
+++ b/frozen_deps/ecdsa/test_ecdh.py
@@ -2,18 +2,41 @@ import os
 import shutil
 import subprocess
 import pytest
-from binascii import hexlify, unhexlify
-
-from .curves import NIST192p, NIST224p, NIST256p, NIST384p, NIST521p
+from binascii import unhexlify
+
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+
+from .curves import (
+ NIST192p,
+ NIST224p,
+ NIST256p,
+ NIST384p,
+ NIST521p,
+ BRAINPOOLP160r1,
+)
 from .curves import curves
-from .ecdh import ECDH, InvalidCurveError, InvalidSharedSecretError, NoKeyError
+from .ecdh import (
+ ECDH,
+ InvalidCurveError,
+ InvalidSharedSecretError,
+ NoKeyError,
+ NoCurveError,
+)
 from .keys import SigningKey, VerifyingKey
+from .ellipticcurve import CurveEdTw
 
 
 @pytest.mark.parametrize(
- "vcurve", curves, ids=[curve.name for curve in curves]
+ "vcurve",
+ curves,
+ ids=[curve.name for curve in curves],
 )
 def test_ecdh_each(vcurve):
+ if isinstance(vcurve.curve, CurveEdTw):
+ pytest.skip("ECDH is not supported for Edwards curves")
 ecdh1 = ECDH(curve=vcurve)
 ecdh2 = ECDH(curve=vcurve)
 
@@ -26,6 +49,19 @@ def test_ecdh_each(vcurve):
 assert secret1 == secret2
 
 
+def test_ecdh_both_keys_present():
+ key1 = SigningKey.generate(BRAINPOOLP160r1)
+ key2 = SigningKey.generate(BRAINPOOLP160r1)
+
+ ecdh1 = ECDH(BRAINPOOLP160r1, key1, key2.verifying_key)
+ ecdh2 = ECDH(private_key=key2, public_key=key1.verifying_key)
+
+ secret1 = ecdh1.generate_sharedsecret_bytes()
+ secret2 = ecdh2.generate_sharedsecret_bytes()
+
+ assert secret1 == secret2
+
+
 def test_ecdh_no_public_key():
 ecdh1 = ECDH(curve=NIST192p)
 
@@ -38,6 +74,44 @@ def test_ecdh_no_public_key():
 ecdh1.generate_sharedsecret_bytes()
 
 
+class TestECDH(unittest.TestCase):
+ def test_load_key_from_wrong_curve(self):
+ ecdh1 = ECDH()
+ ecdh1.set_curve(NIST192p)
+
+ key1 = SigningKey.generate(BRAINPOOLP160r1)
+
+ with self.assertRaises(InvalidCurveError) as e:
+ ecdh1.load_private_key(key1)
+
+ self.assertIn("Curve mismatch", str(e.exception))
+
+ def test_generate_without_curve(self):
+ ecdh1 = ECDH()
+
+ with self.assertRaises(NoCurveError) as e:
+ ecdh1.generate_private_key()
+
+ self.assertIn("Curve must be set", str(e.exception))
+
+ def test_load_bytes_without_curve_set(self):
+ ecdh1 = ECDH()
+
+ with self.assertRaises(NoCurveError) as e:
+ ecdh1.load_private_key_bytes(b"\x01" * 32)
+
+ self.assertIn("Curve must be set", str(e.exception))
+
+ def test_set_curve_from_received_public_key(self):
+ ecdh1 = ECDH()
+
+ key1 = SigningKey.generate(BRAINPOOLP160r1)
+
+ ecdh1.load_received_public_key(key1.verifying_key)
+
+ self.assertEqual(ecdh1.curve, BRAINPOOLP160r1)
+
+
 def test_ecdh_wrong_public_key_curve():
 ecdh1 = ECDH(curve=NIST192p)
 ecdh1.generate_private_key()
@@ -293,25 +367,27 @@ OPENSSL_SUPPORTED_CURVES = set(
 
 
 @pytest.mark.parametrize(
- "vcurve", curves, ids=[curve.name for curve in curves]
+ "vcurve",
+ curves,
+ ids=[curve.name for curve in curves],
 )
 def test_ecdh_with_openssl(vcurve):
+ if isinstance(vcurve.curve, CurveEdTw):
+ pytest.skip("Edwards curves are not supported for ECDH")
+
 assert vcurve.openssl_name
 
 if vcurve.openssl_name not in OPENSSL_SUPPORTED_CURVES:
 pytest.skip("system openssl does not support " + vcurve.openssl_name)
- return
 
 try:
 hlp = run_openssl("pkeyutl -help")
- if hlp.find("-derive") == 0:
+ if hlp.find("-derive") == 0: # pragma: no cover
 pytest.skip("system openssl does not support `pkeyutl -derive`")
- return
- except RunOpenSslError:
- pytest.skip("system openssl does not support `pkeyutl -derive`")
- return
+ except RunOpenSslError: # pragma: no cover
+ pytest.skip("system openssl could not be executed")
 
- if os.path.isdir("t"):
+ if os.path.isdir("t"): # pragma: no branch
 shutil.rmtree("t")
 os.mkdir("t")
 run_openssl(
@@ -346,25 +422,20 @@ def test_ecdh_with_openssl(vcurve):
 
 assert secret1 == secret2
 
- try:
- run_openssl(
- "pkeyutl -derive -inkey t/privkey1.pem -peerkey t/pubkey2.pem -out t/secret1"
- )
- run_openssl(
- "pkeyutl -derive -inkey t/privkey2.pem -peerkey t/pubkey1.pem -out t/secret2"
- )
- except RunOpenSslError:
- pytest.skip("system openssl does not support `pkeyutl -derive`")
- return
+ run_openssl(
+ "pkeyutl -derive -inkey t/privkey1.pem -peerkey t/pubkey2.pem -out t/secret1"
+ )
+ run_openssl(
+ "pkeyutl -derive -inkey t/privkey2.pem -peerkey t/pubkey1.pem -out t/secret2"
+ )
 
 with open("t/secret1", "rb") as e:
 ssl_secret1 = e.read()
 with open("t/secret1", "rb") as e:
 ssl_secret2 = e.read()
 
- if len(ssl_secret1) != vk1.curve.baselen:
- pytest.skip("system openssl does not support `pkeyutl -derive`")
- return
+ assert len(ssl_secret1) == vk1.curve.verifying_key_length // 2
+ assert len(secret1) == vk1.curve.verifying_key_length // 2
 
 assert ssl_secret1 == ssl_secret2
 assert secret1 == ssl_secret1
diff --git a/frozen_deps/ecdsa/test_ecdsa.py b/frozen_deps/ecdsa/test_ecdsa.py
index e656b88..dbc4a6e 100644
--- a/frozen_deps/ecdsa/test_ecdsa.py
+++ b/frozen_deps/ecdsa/test_ecdsa.py
@@ -21,6 +21,11 @@ from .ecdsa import (
 generator_384,
 generator_521,
 generator_secp256k1,
+ curve_192,
+ InvalidPointError,
+ curve_112r2,
+ generator_112r2,
+ int_to_string,
 )
 
 
@@ -96,6 +101,20 @@ class TestPublicKey(unittest.TestCase):
 pub_key2 = Public_key(gen, point2)
 self.assertNotEqual(pub_key1, pub_key2)
 
+ def test_inequality_different_curves(self):
+ gen = generator_192
+ x1 = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+ y1 = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+ point1 = ellipticcurve.Point(gen.curve(), x1, y1)
+
+ x2 = 0x722BA0FB6B8FC8898A4C6AB49E66
+ y2 = 0x2B7344BB57A7ABC8CA0F1A398C7D
+ point2 = ellipticcurve.Point(generator_112r2.curve(), x2, y2)
+
+ pub_key1 = Public_key(gen, point1)
+ pub_key2 = Public_key(generator_112r2, point2)
+ self.assertNotEqual(pub_key1, pub_key2)
+
 def test_inequality_public_key_not_implemented(self):
 gen = generator_192
 x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
@@ -104,6 +123,106 @@ class TestPublicKey(unittest.TestCase):
 pub_key = Public_key(gen, point)
 self.assertNotEqual(pub_key, None)
 
+ def test_public_key_with_generator_without_order(self):
+ gen = ellipticcurve.PointJacobi(
+ generator_192.curve(), generator_192.x(), generator_192.y(), 1
+ )
+
+ x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+ y = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+ point = ellipticcurve.Point(gen.curve(), x, y)
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(gen, point)
+
+ self.assertIn("Generator point must have order", str(e.exception))
+
+ def test_public_point_on_curve_not_scalar_multiple_of_base_point(self):
+ x = 2
+ y = 0xBE6AA4938EF7CFE6FE29595B6B00
+ # we need a curve with cofactor != 1
+ point = ellipticcurve.PointJacobi(curve_112r2, x, y, 1)
+
+ self.assertTrue(curve_112r2.contains_point(x, y))
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(generator_112r2, point)
+
+ self.assertIn("Generator point order", str(e.exception))
+
+ def test_point_is_valid_with_not_scalar_multiple_of_base_point(self):
+ x = 2
+ y = 0xBE6AA4938EF7CFE6FE29595B6B00
+
+ self.assertFalse(point_is_valid(generator_112r2, x, y))
+
+ # the tests to verify the extensiveness of tests in ecdsa.ecdsa
+ # if PointJacobi gets modified to calculate the x and y mod p the tests
+ # below will need to use a fake/mock object
+ def test_invalid_point_x_negative(self):
+ pt = ellipticcurve.PointJacobi(curve_192, -1, 0, 1)
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(generator_192, pt)
+
+ self.assertIn("The public point has x or y", str(e.exception))
+
+ def test_invalid_point_x_equal_p(self):
+ pt = ellipticcurve.PointJacobi(curve_192, curve_192.p(), 0, 1)
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(generator_192, pt)
+
+ self.assertIn("The public point has x or y", str(e.exception))
+
+ def test_invalid_point_y_negative(self):
+ pt = ellipticcurve.PointJacobi(curve_192, 0, -1, 1)
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(generator_192, pt)
+
+ self.assertIn("The public point has x or y", str(e.exception))
+
+ def test_invalid_point_y_equal_p(self):
+ pt = ellipticcurve.PointJacobi(curve_192, 0, curve_192.p(), 1)
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(generator_192, pt)
+
+ self.assertIn("The public point has x or y", str(e.exception))
+
+
+class TestPublicKeyVerifies(unittest.TestCase):
+ # test all the different ways that a signature can be publicly invalid
+ @classmethod
+ def setUpClass(cls):
+ gen = generator_192
+ x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+ y = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+ point = ellipticcurve.Point(gen.curve(), x, y)
+
+ cls.pub_key = Public_key(gen, point)
+
+ def test_sig_with_r_zero(self):
+ sig = Signature(0, 1)
+
+ self.assertFalse(self.pub_key.verifies(1, sig))
+
+ def test_sig_with_r_order(self):
+ sig = Signature(generator_192.order(), 1)
+
+ self.assertFalse(self.pub_key.verifies(1, sig))
+
+ def test_sig_with_s_zero(self):
+ sig = Signature(1, 0)
+
+ self.assertFalse(self.pub_key.verifies(1, sig))
+
+ def test_sig_with_s_order(self):
+ sig = Signature(1, generator_192.order())
+
+ self.assertFalse(self.pub_key.verifies(1, sig))
+
 
 class TestPrivateKey(unittest.TestCase):
 @classmethod
@@ -536,3 +655,7 @@ def test_sig_verify(args):
 assert pubkey.verifies(msg, signature)
 
 assert not pubkey.verifies(msg - 1, signature)
+
+
+def test_int_to_string_with_zero():
+ assert int_to_string(0) == b"\x00"
diff --git a/frozen_deps/ecdsa/test_eddsa.py b/frozen_deps/ecdsa/test_eddsa.py
new file mode 100644
index 0000000..7a09ad7
--- /dev/null
+++ b/frozen_deps/ecdsa/test_eddsa.py
@@ -0,0 +1,1079 @@
+import pickle
+import hashlib
+import pytest
+
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+from hypothesis import given, settings, example
+import hypothesis.strategies as st
+from .ellipticcurve import PointEdwards, INFINITY, CurveEdTw
+from .eddsa import (
+ generator_ed25519,
+ curve_ed25519,
+ generator_ed448,
+ curve_ed448,
+ PrivateKey,
+ PublicKey,
+)
+from .ecdsa import generator_256, curve_256
+from .errors import MalformedPointError
+from ._compat import a2b_hex, compat26_str
+
+
+class TestA2B_Hex(unittest.TestCase):
+ def test_invalid_input(self):
+ with self.assertRaises(ValueError):
+ a2b_hex("abcdefghi")
+
+
+def test_ed25519_curve_compare():
+ assert curve_ed25519 != curve_256
+
+
+def test_ed25519_and_ed448_compare():
+ assert curve_ed448 != curve_ed25519
+
+
+def test_ed25519_and_custom_curve_compare():
+ a = CurveEdTw(curve_ed25519.p(), -curve_ed25519.a(), 1)
+
+ assert curve_ed25519 != a
+
+
+def test_ed25519_and_almost_exact_curve_compare():
+ a = CurveEdTw(curve_ed25519.p(), curve_ed25519.a(), 1)
+
+ assert curve_ed25519 != a
+
+
+def test_ed25519_and_same_curve_params():
+ a = CurveEdTw(curve_ed25519.p(), curve_ed25519.a(), curve_ed25519.d())
+
+ assert curve_ed25519 == a
+ assert not (curve_ed25519 != a)
+
+
+def test_ed25519_contains_point():
+ g = generator_ed25519
+ assert curve_ed25519.contains_point(g.x(), g.y())
+
+
+def test_ed25519_contains_point_bad():
+ assert not curve_ed25519.contains_point(1, 1)
+
+
+def test_ed25519_double():
+ a = generator_ed25519
+
+ z = a.double()
+
+ assert isinstance(z, PointEdwards)
+
+ x2 = int(
+ "24727413235106541002554574571675588834622768167397638456726423"
+ "682521233608206"
+ )
+ y2 = int(
+ "15549675580280190176352668710449542251549572066445060580507079"
+ "593062643049417"
+ )
+
+ b = PointEdwards(curve_ed25519, x2, y2, 1, x2 * y2)
+
+ assert z == b
+ assert a != b
+
+
+def test_ed25519_add_as_double():
+ a = generator_ed25519
+
+ z = a + a
+
+ assert isinstance(z, PointEdwards)
+
+ b = generator_ed25519.double()
+
+ assert z == b
+
+
+def test_ed25519_double_infinity():
+ a = PointEdwards(curve_ed25519, 0, 1, 1, 0)
+
+ z = a.double()
+
+ assert z is INFINITY
+
+
+def test_ed25519_double_badly_encoded_infinity():
+ # invalid point, mostly to make instrumental happy
+ a = PointEdwards(curve_ed25519, 1, 1, 1, 0)
+
+ z = a.double()
+
+ assert z is INFINITY
+
+
+def test_ed25519_eq_with_different_z():
+ x = generator_ed25519.x()
+ y = generator_ed25519.y()
+ p = curve_ed25519.p()
+
+ a = PointEdwards(curve_ed25519, x * 2 % p, y * 2 % p, 2, x * y * 2 % p)
+ b = PointEdwards(curve_ed25519, x * 3 % p, y * 3 % p, 3, x * y * 3 % p)
+
+ assert a == b
+
+ assert not (a != b)
+
+
+def test_ed25519_eq_against_infinity():
+ assert generator_ed25519 != INFINITY
+
+
+def test_ed25519_eq_encoded_infinity_against_infinity():
+ a = PointEdwards(curve_ed25519, 0, 1, 1, 0)
+ assert a == INFINITY
+
+
+def test_ed25519_eq_bad_encode_of_infinity_against_infinity():
+ # technically incorrect encoding of the point at infinity, but we check
+ # both X and T, so verify that just T==0 works
+ a = PointEdwards(curve_ed25519, 1, 1, 1, 0)
+ assert a == INFINITY
+
+
+def test_ed25519_eq_against_non_Edwards_point():
+ assert generator_ed25519 != generator_256
+
+
+def test_ed25519_eq_against_negated_point():
+ g = generator_ed25519
+ neg = PointEdwards(curve_ed25519, -g.x(), g.y(), 1, -g.x() * g.y())
+ assert g != neg
+
+
+def test_ed25519_eq_x_different_y():
+ # not points on the curve, but __eq__ doesn't care
+ a = PointEdwards(curve_ed25519, 1, 1, 1, 1)
+ b = PointEdwards(curve_ed25519, 1, 2, 1, 2)
+
+ assert a != b
+
+
+def test_ed25519_test_normalisation_and_scaling():
+ x = generator_ed25519.x()
+ y = generator_ed25519.y()
+ p = curve_ed25519.p()
+
+ a = PointEdwards(curve_ed25519, x * 11 % p, y * 11 % p, 11, x * y * 11 % p)
+
+ assert a.x() == x
+ assert a.y() == y
+
+ a.scale()
+
+ assert a.x() == x
+ assert a.y() == y
+
+ a.scale() # second execution should be a noop
+
+ assert a.x() == x
+ assert a.y() == y
+
+
+def test_ed25519_add_three_times():
+ a = generator_ed25519
+
+ z = a + a + a
+
+ x3 = int(
+ "468967334644549386571235445953867877890461982801326656862413"
+ "21779790909858396"
+ )
+ y3 = int(
+ "832484377853344397649037712036920113830141722629755531674120"
+ "2210403726505172"
+ )
+
+ b = PointEdwards(curve_ed25519, x3, y3, 1, x3 * y3)
+
+ assert z == b
+
+
+def test_ed25519_add_to_infinity():
+ # generator * (order-1)
+ x1 = int(
+ "427838232691226969392843410947554224151809796397784248136826"
+ "78720006717057747"
+ )
+ y1 = int(
+ "463168356949264781694283940034751631413079938662562256157830"
+ "33603165251855960"
+ )
+ inf_m_1 = PointEdwards(curve_ed25519, x1, y1, 1, x1 * y1)
+
+ inf = inf_m_1 + generator_ed25519
+
+ assert inf is INFINITY
+
+
+def test_ed25519_add_and_mul_equivalence():
+ g = generator_ed25519
+
+ assert g + g == g * 2
+ assert g + g + g == g * 3
+
+
+def test_ed25519_add_literal_infinity():
+ g = generator_ed25519
+ z = g + INFINITY
+
+ assert z == g
+
+
+def test_ed25519_add_infinity():
+ inf = PointEdwards(curve_ed25519, 0, 1, 1, 0)
+ g = generator_ed25519
+ z = g + inf
+
+ assert z == g
+
+ z = inf + g
+
+ assert z == g
+
+
+class TestEd25519(unittest.TestCase):
+ def test_add_wrong_curves(self):
+ with self.assertRaises(ValueError) as e:
+ generator_ed25519 + generator_ed448
+
+ self.assertIn("different curve", str(e.exception))
+
+ def test_add_wrong_point_type(self):
+ with self.assertRaises(ValueError) as e:
+ generator_ed25519 + generator_256
+
+ self.assertIn("different curve", str(e.exception))
+
+
+def test_ed25519_mul_to_order_min_1():
+ x1 = int(
+ "427838232691226969392843410947554224151809796397784248136826"
+ "78720006717057747"
+ )
+ y1 = int(
+ "463168356949264781694283940034751631413079938662562256157830"
+ "33603165251855960"
+ )
+ inf_m_1 = PointEdwards(curve_ed25519, x1, y1, 1, x1 * y1)
+
+ assert generator_ed25519 * (generator_ed25519.order() - 1) == inf_m_1
+
+
+def test_ed25519_mul_to_infinity():
+ assert generator_ed25519 * generator_ed25519.order() == INFINITY
+
+
+def test_ed25519_mul_to_infinity_plus_1():
+ g = generator_ed25519
+ assert g * (g.order() + 1) == g
+
+
+def test_ed25519_mul_and_add():
+ g = generator_ed25519
+ a = g * 128
+ b = g * 64 + g * 64
+
+ assert a == b
+
+
+def test_ed25519_mul_and_add_2():
+ g = generator_ed25519
+
+ a = g * 123
+ b = g * 120 + g * 3
+
+ assert a == b
+
+
+def test_ed25519_mul_infinity():
+ inf = PointEdwards(curve_ed25519, 0, 1, 1, 0)
+
+ z = inf * 11
+
+ assert z == INFINITY
+
+
+def test_ed25519_mul_by_zero():
+ z = generator_ed25519 * 0
+
+ assert z == INFINITY
+
+
+def test_ed25519_mul_by_one():
+ z = generator_ed25519 * 1
+
+ assert z == generator_ed25519
+
+
+def test_ed25519_mul_custom_point():
+ # verify that multiplication without order set works
+
+ g = generator_ed25519
+
+ a = PointEdwards(curve_ed25519, g.x(), g.y(), 1, g.x() * g.y())
+
+ z = a * 11
+
+ assert z == g * 11
+
+
+def test_ed25519_pickle():
+ g = generator_ed25519
+ assert pickle.loads(pickle.dumps(g)) == g
+
+
+def test_ed448_eq_against_different_curve():
+ assert generator_ed25519 != generator_ed448
+
+
+def test_ed448_double():
+ g = generator_ed448
+ z = g.double()
+
+ assert isinstance(z, PointEdwards)
+
+ x2 = int(
+ "4845591495304045936995492052586696895690942404582120401876"
+ "6013278705691214670908136440114445572635086627683154494739"
+ "7859048262938744149"
+ )
+ y2 = int(
+ "4940887598674337276743026725267350893505445523037277237461"
+ "2648447308771911703729389009346215770388834286503647778745"
+ "3078312060500281069"
+ )
+
+ b = PointEdwards(curve_ed448, x2, y2, 1, x2 * y2)
+
+ assert z == b
+ assert g != b
+
+
+def test_ed448_add_as_double():
+ g = generator_ed448
+ z = g + g
+
+ b = g.double()
+
+ assert z == b
+
+
+def test_ed448_mul_as_double():
+ g = generator_ed448
+ z = g * 2
+ b = g.double()
+
+ assert z == b
+
+
+def test_ed448_add_to_infinity():
+ # generator * (order - 1)
+ x1 = int(
+ "5022586839996825903617194737881084981068517190547539260353"
+ "6473749366191269932473977736719082931859264751085238669719"
+ "1187378895383117729"
+ )
+ y1 = int(
+ "2988192100784814926760179304439306734375440401540802420959"
+ "2824137233150618983587600353687865541878473398230323350346"
+ "2500531545062832660"
+ )
+ inf_m_1 = PointEdwards(curve_ed448, x1, y1, 1, x1 * y1)
+
+ inf = inf_m_1 + generator_ed448
+
+ assert inf is INFINITY
+
+
+def test_ed448_mul_to_infinity():
+ g = generator_ed448
+ inf = g * g.order()
+
+ assert inf is INFINITY
+
+
+def test_ed448_mul_to_infinity_plus_1():
+ g = generator_ed448
+
+ z = g * (g.order() + 1)
+
+ assert z == g
+
+
+def test_ed448_add_and_mul_equivalence():
+ g = generator_ed448
+
+ assert g + g == g * 2
+ assert g + g + g == g * 3
+
+
+def test_ed25519_encode():
+ g = generator_ed25519
+ g_bytes = g.to_bytes()
+ assert len(g_bytes) == 32
+ exp_bytes = (
+ b"\x58\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+ b"\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+ )
+ assert g_bytes == exp_bytes
+
+
+def test_ed25519_decode():
+ exp_bytes = (
+ b"\x58\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+ b"\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+ )
+ a = PointEdwards.from_bytes(curve_ed25519, exp_bytes)
+
+ assert a == generator_ed25519
+
+
+class TestEdwardsMalformed(unittest.TestCase):
+ def test_invalid_point(self):
+ exp_bytes = (
+ b"\x78\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+ b"\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+ )
+ with self.assertRaises(MalformedPointError):
+ PointEdwards.from_bytes(curve_ed25519, exp_bytes)
+
+ def test_invalid_length(self):
+ exp_bytes = (
+ b"\x58\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+ b"\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+ b"\x66"
+ )
+ with self.assertRaises(MalformedPointError) as e:
+ PointEdwards.from_bytes(curve_ed25519, exp_bytes)
+
+ self.assertIn("length", str(e.exception))
+
+ def test_ed448_invalid(self):
+ exp_bytes = b"\xff" * 57
+ with self.assertRaises(MalformedPointError):
+ PointEdwards.from_bytes(curve_ed448, exp_bytes)
+
+
+def test_ed448_encode():
+ g = generator_ed448
+ g_bytes = g.to_bytes()
+ assert len(g_bytes) == 57
+ exp_bytes = (
+ b"\x14\xfa\x30\xf2\x5b\x79\x08\x98\xad\xc8\xd7\x4e\x2c\x13\xbd"
+ b"\xfd\xc4\x39\x7c\xe6\x1c\xff\xd3\x3a\xd7\xc2\xa0\x05\x1e\x9c"
+ b"\x78\x87\x40\x98\xa3\x6c\x73\x73\xea\x4b\x62\xc7\xc9\x56\x37"
+ b"\x20\x76\x88\x24\xbc\xb6\x6e\x71\x46\x3f\x69\x00"
+ )
+ assert g_bytes == exp_bytes
+
+
+def test_ed448_decode():
+ exp_bytes = (
+ b"\x14\xfa\x30\xf2\x5b\x79\x08\x98\xad\xc8\xd7\x4e\x2c\x13\xbd"
+ b"\xfd\xc4\x39\x7c\xe6\x1c\xff\xd3\x3a\xd7\xc2\xa0\x05\x1e\x9c"
+ b"\x78\x87\x40\x98\xa3\x6c\x73\x73\xea\x4b\x62\xc7\xc9\x56\x37"
+ b"\x20\x76\x88\x24\xbc\xb6\x6e\x71\x46\x3f\x69\x00"
+ )
+
+ a = PointEdwards.from_bytes(curve_ed448, exp_bytes)
+
+ assert a == generator_ed448
+
+
+class TestEdDSAEquality(unittest.TestCase):
+ def test_equal_public_points(self):
+ key1 = PublicKey(generator_ed25519, b"\x01" * 32)
+ key2 = PublicKey(generator_ed25519, b"\x01" * 32)
+
+ self.assertEqual(key1, key2)
+ self.assertFalse(key1 != key2)
+
+ def test_unequal_public_points(self):
+ key1 = PublicKey(generator_ed25519, b"\x01" * 32)
+ key2 = PublicKey(generator_ed25519, b"\x03" * 32)
+
+ self.assertNotEqual(key1, key2)
+
+ def test_unequal_to_string(self):
+ key1 = PublicKey(generator_ed25519, b"\x01" * 32)
+ key2 = b"\x01" * 32
+
+ self.assertNotEqual(key1, key2)
+
+ def test_unequal_publickey_curves(self):
+ key1 = PublicKey(generator_ed25519, b"\x01" * 32)
+ key2 = PublicKey(generator_ed448, b"\x03" * 56 + b"\x00")
+
+ self.assertNotEqual(key1, key2)
+ self.assertTrue(key1 != key2)
+
+ def test_equal_private_keys(self):
+ key1 = PrivateKey(generator_ed25519, b"\x01" * 32)
+ key2 = PrivateKey(generator_ed25519, b"\x01" * 32)
+
+ self.assertEqual(key1, key2)
+ self.assertFalse(key1 != key2)
+
+ def test_unequal_private_keys(self):
+ key1 = PrivateKey(generator_ed25519, b"\x01" * 32)
+ key2 = PrivateKey(generator_ed25519, b"\x02" * 32)
+
+ self.assertNotEqual(key1, key2)
+ self.assertTrue(key1 != key2)
+
+ def test_unequal_privatekey_to_string(self):
+ key1 = PrivateKey(generator_ed25519, b"\x01" * 32)
+ key2 = b"\x01" * 32
+
+ self.assertNotEqual(key1, key2)
+
+ def test_unequal_privatekey_curves(self):
+ key1 = PrivateKey(generator_ed25519, b"\x01" * 32)
+ key2 = PrivateKey(generator_ed448, b"\x01" * 57)
+
+ self.assertNotEqual(key1, key2)
+
+
+class TestInvalidEdDSAInputs(unittest.TestCase):
+ def test_wrong_length_of_private_key(self):
+ with self.assertRaises(ValueError):
+ PrivateKey(generator_ed25519, b"\x01" * 31)
+
+ def test_wrong_length_of_public_key(self):
+ with self.assertRaises(ValueError):
+ PublicKey(generator_ed25519, b"\x01" * 33)
+
+ def test_wrong_cofactor_curve(self):
+ ed_c = curve_ed25519
+
+ def _hash(data):
+ return hashlib.new("sha512", compat26_str(data)).digest()
+
+ curve = CurveEdTw(ed_c.p(), ed_c.a(), ed_c.d(), 1, _hash)
+ g = generator_ed25519
+ fake_gen = PointEdwards(curve, g.x(), g.y(), 1, g.x() * g.y())
+
+ with self.assertRaises(ValueError) as e:
+ PrivateKey(fake_gen, g.to_bytes())
+
+ self.assertIn("cofactor", str(e.exception))
+
+ def test_invalid_signature_length(self):
+ key = PublicKey(generator_ed25519, b"\x01" * 32)
+
+ with self.assertRaises(ValueError) as e:
+ key.verify(b"", b"\x01" * 65)
+
+ self.assertIn("length", str(e.exception))
+
+ def test_changing_public_key(self):
+ key = PublicKey(generator_ed25519, b"\x01" * 32)
+
+ g = key.point
+
+ new_g = PointEdwards(curve_ed25519, g.x(), g.y(), 1, g.x() * g.y())
+
+ key.point = new_g
+
+ self.assertEqual(g, key.point)
+
+ def test_changing_public_key_to_different_point(self):
+ key = PublicKey(generator_ed25519, b"\x01" * 32)
+
+ with self.assertRaises(ValueError) as e:
+ key.point = generator_ed25519
+
+ self.assertIn("coordinates", str(e.exception))
+
+ def test_invalid_s_value(self):
+ key = PublicKey(
+ generator_ed25519,
+ b"\xd7\x5a\x98\x01\x82\xb1\x0a\xb7\xd5\x4b\xfe\xd3\xc9\x64\x07\x3a"
+ b"\x0e\xe1\x72\xf3\xda\xa6\x23\x25\xaf\x02\x1a\x68\xf7\x07\x51\x1a",
+ )
+ sig_valid = bytearray(
+ b"\xe5\x56\x43\x00\xc3\x60\xac\x72\x90\x86\xe2\xcc\x80\x6e\x82\x8a"
+ b"\x84\x87\x7f\x1e\xb8\xe5\xd9\x74\xd8\x73\xe0\x65\x22\x49\x01\x55"
+ b"\x5f\xb8\x82\x15\x90\xa3\x3b\xac\xc6\x1e\x39\x70\x1c\xf9\xb4\x6b"
+ b"\xd2\x5b\xf5\xf0\x59\x5b\xbe\x24\x65\x51\x41\x43\x8e\x7a\x10\x0b"
+ )
+
+ self.assertTrue(key.verify(b"", sig_valid))
+
+ sig_invalid = bytearray(sig_valid)
+ sig_invalid[-1] = 0xFF
+
+ with self.assertRaises(ValueError):
+ key.verify(b"", sig_invalid)
+
+ def test_invalid_r_value(self):
+ key = PublicKey(
+ generator_ed25519,
+ b"\xd7\x5a\x98\x01\x82\xb1\x0a\xb7\xd5\x4b\xfe\xd3\xc9\x64\x07\x3a"
+ b"\x0e\xe1\x72\xf3\xda\xa6\x23\x25\xaf\x02\x1a\x68\xf7\x07\x51\x1a",
+ )
+ sig_valid = bytearray(
+ b"\xe5\x56\x43\x00\xc3\x60\xac\x72\x90\x86\xe2\xcc\x80\x6e\x82\x8a"
+ b"\x84\x87\x7f\x1e\xb8\xe5\xd9\x74\xd8\x73\xe0\x65\x22\x49\x01\x55"
+ b"\x5f\xb8\x82\x15\x90\xa3\x3b\xac\xc6\x1e\x39\x70\x1c\xf9\xb4\x6b"
+ b"\xd2\x5b\xf5\xf0\x59\x5b\xbe\x24\x65\x51\x41\x43\x8e\x7a\x10\x0b"
+ )
+
+ self.assertTrue(key.verify(b"", sig_valid))
+
+ sig_invalid = bytearray(sig_valid)
+ sig_invalid[0] = 0xE0
+
+ with self.assertRaises(ValueError):
+ key.verify(b"", sig_invalid)
+
+
+HYP_SETTINGS = dict()
+HYP_SETTINGS["max_examples"] = 10
+
+
+@settings(**HYP_SETTINGS)
+@example(1)
+@example(5) # smallest multiple that requires changing sign of x
+@given(st.integers(min_value=1, max_value=int(generator_ed25519.order() - 1)))
+def test_ed25519_encode_decode(multiple):
+ a = generator_ed25519 * multiple
+
+ b = PointEdwards.from_bytes(curve_ed25519, a.to_bytes())
+
+ assert a == b
+
+
+@settings(**HYP_SETTINGS)
+@example(1)
+@example(2) # smallest multiple that requires changing the sign of x
+@given(st.integers(min_value=1, max_value=int(generator_ed448.order() - 1)))
+def test_ed448_encode_decode(multiple):
+ a = generator_ed448 * multiple
+
+ b = PointEdwards.from_bytes(curve_ed448, a.to_bytes())
+
+ assert a == b
+
+
+@settings(**HYP_SETTINGS)
+@example(1)
+@example(2)
+@given(st.integers(min_value=1, max_value=int(generator_ed25519.order()) - 1))
+def test_ed25519_mul_precompute_vs_naf(multiple):
+ """Compare multiplication with and without precomputation."""
+ g = generator_ed25519
+ new_g = PointEdwards(curve_ed25519, g.x(), g.y(), 1, g.x() * g.y())
+
+ assert g * multiple == multiple * new_g
+
+
+# Test vectors from RFC 8032
+TEST_VECTORS = [
+ # TEST 1
+ (
+ generator_ed25519,
+ "9d61b19deffd5a60ba844af492ec2cc4" "4449c5697b326919703bac031cae7f60",
+ "d75a980182b10ab7d54bfed3c964073a" "0ee172f3daa62325af021a68f707511a",
+ "",
+ "e5564300c360ac729086e2cc806e828a"
+ "84877f1eb8e5d974d873e06522490155"
+ "5fb8821590a33bacc61e39701cf9b46b"
+ "d25bf5f0595bbe24655141438e7a100b",
+ ),
+ # TEST 2
+ (
+ generator_ed25519,
+ "4ccd089b28ff96da9db6c346ec114e0f" "5b8a319f35aba624da8cf6ed4fb8a6fb",
+ "3d4017c3e843895a92b70aa74d1b7ebc" "9c982ccf2ec4968cc0cd55f12af4660c",
+ "72",
+ "92a009a9f0d4cab8720e820b5f642540"
+ "a2b27b5416503f8fb3762223ebdb69da"
+ "085ac1e43e15996e458f3613d0f11d8c"
+ "387b2eaeb4302aeeb00d291612bb0c00",
+ ),
+ # TEST 3
+ (
+ generator_ed25519,
+ "c5aa8df43f9f837bedb7442f31dcb7b1" "66d38535076f094b85ce3a2e0b4458f7",
+ "fc51cd8e6218a1a38da47ed00230f058" "0816ed13ba3303ac5deb911548908025",
+ "af82",
+ "6291d657deec24024827e69c3abe01a3"
+ "0ce548a284743a445e3680d7db5ac3ac"
+ "18ff9b538d16f290ae67f760984dc659"
+ "4a7c15e9716ed28dc027beceea1ec40a",
+ ),
+ # TEST 1024
+ (
+ generator_ed25519,
+ "f5e5767cf153319517630f226876b86c" "8160cc583bc013744c6bf255f5cc0ee5",
+ "278117fc144c72340f67d0f2316e8386" "ceffbf2b2428c9c51fef7c597f1d426e",
+ "08b8b2b733424243760fe426a4b54908"
+ "632110a66c2f6591eabd3345e3e4eb98"
+ "fa6e264bf09efe12ee50f8f54e9f77b1"
+ "e355f6c50544e23fb1433ddf73be84d8"
+ "79de7c0046dc4996d9e773f4bc9efe57"
+ "38829adb26c81b37c93a1b270b20329d"
+ "658675fc6ea534e0810a4432826bf58c"
+ "941efb65d57a338bbd2e26640f89ffbc"
+ "1a858efcb8550ee3a5e1998bd177e93a"
+ "7363c344fe6b199ee5d02e82d522c4fe"
+ "ba15452f80288a821a579116ec6dad2b"
+ "3b310da903401aa62100ab5d1a36553e"
+ "06203b33890cc9b832f79ef80560ccb9"
+ "a39ce767967ed628c6ad573cb116dbef"
+ "efd75499da96bd68a8a97b928a8bbc10"
+ "3b6621fcde2beca1231d206be6cd9ec7"
+ "aff6f6c94fcd7204ed3455c68c83f4a4"
+ "1da4af2b74ef5c53f1d8ac70bdcb7ed1"
+ "85ce81bd84359d44254d95629e9855a9"
+ "4a7c1958d1f8ada5d0532ed8a5aa3fb2"
+ "d17ba70eb6248e594e1a2297acbbb39d"
+ "502f1a8c6eb6f1ce22b3de1a1f40cc24"
+ "554119a831a9aad6079cad88425de6bd"
+ "e1a9187ebb6092cf67bf2b13fd65f270"
+ "88d78b7e883c8759d2c4f5c65adb7553"
+ "878ad575f9fad878e80a0c9ba63bcbcc"
+ "2732e69485bbc9c90bfbd62481d9089b"
+ "eccf80cfe2df16a2cf65bd92dd597b07"
+ "07e0917af48bbb75fed413d238f5555a"
+ "7a569d80c3414a8d0859dc65a46128ba"
+ "b27af87a71314f318c782b23ebfe808b"
+ "82b0ce26401d2e22f04d83d1255dc51a"
+ "ddd3b75a2b1ae0784504df543af8969b"
+ "e3ea7082ff7fc9888c144da2af58429e"
+ "c96031dbcad3dad9af0dcbaaaf268cb8"
+ "fcffead94f3c7ca495e056a9b47acdb7"
+ "51fb73e666c6c655ade8297297d07ad1"
+ "ba5e43f1bca32301651339e22904cc8c"
+ "42f58c30c04aafdb038dda0847dd988d"
+ "cda6f3bfd15c4b4c4525004aa06eeff8"
+ "ca61783aacec57fb3d1f92b0fe2fd1a8"
+ "5f6724517b65e614ad6808d6f6ee34df"
+ "f7310fdc82aebfd904b01e1dc54b2927"
+ "094b2db68d6f903b68401adebf5a7e08"
+ "d78ff4ef5d63653a65040cf9bfd4aca7"
+ "984a74d37145986780fc0b16ac451649"
+ "de6188a7dbdf191f64b5fc5e2ab47b57"
+ "f7f7276cd419c17a3ca8e1b939ae49e4"
+ "88acba6b965610b5480109c8b17b80e1"
+ "b7b750dfc7598d5d5011fd2dcc5600a3"
+ "2ef5b52a1ecc820e308aa342721aac09"
+ "43bf6686b64b2579376504ccc493d97e"
+ "6aed3fb0f9cd71a43dd497f01f17c0e2"
+ "cb3797aa2a2f256656168e6c496afc5f"
+ "b93246f6b1116398a346f1a641f3b041"
+ "e989f7914f90cc2c7fff357876e506b5"
+ "0d334ba77c225bc307ba537152f3f161"
+ "0e4eafe595f6d9d90d11faa933a15ef1"
+ "369546868a7f3a45a96768d40fd9d034"
+ "12c091c6315cf4fde7cb68606937380d"
+ "b2eaaa707b4c4185c32eddcdd306705e"
+ "4dc1ffc872eeee475a64dfac86aba41c"
+ "0618983f8741c5ef68d3a101e8a3b8ca"
+ "c60c905c15fc910840b94c00a0b9d0",
+ "0aab4c900501b3e24d7cdf4663326a3a"
+ "87df5e4843b2cbdb67cbf6e460fec350"
+ "aa5371b1508f9f4528ecea23c436d94b"
+ "5e8fcd4f681e30a6ac00a9704a188a03",
+ ),
+ # TEST SHA(abc)
+ (
+ generator_ed25519,
+ "833fe62409237b9d62ec77587520911e" "9a759cec1d19755b7da901b96dca3d42",
+ "ec172b93ad5e563bf4932c70e1245034" "c35467ef2efd4d64ebf819683467e2bf",
+ "ddaf35a193617abacc417349ae204131"
+ "12e6fa4e89a97ea20a9eeee64b55d39a"
+ "2192992a274fc1a836ba3c23a3feebbd"
+ "454d4423643ce80e2a9ac94fa54ca49f",
+ "dc2a4459e7369633a52b1bf277839a00"
+ "201009a3efbf3ecb69bea2186c26b589"
+ "09351fc9ac90b3ecfdfbc7c66431e030"
+ "3dca179c138ac17ad9bef1177331a704",
+ ),
+ # Blank
+ (
+ generator_ed448,
+ "6c82a562cb808d10d632be89c8513ebf"
+ "6c929f34ddfa8c9f63c9960ef6e348a3"
+ "528c8a3fcc2f044e39a3fc5b94492f8f"
+ "032e7549a20098f95b",
+ "5fd7449b59b461fd2ce787ec616ad46a"
+ "1da1342485a70e1f8a0ea75d80e96778"
+ "edf124769b46c7061bd6783df1e50f6c"
+ "d1fa1abeafe8256180",
+ "",
+ "533a37f6bbe457251f023c0d88f976ae"
+ "2dfb504a843e34d2074fd823d41a591f"
+ "2b233f034f628281f2fd7a22ddd47d78"
+ "28c59bd0a21bfd3980ff0d2028d4b18a"
+ "9df63e006c5d1c2d345b925d8dc00b41"
+ "04852db99ac5c7cdda8530a113a0f4db"
+ "b61149f05a7363268c71d95808ff2e65"
+ "2600",
+ ),
+ # 1 octet
+ (
+ generator_ed448,
+ "c4eab05d357007c632f3dbb48489924d"
+ "552b08fe0c353a0d4a1f00acda2c463a"
+ "fbea67c5e8d2877c5e3bc397a659949e"
+ "f8021e954e0a12274e",
+ "43ba28f430cdff456ae531545f7ecd0a"
+ "c834a55d9358c0372bfa0c6c6798c086"
+ "6aea01eb00742802b8438ea4cb82169c"
+ "235160627b4c3a9480",
+ "03",
+ "26b8f91727bd62897af15e41eb43c377"
+ "efb9c610d48f2335cb0bd0087810f435"
+ "2541b143c4b981b7e18f62de8ccdf633"
+ "fc1bf037ab7cd779805e0dbcc0aae1cb"
+ "cee1afb2e027df36bc04dcecbf154336"
+ "c19f0af7e0a6472905e799f1953d2a0f"
+ "f3348ab21aa4adafd1d234441cf807c0"
+ "3a00",
+ ),
+ # 11 octets
+ (
+ generator_ed448,
+ "cd23d24f714274e744343237b93290f5"
+ "11f6425f98e64459ff203e8985083ffd"
+ "f60500553abc0e05cd02184bdb89c4cc"
+ "d67e187951267eb328",
+ "dcea9e78f35a1bf3499a831b10b86c90"
+ "aac01cd84b67a0109b55a36e9328b1e3"
+ "65fce161d71ce7131a543ea4cb5f7e9f"
+ "1d8b00696447001400",
+ "0c3e544074ec63b0265e0c",
+ "1f0a8888ce25e8d458a21130879b840a"
+ "9089d999aaba039eaf3e3afa090a09d3"
+ "89dba82c4ff2ae8ac5cdfb7c55e94d5d"
+ "961a29fe0109941e00b8dbdeea6d3b05"
+ "1068df7254c0cdc129cbe62db2dc957d"
+ "bb47b51fd3f213fb8698f064774250a5"
+ "028961c9bf8ffd973fe5d5c206492b14"
+ "0e00",
+ ),
+ # 12 octets
+ (
+ generator_ed448,
+ "258cdd4ada32ed9c9ff54e63756ae582"
+ "fb8fab2ac721f2c8e676a72768513d93"
+ "9f63dddb55609133f29adf86ec9929dc"
+ "cb52c1c5fd2ff7e21b",
+ "3ba16da0c6f2cc1f30187740756f5e79"
+ "8d6bc5fc015d7c63cc9510ee3fd44adc"
+ "24d8e968b6e46e6f94d19b945361726b"
+ "d75e149ef09817f580",
+ "64a65f3cdedcdd66811e2915",
+ "7eeeab7c4e50fb799b418ee5e3197ff6"
+ "bf15d43a14c34389b59dd1a7b1b85b4a"
+ "e90438aca634bea45e3a2695f1270f07"
+ "fdcdf7c62b8efeaf00b45c2c96ba457e"
+ "b1a8bf075a3db28e5c24f6b923ed4ad7"
+ "47c3c9e03c7079efb87cb110d3a99861"
+ "e72003cbae6d6b8b827e4e6c143064ff"
+ "3c00",
+ ),
+ # 13 octets
+ (
+ generator_ed448,
+ "7ef4e84544236752fbb56b8f31a23a10"
+ "e42814f5f55ca037cdcc11c64c9a3b29"
+ "49c1bb60700314611732a6c2fea98eeb"
+ "c0266a11a93970100e",
+ "b3da079b0aa493a5772029f0467baebe"
+ "e5a8112d9d3a22532361da294f7bb381"
+ "5c5dc59e176b4d9f381ca0938e13c6c0"
+ "7b174be65dfa578e80",
+ "64a65f3cdedcdd66811e2915e7",
+ "6a12066f55331b6c22acd5d5bfc5d712"
+ "28fbda80ae8dec26bdd306743c5027cb"
+ "4890810c162c027468675ecf645a8317"
+ "6c0d7323a2ccde2d80efe5a1268e8aca"
+ "1d6fbc194d3f77c44986eb4ab4177919"
+ "ad8bec33eb47bbb5fc6e28196fd1caf5"
+ "6b4e7e0ba5519234d047155ac727a105"
+ "3100",
+ ),
+ # 64 octets
+ (
+ generator_ed448,
+ "d65df341ad13e008567688baedda8e9d"
+ "cdc17dc024974ea5b4227b6530e339bf"
+ "f21f99e68ca6968f3cca6dfe0fb9f4fa"
+ "b4fa135d5542ea3f01",
+ "df9705f58edbab802c7f8363cfe5560a"
+ "b1c6132c20a9f1dd163483a26f8ac53a"
+ "39d6808bf4a1dfbd261b099bb03b3fb5"
+ "0906cb28bd8a081f00",
+ "bd0f6a3747cd561bdddf4640a332461a"
+ "4a30a12a434cd0bf40d766d9c6d458e5"
+ "512204a30c17d1f50b5079631f64eb31"
+ "12182da3005835461113718d1a5ef944",
+ "554bc2480860b49eab8532d2a533b7d5"
+ "78ef473eeb58c98bb2d0e1ce488a98b1"
+ "8dfde9b9b90775e67f47d4a1c3482058"
+ "efc9f40d2ca033a0801b63d45b3b722e"
+ "f552bad3b4ccb667da350192b61c508c"
+ "f7b6b5adadc2c8d9a446ef003fb05cba"
+ "5f30e88e36ec2703b349ca229c267083"
+ "3900",
+ ),
+ # 256 octets
+ (
+ generator_ed448,
+ "2ec5fe3c17045abdb136a5e6a913e32a"
+ "b75ae68b53d2fc149b77e504132d3756"
+ "9b7e766ba74a19bd6162343a21c8590a"
+ "a9cebca9014c636df5",
+ "79756f014dcfe2079f5dd9e718be4171"
+ "e2ef2486a08f25186f6bff43a9936b9b"
+ "fe12402b08ae65798a3d81e22e9ec80e"
+ "7690862ef3d4ed3a00",
+ "15777532b0bdd0d1389f636c5f6b9ba7"
+ "34c90af572877e2d272dd078aa1e567c"
+ "fa80e12928bb542330e8409f31745041"
+ "07ecd5efac61ae7504dabe2a602ede89"
+ "e5cca6257a7c77e27a702b3ae39fc769"
+ "fc54f2395ae6a1178cab4738e543072f"
+ "c1c177fe71e92e25bf03e4ecb72f47b6"
+ "4d0465aaea4c7fad372536c8ba516a60"
+ "39c3c2a39f0e4d832be432dfa9a706a6"
+ "e5c7e19f397964ca4258002f7c0541b5"
+ "90316dbc5622b6b2a6fe7a4abffd9610"
+ "5eca76ea7b98816af0748c10df048ce0"
+ "12d901015a51f189f3888145c03650aa"
+ "23ce894c3bd889e030d565071c59f409"
+ "a9981b51878fd6fc110624dcbcde0bf7"
+ "a69ccce38fabdf86f3bef6044819de11",
+ "c650ddbb0601c19ca11439e1640dd931"
+ "f43c518ea5bea70d3dcde5f4191fe53f"
+ "00cf966546b72bcc7d58be2b9badef28"
+ "743954e3a44a23f880e8d4f1cfce2d7a"
+ "61452d26da05896f0a50da66a239a8a1"
+ "88b6d825b3305ad77b73fbac0836ecc6"
+ "0987fd08527c1a8e80d5823e65cafe2a"
+ "3d00",
+ ),
+ # 1023 octets
+ (
+ generator_ed448,
+ "872d093780f5d3730df7c212664b37b8"
+ "a0f24f56810daa8382cd4fa3f77634ec"
+ "44dc54f1c2ed9bea86fafb7632d8be19"
+ "9ea165f5ad55dd9ce8",
+ "a81b2e8a70a5ac94ffdbcc9badfc3feb"
+ "0801f258578bb114ad44ece1ec0e799d"
+ "a08effb81c5d685c0c56f64eecaef8cd"
+ "f11cc38737838cf400",
+ "6ddf802e1aae4986935f7f981ba3f035"
+ "1d6273c0a0c22c9c0e8339168e675412"
+ "a3debfaf435ed651558007db4384b650"
+ "fcc07e3b586a27a4f7a00ac8a6fec2cd"
+ "86ae4bf1570c41e6a40c931db27b2faa"
+ "15a8cedd52cff7362c4e6e23daec0fbc"
+ "3a79b6806e316efcc7b68119bf46bc76"
+ "a26067a53f296dafdbdc11c77f7777e9"
+ "72660cf4b6a9b369a6665f02e0cc9b6e"
+ "dfad136b4fabe723d2813db3136cfde9"
+ "b6d044322fee2947952e031b73ab5c60"
+ "3349b307bdc27bc6cb8b8bbd7bd32321"
+ "9b8033a581b59eadebb09b3c4f3d2277"
+ "d4f0343624acc817804728b25ab79717"
+ "2b4c5c21a22f9c7839d64300232eb66e"
+ "53f31c723fa37fe387c7d3e50bdf9813"
+ "a30e5bb12cf4cd930c40cfb4e1fc6225"
+ "92a49588794494d56d24ea4b40c89fc0"
+ "596cc9ebb961c8cb10adde976a5d602b"
+ "1c3f85b9b9a001ed3c6a4d3b1437f520"
+ "96cd1956d042a597d561a596ecd3d173"
+ "5a8d570ea0ec27225a2c4aaff26306d1"
+ "526c1af3ca6d9cf5a2c98f47e1c46db9"
+ "a33234cfd4d81f2c98538a09ebe76998"
+ "d0d8fd25997c7d255c6d66ece6fa56f1"
+ "1144950f027795e653008f4bd7ca2dee"
+ "85d8e90f3dc315130ce2a00375a318c7"
+ "c3d97be2c8ce5b6db41a6254ff264fa6"
+ "155baee3b0773c0f497c573f19bb4f42"
+ "40281f0b1f4f7be857a4e59d416c06b4"
+ "c50fa09e1810ddc6b1467baeac5a3668"
+ "d11b6ecaa901440016f389f80acc4db9"
+ "77025e7f5924388c7e340a732e554440"
+ "e76570f8dd71b7d640b3450d1fd5f041"
+ "0a18f9a3494f707c717b79b4bf75c984"
+ "00b096b21653b5d217cf3565c9597456"
+ "f70703497a078763829bc01bb1cbc8fa"
+ "04eadc9a6e3f6699587a9e75c94e5bab"
+ "0036e0b2e711392cff0047d0d6b05bd2"
+ "a588bc109718954259f1d86678a579a3"
+ "120f19cfb2963f177aeb70f2d4844826"
+ "262e51b80271272068ef5b3856fa8535"
+ "aa2a88b2d41f2a0e2fda7624c2850272"
+ "ac4a2f561f8f2f7a318bfd5caf969614"
+ "9e4ac824ad3460538fdc25421beec2cc"
+ "6818162d06bbed0c40a387192349db67"
+ "a118bada6cd5ab0140ee273204f628aa"
+ "d1c135f770279a651e24d8c14d75a605"
+ "9d76b96a6fd857def5e0b354b27ab937"
+ "a5815d16b5fae407ff18222c6d1ed263"
+ "be68c95f32d908bd895cd76207ae7264"
+ "87567f9a67dad79abec316f683b17f2d"
+ "02bf07e0ac8b5bc6162cf94697b3c27c"
+ "d1fea49b27f23ba2901871962506520c"
+ "392da8b6ad0d99f7013fbc06c2c17a56"
+ "9500c8a7696481c1cd33e9b14e40b82e"
+ "79a5f5db82571ba97bae3ad3e0479515"
+ "bb0e2b0f3bfcd1fd33034efc6245eddd"
+ "7ee2086ddae2600d8ca73e214e8c2b0b"
+ "db2b047c6a464a562ed77b73d2d841c4"
+ "b34973551257713b753632efba348169"
+ "abc90a68f42611a40126d7cb21b58695"
+ "568186f7e569d2ff0f9e745d0487dd2e"
+ "b997cafc5abf9dd102e62ff66cba87",
+ "e301345a41a39a4d72fff8df69c98075"
+ "a0cc082b802fc9b2b6bc503f926b65bd"
+ "df7f4c8f1cb49f6396afc8a70abe6d8a"
+ "ef0db478d4c6b2970076c6a0484fe76d"
+ "76b3a97625d79f1ce240e7c576750d29"
+ "5528286f719b413de9ada3e8eb78ed57"
+ "3603ce30d8bb761785dc30dbc320869e"
+ "1a00",
+ ),
+]
+
+
+[email protected](
+ "generator,private_key,public_key,message,signature",
+ TEST_VECTORS,
+)
+def test_vectors(generator, private_key, public_key, message, signature):
+ private_key = a2b_hex(private_key)
+ public_key = a2b_hex(public_key)
+ message = a2b_hex(message)
+ signature = a2b_hex(signature)
+
+ sig_key = PrivateKey(generator, private_key)
+ ver_key = PublicKey(generator, public_key)
+
+ assert sig_key.public_key().public_key() == ver_key.public_key()
+
+ gen_sig = sig_key.sign(message)
+
+ assert gen_sig == signature
+
+ assert ver_key.verify(message, signature)
diff --git a/frozen_deps/ecdsa/test_ellipticcurve.py b/frozen_deps/ecdsa/test_ellipticcurve.py
index def53b2..85faef4 100644
--- a/frozen_deps/ecdsa/test_ellipticcurve.py
+++ b/frozen_deps/ecdsa/test_ellipticcurve.py
@@ -1,5 +1,4 @@
 import pytest
-from six import print_
 
 try:
 import unittest2 as unittest
@@ -96,7 +95,7 @@ class TestCurve(unittest.TestCase):
 self.assertEqual(len(set((c_23, eq1, eq2, eq3))), 1)
 self.assertEqual(len(set((c_23, ne1, ne2, ne3))), 4)
 self.assertDictEqual({c_23: None}, {eq1: None})
- self.assertTrue(eq2 in {eq3: None})
+ self.assertIn(eq2, {eq3: None})
 
 
 class TestPoint(unittest.TestCase):
diff --git a/frozen_deps/ecdsa/test_jacobi.py b/frozen_deps/ecdsa/test_jacobi.py
index 43ed6c1..1f52804 100644
--- a/frozen_deps/ecdsa/test_jacobi.py
+++ b/frozen_deps/ecdsa/test_jacobi.py
@@ -5,18 +5,31 @@ try:
 except ImportError:
 import unittest
 
+import os
+import sys
+import signal
+import pytest
+import threading
+import platform
 import hypothesis.strategies as st
 from hypothesis import given, assume, settings, example
 
-from .ellipticcurve import CurveFp, Point, PointJacobi, INFINITY
+from .ellipticcurve import CurveFp, PointJacobi, INFINITY
 from .ecdsa import (
 generator_256,
 curve_256,
 generator_224,
 generator_brainpoolp160r1,
 curve_brainpoolp160r1,
+ generator_112r2,
 )
 from .numbertheory import inverse_mod
+from .util import randrange
+
+
+NO_OLD_SETTINGS = {}
+if sys.version_info > (2, 7): # pragma: no branch
+ NO_OLD_SETTINGS["deadline"] = 5000
 
 
 class TestJacobi(unittest.TestCase):
@@ -210,7 +223,8 @@ class TestJacobi(unittest.TestCase):
 @example(0)
 @example(int(generator_brainpoolp160r1.order()))
 def test_precompute(self, mul):
- precomp = PointJacobi.from_affine(generator_brainpoolp160r1, True)
+ precomp = generator_brainpoolp160r1
+ self.assertTrue(precomp._PointJacobi__precompute)
 pj = PointJacobi.from_affine(generator_brainpoolp160r1)
 
 a = precomp * mul
@@ -311,6 +325,29 @@ class TestJacobi(unittest.TestCase):
 
 self.assertEqual(c, j_g * (a_mul + b_mul))
 
+ def test_add_same_scale_points_static(self):
+ j_g = generator_brainpoolp160r1
+ p = curve_brainpoolp160r1.p()
+ a = j_g * 11
+ a.scale()
+ z1 = 13
+ x = PointJacobi(
+ curve_brainpoolp160r1,
+ a.x() * z1**2 % p,
+ a.y() * z1**3 % p,
+ z1,
+ )
+ y = PointJacobi(
+ curve_brainpoolp160r1,
+ a.x() * z1**2 % p,
+ a.y() * z1**3 % p,
+ z1,
+ )
+
+ c = a + a
+
+ self.assertEqual(c, x + y)
+
 @settings(max_examples=14)
 @given(
 st.integers(
@@ -362,11 +399,40 @@ class TestJacobi(unittest.TestCase):
 
 self.assertEqual(c, j_g * (a_mul + b_mul))
 
+ def test_add_different_scale_points_static(self):
+ j_g = generator_brainpoolp160r1
+ p = curve_brainpoolp160r1.p()
+ a = j_g * 11
+ a.scale()
+ z1 = 13
+ x = PointJacobi(
+ curve_brainpoolp160r1,
+ a.x() * z1**2 % p,
+ a.y() * z1**3 % p,
+ z1,
+ )
+ z2 = 29
+ y = PointJacobi(
+ curve_brainpoolp160r1,
+ a.x() * z2**2 % p,
+ a.y() * z2**3 % p,
+ z2,
+ )
+
+ c = a + a
+
+ self.assertEqual(c, x + y)
+
 def test_add_point_3_times(self):
 j_g = PointJacobi.from_affine(generator_256)
 
 self.assertEqual(j_g * 3, j_g + j_g + j_g)
 
+ def test_mul_without_order(self):
+ j_g = PointJacobi(curve_256, generator_256.x(), generator_256.y(), 1)
+
+ self.assertEqual(j_g * generator_256.order(), INFINITY)
+
 def test_mul_add_inf(self):
 j_g = PointJacobi.from_affine(generator_256)
 
@@ -378,7 +444,7 @@ class TestJacobi(unittest.TestCase):
 self.assertEqual(j_g * 2, j_g.mul_add(1, j_g, 1))
 
 def test_mul_add_precompute(self):
- j_g = PointJacobi.from_affine(generator_256, True)
+ j_g = PointJacobi.from_affine(generator_brainpoolp160r1, True)
 b = PointJacobi.from_affine(j_g * 255, True)
 
 self.assertEqual(j_g * 256, j_g + b)
@@ -386,7 +452,7 @@ class TestJacobi(unittest.TestCase):
 self.assertEqual(j_g * (5 + 255 * 7), j_g.mul_add(5, b, 7))
 
 def test_mul_add_precompute_large(self):
- j_g = PointJacobi.from_affine(generator_256, True)
+ j_g = PointJacobi.from_affine(generator_brainpoolp160r1, True)
 b = PointJacobi.from_affine(j_g * 255, True)
 
 self.assertEqual(j_g * 256, j_g + b)
@@ -405,6 +471,21 @@ class TestJacobi(unittest.TestCase):
 
 self.assertEqual(a, b)
 
+ def test_mul_add_differnt(self):
+ j_g = PointJacobi.from_affine(generator_256)
+
+ w_a = j_g * 2
+
+ self.assertEqual(j_g.mul_add(1, w_a, 1), j_g * 3)
+
+ def test_mul_add_slightly_different(self):
+ j_g = PointJacobi.from_affine(generator_256)
+
+ w_a = j_g * 2
+ w_b = j_g * 3
+
+ self.assertEqual(w_a.mul_add(1, w_b, 3), w_a * 1 + w_b * 3)
+
 def test_mul_add(self):
 j_g = PointJacobi.from_affine(generator_256)
 
@@ -428,11 +509,149 @@ class TestJacobi(unittest.TestCase):
 j_g * (0xFF00 + 255 * 0xF0F0), j_g.mul_add(0xFF00, b, 0xF0F0)
 )
 
+ def test_mul_add_with_infinity_as_result(self):
+ j_g = PointJacobi.from_affine(generator_256)
+
+ order = generator_256.order()
+
+ b = PointJacobi.from_affine(generator_256 * 256)
+
+ self.assertEqual(j_g.mul_add(order % 256, b, order // 256), INFINITY)
+
+ def test_mul_add_without_order(self):
+ j_g = PointJacobi(curve_256, generator_256.x(), generator_256.y(), 1)
+
+ order = generator_256.order()
+
+ w_b = generator_256 * 34
+ w_b.scale()
+
+ b = PointJacobi(curve_256, w_b.x(), w_b.y(), 1)
+
+ self.assertEqual(j_g.mul_add(order % 34, b, order // 34), INFINITY)
+
+ def test_mul_add_with_doubled_negation_of_itself(self):
+ j_g = PointJacobi.from_affine(generator_256 * 17)
+
+ dbl_neg = 2 * (-j_g)
+
+ self.assertEqual(j_g.mul_add(4, dbl_neg, 2), INFINITY)
+
 def test_equality(self):
 pj1 = PointJacobi(curve=CurveFp(23, 1, 1, 1), x=2, y=3, z=1, order=1)
 pj2 = PointJacobi(curve=CurveFp(23, 1, 1, 1), x=2, y=3, z=1, order=1)
 self.assertEqual(pj1, pj2)
 
+ def test_equality_with_invalid_object(self):
+ j_g = PointJacobi.from_affine(generator_256)
+
+ self.assertNotEqual(j_g, 12)
+
+ def test_equality_with_wrong_curves(self):
+ p_a = PointJacobi.from_affine(generator_256)
+ p_b = PointJacobi.from_affine(generator_224)
+
+ self.assertNotEqual(p_a, p_b)
+
 def test_pickle(self):
 pj = PointJacobi(curve=CurveFp(23, 1, 1, 1), x=2, y=3, z=1, order=1)
 self.assertEqual(pickle.loads(pickle.dumps(pj)), pj)
+
+ @settings(**NO_OLD_SETTINGS)
+ @given(st.integers(min_value=1, max_value=10))
+ def test_multithreading(self, thread_num):
+ # ensure that generator's precomputation table is filled
+ generator_112r2 * 2
+
+ # create a fresh point that doesn't have a filled precomputation table
+ gen = generator_112r2
+ gen = PointJacobi(gen.curve(), gen.x(), gen.y(), 1, gen.order(), True)
+
+ self.assertEqual(gen._PointJacobi__precompute, [])
+
+ def runner(generator):
+ order = generator.order()
+ for _ in range(10):
+ generator * randrange(order)
+
+ threads = []
+ for _ in range(thread_num):
+ threads.append(threading.Thread(target=runner, args=(gen,)))
+
+ for t in threads:
+ t.start()
+
+ runner(gen)
+
+ for t in threads:
+ t.join()
+
+ self.assertEqual(
+ gen._PointJacobi__precompute,
+ generator_112r2._PointJacobi__precompute,
+ )
+
+ @pytest.mark.skipif(
+ platform.system() == "Windows",
+ reason="there are no signals on Windows",
+ )
+ def test_multithreading_with_interrupts(self):
+ thread_num = 10
+ # ensure that generator's precomputation table is filled
+ generator_112r2 * 2
+
+ # create a fresh point that doesn't have a filled precomputation table
+ gen = generator_112r2
+ gen = PointJacobi(gen.curve(), gen.x(), gen.y(), 1, gen.order(), True)
+
+ self.assertEqual(gen._PointJacobi__precompute, [])
+
+ def runner(generator):
+ order = generator.order()
+ for _ in range(50):
+ generator * randrange(order)
+
+ def interrupter(barrier_start, barrier_end, lock_exit):
+ # wait until MainThread can handle KeyboardInterrupt
+ barrier_start.release()
+ barrier_end.acquire()
+ os.kill(os.getpid(), signal.SIGINT)
+ lock_exit.release()
+
+ threads = []
+ for _ in range(thread_num):
+ threads.append(threading.Thread(target=runner, args=(gen,)))
+
+ barrier_start = threading.Lock()
+ barrier_start.acquire()
+ barrier_end = threading.Lock()
+ barrier_end.acquire()
+ lock_exit = threading.Lock()
+ lock_exit.acquire()
+
+ threads.append(
+ threading.Thread(
+ target=interrupter,
+ args=(barrier_start, barrier_end, lock_exit),
+ )
+ )
+
+ for t in threads:
+ t.start()
+
+ with self.assertRaises(KeyboardInterrupt):
+ # signal to interrupter that we can now handle the signal
+ barrier_start.acquire()
+ barrier_end.release()
+ runner(gen)
+ # use the lock to ensure we never go past the scope of
+ # assertRaises before the os.kill is called
+ lock_exit.acquire()
+
+ for t in threads:
+ t.join()
+
+ self.assertEqual(
+ gen._PointJacobi__precompute,
+ generator_112r2._PointJacobi__precompute,
+ )
diff --git a/frozen_deps/ecdsa/test_keys.py b/frozen_deps/ecdsa/test_keys.py
index 406a5bf..25386b1 100644
--- a/frozen_deps/ecdsa/test_keys.py
+++ b/frozen_deps/ecdsa/test_keys.py
@@ -8,14 +8,19 @@ try:
 except NameError:
 buffer = memoryview
 
+import os
 import array
-import six
-import sys
 import pytest
 import hashlib
 
-from .keys import VerifyingKey, SigningKey
-from .der import unpem
+from .keys import VerifyingKey, SigningKey, MalformedPointError
+from .der import (
+ unpem,
+ UnexpectedDER,
+ encode_sequence,
+ encode_oid,
+ encode_bitstring,
+)
 from .util import (
 sigencode_string,
 sigencode_der,
@@ -24,7 +29,9 @@ from .util import (
 sigdecode_der,
 sigdecode_strings,
 )
-from .curves import NIST256p
+from .curves import NIST256p, Curve, BRAINPOOLP160r1, Ed25519, Ed448
+from .ellipticcurve import Point, PointJacobi, CurveFp, INFINITY
+from .ecdsa import generator_brainpoolp160r1
 
 
 class TestVerifyingKeyFromString(unittest.TestCase):
@@ -150,6 +157,55 @@ class TestVerifyingKeyFromDer(unittest.TestCase):
 )
 cls.vk2 = VerifyingKey.from_pem(key_str)
 
+ cls.sk2 = SigningKey.generate(vk.curve)
+
+ def test_load_key_with_explicit_parameters(self):
+ pub_key_str = (
+ "-----BEGIN PUBLIC KEY-----\n"
+ "MIIBSzCCAQMGByqGSM49AgEwgfcCAQEwLAYHKoZIzj0BAQIhAP////8AAAABAAAA\n"
+ "AAAAAAAAAAAA////////////////MFsEIP////8AAAABAAAAAAAAAAAAAAAA////\n"
+ "///////////8BCBaxjXYqjqT57PrvVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMVAMSd\n"
+ "NgiG5wSTamZ44ROdJreBn36QBEEEaxfR8uEsQkf4vOblY6RA8ncDfYEt6zOg9KE5\n"
+ "RdiYwpZP40Li/hp/m47n60p8D54WK84zV2sxXs7LtkBoN79R9QIhAP////8AAAAA\n"
+ "//////////+85vqtpxeehPO5ysL8YyVRAgEBA0IABIr1UkgYs5jmbFc7it1/YI2X\n"
+ "T//IlaEjMNZft1owjqpBYH2ErJHk4U5Pp4WvWq1xmHwIZlsH7Ig4KmefCfR6SmU=\n"
+ "-----END PUBLIC KEY-----"
+ )
+ pk = VerifyingKey.from_pem(pub_key_str)
+
+ pk_exp = VerifyingKey.from_string(
+ b"\x04\x8a\xf5\x52\x48\x18\xb3\x98\xe6\x6c\x57\x3b\x8a\xdd\x7f"
+ b"\x60\x8d\x97\x4f\xff\xc8\x95\xa1\x23\x30\xd6\x5f\xb7\x5a\x30"
+ b"\x8e\xaa\x41\x60\x7d\x84\xac\x91\xe4\xe1\x4e\x4f\xa7\x85\xaf"
+ b"\x5a\xad\x71\x98\x7c\x08\x66\x5b\x07\xec\x88\x38\x2a\x67\x9f"
+ b"\x09\xf4\x7a\x4a\x65",
+ curve=NIST256p,
+ )
+ self.assertEqual(pk, pk_exp)
+
+ def test_load_key_with_explicit_with_explicit_disabled(self):
+ pub_key_str = (
+ "-----BEGIN PUBLIC KEY-----\n"
+ "MIIBSzCCAQMGByqGSM49AgEwgfcCAQEwLAYHKoZIzj0BAQIhAP////8AAAABAAAA\n"
+ "AAAAAAAAAAAA////////////////MFsEIP////8AAAABAAAAAAAAAAAAAAAA////\n"
+ "///////////8BCBaxjXYqjqT57PrvVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMVAMSd\n"
+ "NgiG5wSTamZ44ROdJreBn36QBEEEaxfR8uEsQkf4vOblY6RA8ncDfYEt6zOg9KE5\n"
+ "RdiYwpZP40Li/hp/m47n60p8D54WK84zV2sxXs7LtkBoN79R9QIhAP////8AAAAA\n"
+ "//////////+85vqtpxeehPO5ysL8YyVRAgEBA0IABIr1UkgYs5jmbFc7it1/YI2X\n"
+ "T//IlaEjMNZft1owjqpBYH2ErJHk4U5Pp4WvWq1xmHwIZlsH7Ig4KmefCfR6SmU=\n"
+ "-----END PUBLIC KEY-----"
+ )
+ with self.assertRaises(UnexpectedDER):
+ VerifyingKey.from_pem(
+ pub_key_str, valid_curve_encodings=["named_curve"]
+ )
+
+ def test_load_key_with_disabled_format(self):
+ with self.assertRaises(MalformedPointError) as e:
+ VerifyingKey.from_der(self.key_bytes, valid_encodings=["raw"])
+
+ self.assertIn("enabled (raw) encodings", str(e.exception))
+
 def test_custom_hashfunc(self):
 vk = VerifyingKey.from_der(self.key_bytes, hashlib.sha256)
 
@@ -201,6 +257,218 @@ class TestVerifyingKeyFromDer(unittest.TestCase):
 def test_inequality_on_verifying_keys_not_implemented(self):
 self.assertNotEqual(self.vk, None)
 
+ def test_VerifyingKey_inequality_on_same_curve(self):
+ self.assertNotEqual(self.vk, self.sk2.verifying_key)
+
+ def test_SigningKey_inequality_on_same_curve(self):
+ self.assertNotEqual(self.sk, self.sk2)
+
+ def test_inequality_on_wrong_types(self):
+ self.assertNotEqual(self.vk, self.sk)
+
+ def test_from_public_point_old(self):
+ pj = self.vk.pubkey.point
+ point = Point(pj.curve(), pj.x(), pj.y())
+
+ vk = VerifyingKey.from_public_point(point, self.vk.curve)
+
+ self.assertEqual(vk, self.vk)
+
+ def test_ed25519_VerifyingKey_repr__(self):
+ sk = SigningKey.from_string(Ed25519.generator.to_bytes(), Ed25519)
+ string = repr(sk.verifying_key)
+
+ self.assertEqual(
+ "VerifyingKey.from_string("
+ "bytearray(b'K\\x0c\\xfbZH\\x8e\\x8c\\x8c\\x07\\xee\\xda\\xfb"
+ "\\xe1\\x97\\xcd\\x90\\x18\\x02\\x15h]\\xfe\\xbe\\xcbB\\xba\\xe6r"
+ "\\x10\\xae\\xf1P'), Ed25519, None)",
+ string,
+ )
+
+ def test_edwards_from_public_point(self):
+ point = Ed25519.generator
+ with self.assertRaises(ValueError) as e:
+ VerifyingKey.from_public_point(point, Ed25519)
+
+ self.assertIn("incompatible with Edwards", str(e.exception))
+
+ def test_edwards_precompute_no_side_effect(self):
+ sk = SigningKey.from_string(Ed25519.generator.to_bytes(), Ed25519)
+ vk = sk.verifying_key
+ vk2 = VerifyingKey.from_string(vk.to_string(), Ed25519)
+ vk.precompute()
+
+ self.assertEqual(vk, vk2)
+
+ def test_parse_malfomed_eddsa_der_pubkey(self):
+ der_str = encode_sequence(
+ encode_sequence(encode_oid(*Ed25519.oid)),
+ encode_bitstring(bytes(Ed25519.generator.to_bytes()), 0),
+ encode_bitstring(b"\x00", 0),
+ )
+
+ with self.assertRaises(UnexpectedDER) as e:
+ VerifyingKey.from_der(der_str)
+
+ self.assertIn("trailing junk after public key", str(e.exception))
+
+ def test_edwards_from_public_key_recovery(self):
+ with self.assertRaises(ValueError) as e:
+ VerifyingKey.from_public_key_recovery(b"", b"", Ed25519)
+
+ self.assertIn("unsupported for Edwards", str(e.exception))
+
+ def test_edwards_from_public_key_recovery_with_digest(self):
+ with self.assertRaises(ValueError) as e:
+ VerifyingKey.from_public_key_recovery_with_digest(
+ b"", b"", Ed25519
+ )
+
+ self.assertIn("unsupported for Edwards", str(e.exception))
+
+ def test_load_ed25519_from_pem(self):
+ vk_pem = (
+ "-----BEGIN PUBLIC KEY-----\n"
+ "MCowBQYDK2VwAyEAIwBQ0NZkIiiO41WJfm5BV42u3kQm7lYnvIXmCy8qy2U=\n"
+ "-----END PUBLIC KEY-----\n"
+ )
+
+ vk = VerifyingKey.from_pem(vk_pem)
+
+ self.assertIsInstance(vk.curve, Curve)
+ self.assertIs(vk.curve, Ed25519)
+
+ vk_str = (
+ b"\x23\x00\x50\xd0\xd6\x64\x22\x28\x8e\xe3\x55\x89\x7e\x6e\x41\x57"
+ b"\x8d\xae\xde\x44\x26\xee\x56\x27\xbc\x85\xe6\x0b\x2f\x2a\xcb\x65"
+ )
+
+ vk_2 = VerifyingKey.from_string(vk_str, Ed25519)
+
+ self.assertEqual(vk, vk_2)
+
+ def test_export_ed255_to_pem(self):
+ vk_str = (
+ b"\x23\x00\x50\xd0\xd6\x64\x22\x28\x8e\xe3\x55\x89\x7e\x6e\x41\x57"
+ b"\x8d\xae\xde\x44\x26\xee\x56\x27\xbc\x85\xe6\x0b\x2f\x2a\xcb\x65"
+ )
+
+ vk = VerifyingKey.from_string(vk_str, Ed25519)
+
+ vk_pem = (
+ b"-----BEGIN PUBLIC KEY-----\n"
+ b"MCowBQYDK2VwAyEAIwBQ0NZkIiiO41WJfm5BV42u3kQm7lYnvIXmCy8qy2U=\n"
+ b"-----END PUBLIC KEY-----\n"
+ )
+
+ self.assertEqual(vk_pem, vk.to_pem())
+
+ def test_ed25519_export_import(self):
+ sk = SigningKey.generate(Ed25519)
+ vk = sk.verifying_key
+
+ vk2 = VerifyingKey.from_pem(vk.to_pem())
+
+ self.assertEqual(vk, vk2)
+
+ def test_ed25519_sig_verify(self):
+ vk_pem = (
+ "-----BEGIN PUBLIC KEY-----\n"
+ "MCowBQYDK2VwAyEAIwBQ0NZkIiiO41WJfm5BV42u3kQm7lYnvIXmCy8qy2U=\n"
+ "-----END PUBLIC KEY-----\n"
+ )
+
+ vk = VerifyingKey.from_pem(vk_pem)
+
+ data = b"data\n"
+
+ # signature created by OpenSSL 3.0.0 beta1
+ sig = (
+ b"\x64\x47\xab\x6a\x33\xcd\x79\x45\xad\x98\x11\x6c\xb9\xf2\x20\xeb"
+ b"\x90\xd6\x50\xe3\xc7\x8f\x9f\x60\x10\xec\x75\xe0\x2f\x27\xd3\x96"
+ b"\xda\xe8\x58\x7f\xe0\xfe\x46\x5c\x81\xef\x50\xec\x29\x9f\xae\xd5"
+ b"\xad\x46\x3c\x91\x68\x83\x4d\xea\x8d\xa8\x19\x04\x04\x79\x03\x0b"
+ )
+
+ self.assertTrue(vk.verify(sig, data))
+
+ def test_ed448_from_pem(self):
+ pem_str = (
+ "-----BEGIN PUBLIC KEY-----\n"
+ "MEMwBQYDK2VxAzoAeQtetSu7CMEzE+XWB10Bg47LCA0giNikOxHzdp+tZ/eK/En0\n"
+ "dTdYD2ll94g58MhSnBiBQB9A1MMA\n"
+ "-----END PUBLIC KEY-----\n"
+ )
+
+ vk = VerifyingKey.from_pem(pem_str)
+
+ self.assertIsInstance(vk.curve, Curve)
+ self.assertIs(vk.curve, Ed448)
+
+ vk_str = (
+ b"\x79\x0b\x5e\xb5\x2b\xbb\x08\xc1\x33\x13\xe5\xd6\x07\x5d\x01\x83"
+ b"\x8e\xcb\x08\x0d\x20\x88\xd8\xa4\x3b\x11\xf3\x76\x9f\xad\x67\xf7"
+ b"\x8a\xfc\x49\xf4\x75\x37\x58\x0f\x69\x65\xf7\x88\x39\xf0\xc8\x52"
+ b"\x9c\x18\x81\x40\x1f\x40\xd4\xc3\x00"
+ )
+
+ vk2 = VerifyingKey.from_string(vk_str, Ed448)
+
+ self.assertEqual(vk, vk2)
+
+ def test_ed448_to_pem(self):
+ vk_str = (
+ b"\x79\x0b\x5e\xb5\x2b\xbb\x08\xc1\x33\x13\xe5\xd6\x07\x5d\x01\x83"
+ b"\x8e\xcb\x08\x0d\x20\x88\xd8\xa4\x3b\x11\xf3\x76\x9f\xad\x67\xf7"
+ b"\x8a\xfc\x49\xf4\x75\x37\x58\x0f\x69\x65\xf7\x88\x39\xf0\xc8\x52"
+ b"\x9c\x18\x81\x40\x1f\x40\xd4\xc3\x00"
+ )
+ vk = VerifyingKey.from_string(vk_str, Ed448)
+
+ vk_pem = (
+ b"-----BEGIN PUBLIC KEY-----\n"
+ b"MEMwBQYDK2VxAzoAeQtetSu7CMEzE+XWB10Bg47LCA0giNikOxHzdp+tZ/eK/En0\n"
+ b"dTdYD2ll94g58MhSnBiBQB9A1MMA\n"
+ b"-----END PUBLIC KEY-----\n"
+ )
+
+ self.assertEqual(vk_pem, vk.to_pem())
+
+ def test_ed448_export_import(self):
+ sk = SigningKey.generate(Ed448)
+ vk = sk.verifying_key
+
+ vk2 = VerifyingKey.from_pem(vk.to_pem())
+
+ self.assertEqual(vk, vk2)
+
+ def test_ed448_sig_verify(self):
+ pem_str = (
+ "-----BEGIN PUBLIC KEY-----\n"
+ "MEMwBQYDK2VxAzoAeQtetSu7CMEzE+XWB10Bg47LCA0giNikOxHzdp+tZ/eK/En0\n"
+ "dTdYD2ll94g58MhSnBiBQB9A1MMA\n"
+ "-----END PUBLIC KEY-----\n"
+ )
+
+ vk = VerifyingKey.from_pem(pem_str)
+
+ data = b"data\n"
+
+ # signature created by OpenSSL 3.0.0 beta1
+ sig = (
+ b"\x68\xed\x2c\x70\x35\x22\xca\x1c\x35\x03\xf3\xaa\x51\x33\x3d\x00"
+ b"\xc0\xae\xb0\x54\xc5\xdc\x7f\x6f\x30\x57\xb4\x1d\xcb\xe9\xec\xfa"
+ b"\xc8\x45\x3e\x51\xc1\xcb\x60\x02\x6a\xd0\x43\x11\x0b\x5f\x9b\xfa"
+ b"\x32\x88\xb2\x38\x6b\xed\xac\x09\x00\x78\xb1\x7b\x5d\x7e\xf8\x16"
+ b"\x31\xdd\x1b\x3f\x98\xa0\xce\x19\xe7\xd8\x1c\x9f\x30\xac\x2f\xd4"
+ b"\x1e\x55\xbf\x21\x98\xf6\x4c\x8c\xbe\x81\xa5\x2d\x80\x4c\x62\x53"
+ b"\x91\xd5\xee\x03\x30\xc6\x17\x66\x4b\x9e\x0c\x8d\x40\xd0\xad\xae"
+ b"\x0a\x00"
+ )
+
+ self.assertTrue(vk.verify(sig, data))
+
 
 class TestSigningKey(unittest.TestCase):
 """
@@ -237,6 +505,50 @@ class TestSigningKey(unittest.TestCase):
 )
 cls.sk2 = SigningKey.from_pem(prv_key_str)
 
+ def test_decoding_explicit_curve_parameters(self):
+ prv_key_str = (
+ "-----BEGIN PRIVATE KEY-----\n"
+ "MIIBeQIBADCCAQMGByqGSM49AgEwgfcCAQEwLAYHKoZIzj0BAQIhAP////8AAAAB\n"
+ "AAAAAAAAAAAAAAAA////////////////MFsEIP////8AAAABAAAAAAAAAAAAAAAA\n"
+ "///////////////8BCBaxjXYqjqT57PrvVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMV\n"
+ "AMSdNgiG5wSTamZ44ROdJreBn36QBEEEaxfR8uEsQkf4vOblY6RA8ncDfYEt6zOg\n"
+ "9KE5RdiYwpZP40Li/hp/m47n60p8D54WK84zV2sxXs7LtkBoN79R9QIhAP////8A\n"
+ "AAAA//////////+85vqtpxeehPO5ysL8YyVRAgEBBG0wawIBAQQgIXtREfUmR16r\n"
+ "ZbmvDGD2lAEFPZa2DLPyz0czSja58yChRANCAASK9VJIGLOY5mxXO4rdf2CNl0//\n"
+ "yJWhIzDWX7daMI6qQWB9hKyR5OFOT6eFr1qtcZh8CGZbB+yIOCpnnwn0ekpl\n"
+ "-----END PRIVATE KEY-----\n"
+ )
+
+ sk = SigningKey.from_pem(prv_key_str)
+
+ sk2 = SigningKey.from_string(
+ b"\x21\x7b\x51\x11\xf5\x26\x47\x5e\xab\x65\xb9\xaf\x0c\x60\xf6"
+ b"\x94\x01\x05\x3d\x96\xb6\x0c\xb3\xf2\xcf\x47\x33\x4a\x36\xb9"
+ b"\xf3\x20",
+ curve=NIST256p,
+ )
+
+ self.assertEqual(sk, sk2)
+
+ def test_decoding_explicit_curve_parameters_with_explicit_disabled(self):
+ prv_key_str = (
+ "-----BEGIN PRIVATE KEY-----\n"
+ "MIIBeQIBADCCAQMGByqGSM49AgEwgfcCAQEwLAYHKoZIzj0BAQIhAP////8AAAAB\n"
+ "AAAAAAAAAAAAAAAA////////////////MFsEIP////8AAAABAAAAAAAAAAAAAAAA\n"
+ "///////////////8BCBaxjXYqjqT57PrvVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMV\n"
+ "AMSdNgiG5wSTamZ44ROdJreBn36QBEEEaxfR8uEsQkf4vOblY6RA8ncDfYEt6zOg\n"
+ "9KE5RdiYwpZP40Li/hp/m47n60p8D54WK84zV2sxXs7LtkBoN79R9QIhAP////8A\n"
+ "AAAA//////////+85vqtpxeehPO5ysL8YyVRAgEBBG0wawIBAQQgIXtREfUmR16r\n"
+ "ZbmvDGD2lAEFPZa2DLPyz0czSja58yChRANCAASK9VJIGLOY5mxXO4rdf2CNl0//\n"
+ "yJWhIzDWX7daMI6qQWB9hKyR5OFOT6eFr1qtcZh8CGZbB+yIOCpnnwn0ekpl\n"
+ "-----END PRIVATE KEY-----\n"
+ )
+
+ with self.assertRaises(UnexpectedDER):
+ SigningKey.from_pem(
+ prv_key_str, valid_curve_encodings=["named_curve"]
+ )
+
 def test_equality_on_signing_keys(self):
 sk = SigningKey.from_secret_exponent(
 self.sk1.privkey.secret_multiplier, self.sk1.curve
@@ -244,6 +556,15 @@ class TestSigningKey(unittest.TestCase):
 self.assertEqual(self.sk1, sk)
 self.assertEqual(self.sk1_pkcs8, sk)
 
+ def test_verify_with_empty_message(self):
+ sig = self.sk1.sign(b"")
+
+ self.assertTrue(sig)
+
+ vk = self.sk1.verifying_key
+
+ self.assertTrue(vk.verify(sig, b""))
+
 def test_verify_with_precompute(self):
 sig = self.sk1.sign(b"message")
 
@@ -276,6 +597,143 @@ class TestSigningKey(unittest.TestCase):
 def test_inequality_on_signing_keys_not_implemented(self):
 self.assertNotEqual(self.sk1, None)
 
+ def test_ed25519_from_pem(self):
+ pem_str = (
+ "-----BEGIN PRIVATE KEY-----\n"
+ "MC4CAQAwBQYDK2VwBCIEIDS6x9FO1PG8T4xIPg8Zd0z8uL6sVGZFEZrX17gHC/XU\n"
+ "-----END PRIVATE KEY-----\n"
+ )
+
+ sk = SigningKey.from_pem(pem_str)
+
+ sk_str = SigningKey.from_string(
+ b"\x34\xBA\xC7\xD1\x4E\xD4\xF1\xBC\x4F\x8C\x48\x3E\x0F\x19\x77\x4C"
+ b"\xFC\xB8\xBE\xAC\x54\x66\x45\x11\x9A\xD7\xD7\xB8\x07\x0B\xF5\xD4",
+ Ed25519,
+ )
+
+ self.assertEqual(sk, sk_str)
+
+ def test_ed25519_to_pem(self):
+ sk = SigningKey.from_string(
+ b"\x34\xBA\xC7\xD1\x4E\xD4\xF1\xBC\x4F\x8C\x48\x3E\x0F\x19\x77\x4C"
+ b"\xFC\xB8\xBE\xAC\x54\x66\x45\x11\x9A\xD7\xD7\xB8\x07\x0B\xF5\xD4",
+ Ed25519,
+ )
+
+ pem_str = (
+ b"-----BEGIN PRIVATE KEY-----\n"
+ b"MC4CAQAwBQYDK2VwBCIEIDS6x9FO1PG8T4xIPg8Zd0z8uL6sVGZFEZrX17gHC/XU\n"
+ b"-----END PRIVATE KEY-----\n"
+ )
+
+ self.assertEqual(sk.to_pem(format="pkcs8"), pem_str)
+
+ def test_ed25519_to_and_from_pem(self):
+ sk = SigningKey.generate(Ed25519)
+
+ decoded = SigningKey.from_pem(sk.to_pem(format="pkcs8"))
+
+ self.assertEqual(sk, decoded)
+
+ def test_ed448_from_pem(self):
+ pem_str = (
+ "-----BEGIN PRIVATE KEY-----\n"
+ "MEcCAQAwBQYDK2VxBDsEOTyFuXqFLXgJlV8uDqcOw9nG4IqzLiZ/i5NfBDoHPzmP\n"
+ "OP0JMYaLGlTzwovmvCDJ2zLaezu9NLz9aQ==\n"
+ "-----END PRIVATE KEY-----\n"
+ )
+ sk = SigningKey.from_pem(pem_str)
+
+ sk_str = SigningKey.from_string(
+ b"\x3C\x85\xB9\x7A\x85\x2D\x78\x09\x95\x5F\x2E\x0E\xA7\x0E\xC3\xD9"
+ b"\xC6\xE0\x8A\xB3\x2E\x26\x7F\x8B\x93\x5F\x04\x3A\x07\x3F\x39\x8F"
+ b"\x38\xFD\x09\x31\x86\x8B\x1A\x54\xF3\xC2\x8B\xE6\xBC\x20\xC9\xDB"
+ b"\x32\xDA\x7B\x3B\xBD\x34\xBC\xFD\x69",
+ Ed448,
+ )
+
+ self.assertEqual(sk, sk_str)
+
+ def test_ed448_to_pem(self):
+ sk = SigningKey.from_string(
+ b"\x3C\x85\xB9\x7A\x85\x2D\x78\x09\x95\x5F\x2E\x0E\xA7\x0E\xC3\xD9"
+ b"\xC6\xE0\x8A\xB3\x2E\x26\x7F\x8B\x93\x5F\x04\x3A\x07\x3F\x39\x8F"
+ b"\x38\xFD\x09\x31\x86\x8B\x1A\x54\xF3\xC2\x8B\xE6\xBC\x20\xC9\xDB"
+ b"\x32\xDA\x7B\x3B\xBD\x34\xBC\xFD\x69",
+ Ed448,
+ )
+ pem_str = (
+ b"-----BEGIN PRIVATE KEY-----\n"
+ b"MEcCAQAwBQYDK2VxBDsEOTyFuXqFLXgJlV8uDqcOw9nG4IqzLiZ/i5NfBDoHPzmP\n"
+ b"OP0JMYaLGlTzwovmvCDJ2zLaezu9NLz9aQ==\n"
+ b"-----END PRIVATE KEY-----\n"
+ )
+
+ self.assertEqual(sk.to_pem(format="pkcs8"), pem_str)
+
+ def test_ed448_encode_decode(self):
+ sk = SigningKey.generate(Ed448)
+
+ decoded = SigningKey.from_pem(sk.to_pem(format="pkcs8"))
+
+ self.assertEqual(decoded, sk)
+
+
+class TestTrivialCurve(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ # To test what happens with r or s in signing happens to be zero we
+ # need to find a scalar that creates one of the points on a curve that
+ # has x coordinate equal to zero.
+ # Even for secp112r2 curve that's non trivial so use this toy
+ # curve, for which we can iterate over all points quickly
+ curve = CurveFp(163, 84, 58)
+ gen = PointJacobi(curve, 2, 87, 1, 167, generator=True)
+
+ cls.toy_curve = Curve("toy_p8", curve, gen, (1, 2, 0))
+
+ cls.sk = SigningKey.from_secret_exponent(
+ 140,
+ cls.toy_curve,
+ hashfunc=hashlib.sha1,
+ )
+
+ def test_generator_sanity(self):
+ gen = self.toy_curve.generator
+
+ self.assertEqual(gen * gen.order(), INFINITY)
+
+ def test_public_key_sanity(self):
+ self.assertEqual(self.sk.verifying_key.to_string(), b"\x98\x1e")
+
+ def test_deterministic_sign(self):
+ sig = self.sk.sign_deterministic(b"message")
+
+ self.assertEqual(sig, b"-.")
+
+ self.assertTrue(self.sk.verifying_key.verify(sig, b"message"))
+
+ def test_deterministic_sign_random_message(self):
+ msg = os.urandom(32)
+ sig = self.sk.sign_deterministic(msg)
+ self.assertEqual(len(sig), 2)
+ self.assertTrue(self.sk.verifying_key.verify(sig, msg))
+
+ def test_deterministic_sign_that_rises_R_zero_error(self):
+ # the raised RSZeroError is caught and handled internally by
+ # sign_deterministic methods
+ msg = b"\x00\x4f"
+ sig = self.sk.sign_deterministic(msg)
+ self.assertEqual(sig, b"\x36\x9e")
+ self.assertTrue(self.sk.verifying_key.verify(sig, msg))
+
+ def test_deterministic_sign_that_rises_S_zero_error(self):
+ msg = b"\x01\x6d"
+ sig = self.sk.sign_deterministic(msg)
+ self.assertEqual(sig, b"\x49\x6c")
+ self.assertTrue(self.sk.verifying_key.verify(sig, msg))
+
 
 # test VerifyingKey.verify()
 prv_key_str = (
@@ -452,3 +910,50 @@ def test_SigningKey_with_unlikely_value():
 vk = sk.verifying_key
 sig = sk.sign(b"hello")
 assert vk.verify(sig, b"hello")
+
+
+def test_SigningKey_with_custom_curve_old_point():
+ generator = generator_brainpoolp160r1
+ generator = Point(
+ generator.curve(),
+ generator.x(),
+ generator.y(),
+ generator.order(),
+ )
+
+ curve = Curve(
+ "BRAINPOOLP160r1",
+ generator.curve(),
+ generator,
+ (1, 3, 36, 3, 3, 2, 8, 1, 1, 1),
+ )
+
+ sk = SigningKey.from_secret_exponent(12, curve)
+
+ sk2 = SigningKey.from_secret_exponent(12, BRAINPOOLP160r1)
+
+ assert sk.privkey == sk2.privkey
+
+
+def test_VerifyingKey_inequality_with_different_curves():
+ sk1 = SigningKey.from_secret_exponent(2, BRAINPOOLP160r1)
+ sk2 = SigningKey.from_secret_exponent(2, NIST256p)
+
+ assert sk1.verifying_key != sk2.verifying_key
+
+
+def test_VerifyingKey_inequality_with_different_secret_points():
+ sk1 = SigningKey.from_secret_exponent(2, BRAINPOOLP160r1)
+ sk2 = SigningKey.from_secret_exponent(3, BRAINPOOLP160r1)
+
+ assert sk1.verifying_key != sk2.verifying_key
+
+
+def test_SigningKey_from_pem_pkcs8v2_EdDSA():
+ pem = """-----BEGIN PRIVATE KEY-----
+ MFMCAQEwBQYDK2VwBCIEICc2F2ag1n1QP0jY+g9qWx5sDkx0s/HdNi3cSRHw+zsI
+ oSMDIQA+HQ2xCif8a/LMWR2m5HaCm5I2pKe/cc8OiRANMHxjKQ==
+ -----END PRIVATE KEY-----"""
+
+ sk = SigningKey.from_pem(pem)
+ assert sk.curve == Ed25519
diff --git a/frozen_deps/ecdsa/test_malformed_sigs.py b/frozen_deps/ecdsa/test_malformed_sigs.py
index 4895cea..8e1b611 100644
--- a/frozen_deps/ecdsa/test_malformed_sigs.py
+++ b/frozen_deps/ecdsa/test_malformed_sigs.py
@@ -13,10 +13,17 @@ except ImportError: # pragma: no cover
 "sha384",
 "sha512",
 ]
+# skip algorithms broken by change to OpenSSL 3.0 and early versions
+# of hashlib that list algorithms that require the legacy provider to work
+# https://bugs.python.org/issue38820
+algorithms_available = [
+ i
+ for i in algorithms_available
+ if i not in ("mdc2", "md2", "md4", "whirlpool", "ripemd160")
+]
 from functools import partial
 import pytest
 import sys
-from six import binary_type
 import hypothesis.strategies as st
 from hypothesis import note, assume, given, settings, example
 
@@ -24,7 +31,7 @@ from .keys import SigningKey
 from .keys import BadSignatureError
 from .util import sigencode_der, sigencode_string
 from .util import sigdecode_der, sigdecode_string
-from .curves import curves, NIST256p
+from .curves import curves
 from .der import (
 encode_integer,
 encode_bitstring,
@@ -33,6 +40,7 @@ from .der import (
 encode_sequence,
 encode_constructed,
 )
+from .ellipticcurve import CurveEdTw
 
 
 example_data = b"some data to sign"
@@ -174,7 +182,7 @@ def st_random_der_ecdsa_sig_value(draw):
 note("Configuration: {0}".format(name))
 order = int(verifying_key.curve.order)
 
- # the encode_integer doesn't suport negative numbers, would be nice
+ # the encode_integer doesn't support negative numbers, would be nice
 # to generate them too, but we have coverage for remove_integer()
 # verifying that it doesn't accept them, so meh.
 # Test all numbers around the ones that can show up (around order)
@@ -227,7 +235,7 @@ def st_der_bit_string(draw, *args, **kwargs):
 if data:
 unused = draw(st.integers(min_value=0, max_value=7))
 data = bytearray(data)
- data[-1] &= -(2 ** unused)
+ data[-1] &= -(2**unused)
 data = bytes(data)
 else:
 unused = 0
@@ -258,9 +266,9 @@ def st_der_oid(draw):
 if first < 2:
 second = draw(st.integers(min_value=0, max_value=39))
 else:
- second = draw(st.integers(min_value=0, max_value=2 ** 512))
+ second = draw(st.integers(min_value=0, max_value=2**512))
 rest = draw(
- st.lists(st.integers(min_value=0, max_value=2 ** 512), max_size=50)
+ st.lists(st.integers(min_value=0, max_value=2**512), max_size=50)
 )
 return encode_oid(first, second, *rest)
 
@@ -275,9 +283,9 @@ def st_der():
 """
 return st.recursive(
 st.just(b"")
- | st_der_integer(max_value=2 ** 4096)
- | st_der_bit_string(max_size=1024 ** 2)
- | st_der_octet_string(max_size=1024 ** 2)
+ | st_der_integer(max_value=2**4096)
+ | st_der_bit_string(max_size=1024**2)
+ | st_der_octet_string(max_size=1024**2)
 | st_der_null()
 | st_der_oid(),
 lambda children: st.builds(
@@ -307,7 +315,7 @@ def test_random_der_as_signature(params, der):
 
 
 @settings(**params)
-@given(st.sampled_from(keys_and_sigs), st.binary(max_size=1024 ** 2))
+@given(st.sampled_from(keys_and_sigs), st.binary(max_size=1024**2))
 @example(
 keys_and_sigs[0], encode_sequence(encode_integer(0), encode_integer(0))
 )
@@ -334,6 +342,7 @@ keys_and_string_sigs = [
 ),
 )
 for name, verifying_key, sig in keys_and_sigs
+ if not isinstance(verifying_key.curve.curve, CurveEdTw)
 ]
 """
 Name of the curve+hash combination, VerifyingKey and signature as a
@@ -341,6 +350,17 @@ byte string.
 """
 
 
+keys_and_string_sigs += [
+ (
+ name,
+ verifying_key,
+ sig,
+ )
+ for name, verifying_key, sig in keys_and_sigs
+ if isinstance(verifying_key.curve.curve, CurveEdTw)
+]
+
+
 @settings(**params)
 @given(st_fuzzed_sig(keys_and_string_sigs))
 def test_fuzzed_string_signatures(params):
diff --git a/frozen_deps/ecdsa/test_numbertheory.py b/frozen_deps/ecdsa/test_numbertheory.py
index 4912c57..8bc787f 100644
--- a/frozen_deps/ecdsa/test_numbertheory.py
+++ b/frozen_deps/ecdsa/test_numbertheory.py
@@ -1,7 +1,5 @@
 import operator
-from six import print_
 from functools import reduce
-import operator
 
 try:
 import unittest2 as unittest
@@ -19,6 +17,7 @@ except ImportError: # pragma: no cover
 HC_PRESENT = False
 from .numbertheory import (
 SquareRootError,
+ JacobiError,
 factorization,
 gcd,
 lcm,
@@ -84,11 +83,61 @@ def test_square_root_mod_prime_for_small_primes(prime):
 square_root_mod_prime(nonsquare, prime)
 
 
+def test_square_root_mod_prime_for_2():
+ a = square_root_mod_prime(1, 2)
+ assert a == 1
+
+
+def test_square_root_mod_prime_for_small_prime():
+ root = square_root_mod_prime(98**2 % 101, 101)
+ assert root * root % 101 == 9
+
+
+def test_square_root_mod_prime_for_p_congruent_5():
+ p = 13
+ assert p % 8 == 5
+
+ root = square_root_mod_prime(3, p)
+ assert root * root % p == 3
+
+
+def test_square_root_mod_prime_for_p_congruent_5_large_d():
+ p = 29
+ assert p % 8 == 5
+
+ root = square_root_mod_prime(4, p)
+ assert root * root % p == 4
+
+
+class TestSquareRootModPrime(unittest.TestCase):
+ def test_power_of_2_p(self):
+ with self.assertRaises(JacobiError):
+ square_root_mod_prime(12, 32)
+
+ def test_no_square(self):
+ with self.assertRaises(SquareRootError) as e:
+ square_root_mod_prime(12, 31)
+
+ self.assertIn("no square root", str(e.exception))
+
+ def test_non_prime(self):
+ with self.assertRaises(SquareRootError) as e:
+ square_root_mod_prime(12, 33)
+
+ self.assertIn("p is not prime", str(e.exception))
+
+ def test_non_prime_with_negative(self):
+ with self.assertRaises(SquareRootError) as e:
+ square_root_mod_prime(697 - 1, 697)
+
+ self.assertIn("p is not prime", str(e.exception))
+
+
 @st.composite
 def st_two_nums_rel_prime(draw):
 # 521-bit is the biggest curve we operate on, use 1024 for a bit
 # of breathing space
- mod = draw(st.integers(min_value=2, max_value=2 ** 1024))
+ mod = draw(st.integers(min_value=2, max_value=2**1024))
 num = draw(
 st.integers(min_value=1, max_value=mod - 1).filter(
 lambda x: gcd(x, mod) == 1
@@ -110,7 +159,7 @@ def st_primes(draw, *args, **kwargs):
 
 @st.composite
 def st_num_square_prime(draw):
- prime = draw(st_primes(max_value=2 ** 1024))
+ prime = draw(st_primes(max_value=2**1024))
 num = draw(st.integers(min_value=0, max_value=1 + prime // 2))
 sq = num * num % prime
 return sq, prime
@@ -122,7 +171,7 @@ def st_comp_with_com_fac(draw):
 Strategy that returns lists of numbers, all having a common factor.
 """
 primes = draw(
- st.lists(st_primes(max_value=2 ** 512), min_size=1, max_size=10)
+ st.lists(st_primes(max_value=2**512), min_size=1, max_size=10)
 )
 # select random prime(s) that will make the common factor of composites
 com_fac_primes = draw(
@@ -153,7 +202,7 @@ def st_comp_no_com_fac(draw):
 """
 primes = draw(
 st.lists(
- st_primes(max_value=2 ** 512), min_size=2, max_size=10, unique=True
+ st_primes(max_value=2**512), min_size=2, max_size=10, unique=True
 )
 )
 # first select the primes that will create the uncommon factor
@@ -207,6 +256,38 @@ HYP_SLOW_SETTINGS = dict(HYP_SETTINGS)
 HYP_SLOW_SETTINGS["max_examples"] = 10
 
 
+class TestIsPrime(unittest.TestCase):
+ def test_very_small_prime(self):
+ assert is_prime(23)
+
+ def test_very_small_composite(self):
+ assert not is_prime(22)
+
+ def test_small_prime(self):
+ assert is_prime(123456791)
+
+ def test_special_composite(self):
+ assert not is_prime(10261)
+
+ def test_medium_prime_1(self):
+ # nextPrime[2^256]
+ assert is_prime(2**256 + 0x129)
+
+ def test_medium_prime_2(self):
+ # nextPrime(2^256+0x129)
+ assert is_prime(2**256 + 0x12D)
+
+ def test_medium_trivial_composite(self):
+ assert not is_prime(2**256 + 0x130)
+
+ def test_medium_non_trivial_composite(self):
+ assert not is_prime(2**256 + 0x12F)
+
+ def test_large_prime(self):
+ # nextPrime[2^2048]
+ assert is_prime(2**2048 + 0x3D5)
+
+
 class TestNumbertheory(unittest.TestCase):
 def test_gcd(self):
 assert gcd(3 * 5 * 7, 3 * 5 * 11, 3 * 5 * 13) == 3 * 5
@@ -241,7 +322,7 @@ class TestNumbertheory(unittest.TestCase):
 
 @given(
 st.lists(
- st.integers(min_value=1, max_value=2 ** 8192),
+ st.integers(min_value=1, max_value=2**8192),
 min_size=1,
 max_size=20,
 )
@@ -259,7 +340,7 @@ class TestNumbertheory(unittest.TestCase):
 
 @given(
 st.lists(
- st.integers(min_value=1, max_value=2 ** 8192),
+ st.integers(min_value=1, max_value=2**8192),
 min_size=1,
 max_size=20,
 )
@@ -284,9 +365,9 @@ class TestNumbertheory(unittest.TestCase):
 assert calc * calc % prime == square
 
 @settings(**HYP_SETTINGS)
- @given(st.integers(min_value=1, max_value=10 ** 12))
+ @given(st.integers(min_value=1, max_value=10**12))
 @example(265399 * 1526929)
- @example(373297 ** 2 * 553991)
+ @example(373297**2 * 553991)
 def test_factorization(self, num):
 factors = factorization(num)
 mult = 1
@@ -294,6 +375,32 @@ class TestNumbertheory(unittest.TestCase):
 mult *= i[0] ** i[1]
 assert mult == num
 
+ def test_factorisation_smallprimes(self):
+ exp = 101 * 103
+ assert 101 in smallprimes
+ assert 103 in smallprimes
+ factors = factorization(exp)
+ mult = 1
+ for i in factors:
+ mult *= i[0] ** i[1]
+ assert mult == exp
+
+ def test_factorisation_not_smallprimes(self):
+ exp = 1231 * 1237
+ assert 1231 not in smallprimes
+ assert 1237 not in smallprimes
+ factors = factorization(exp)
+ mult = 1
+ for i in factors:
+ mult *= i[0] ** i[1]
+ assert mult == exp
+
+ def test_jacobi_with_zero(self):
+ assert jacobi(0, 3) == 0
+
+ def test_jacobi_with_one(self):
+ assert jacobi(1, 3) == 1
+
 @settings(**HYP_SETTINGS)
 @given(st.integers(min_value=3, max_value=1000).filter(lambda x: x % 2))
 def test_jacobi(self, mod):
diff --git a/frozen_deps/ecdsa/test_pyecdsa.py b/frozen_deps/ecdsa/test_pyecdsa.py
index 65b6716..d61f508 100644
--- a/frozen_deps/ecdsa/test_pyecdsa.py
+++ b/frozen_deps/ecdsa/test_pyecdsa.py
@@ -5,7 +5,7 @@ try:
 except ImportError:
 import unittest
 import os
-import time
+import sys
 import shutil
 import subprocess
 import pytest
@@ -26,6 +26,10 @@ from .util import sigdecode_der, sigdecode_strings
 from .util import number_to_string, encoded_oid_ecPublicKey, MalformedSignature
 from .curves import Curve, UnknownCurveError
 from .curves import (
+ SECP112r1,
+ SECP112r2,
+ SECP128r1,
+ SECP160r1,
 NIST192p,
 NIST224p,
 NIST256p,
@@ -39,6 +43,8 @@ from .curves import (
 BRAINPOOLP320r1,
 BRAINPOOLP384r1,
 BRAINPOOLP512r1,
+ Ed25519,
+ Ed448,
 curves,
 )
 from .ecdsa import (
@@ -136,16 +142,12 @@ class ECDSA(unittest.TestCase):
 BRAINPOOLP384r1,
 BRAINPOOLP512r1,
 ):
- start = time.time()
 priv = SigningKey.generate(curve=curve)
 pub1 = priv.get_verifying_key()
- keygen_time = time.time() - start
 pub2 = VerifyingKey.from_string(pub1.to_string(), curve)
 self.assertEqual(pub1.to_string(), pub2.to_string())
 self.assertEqual(len(pub1.to_string()), curve.verifying_key_length)
- start = time.time()
 sig = priv.sign(b("data"))
- sign_time = time.time() - start
 self.assertEqual(len(sig), curve.signature_length)
 
 def test_serialize(self):
@@ -310,8 +312,15 @@ class ECDSA(unittest.TestCase):
 def order(self):
 return 123456789
 
+ class FakeCurveFp:
+ def p(self):
+ return int(
+ "6525534529039240705020950546962731340"
+ "4541085228058844382513856749047873406763"
+ )
+
 badcurve = Curve(
- "unknown", None, FakeGenerator(), (1, 2, 3, 4, 5, 6), None
+ "unknown", FakeCurveFp(), FakeGenerator(), (1, 2, 3, 4, 5, 6), None
 )
 badpub.curve = badcurve
 badder = badpub.to_der()
@@ -616,7 +625,7 @@ class ECDSA(unittest.TestCase):
 
 def test_public_key_recovery(self):
 # Create keys
- curve = NIST256p
+ curve = BRAINPOOLP160r1
 
 sk = SigningKey.generate(curve=curve)
 vk = sk.get_verifying_key()
@@ -642,14 +651,14 @@ class ECDSA(unittest.TestCase):
 )
 
 # Test if original vk is the list of recovered keys
- self.assertTrue(
- vk.pubkey.point
- in [recovered_vk.pubkey.point for recovered_vk in recovered_vks]
+ self.assertIn(
+ vk.pubkey.point,
+ [recovered_vk.pubkey.point for recovered_vk in recovered_vks],
 )
 
 def test_public_key_recovery_with_custom_hash(self):
 # Create keys
- curve = NIST256p
+ curve = BRAINPOOLP160r1
 
 sk = SigningKey.generate(curve=curve, hashfunc=sha256)
 vk = sk.get_verifying_key()
@@ -660,7 +669,7 @@ class ECDSA(unittest.TestCase):
 
 # Recover verifying keys
 recovered_vks = VerifyingKey.from_public_key_recovery(
- signature, data, curve, hashfunc=sha256
+ signature, data, curve, hashfunc=sha256, allow_truncate=True
 )
 
 # Test if each pk is valid
@@ -673,9 +682,9 @@ class ECDSA(unittest.TestCase):
 self.assertEqual(sha256, recovered_vk.default_hashfunc)
 
 # Test if original vk is the list of recovered keys
- self.assertTrue(
- vk.pubkey.point
- in [recovered_vk.pubkey.point for recovered_vk in recovered_vks]
+ self.assertIn(
+ vk.pubkey.point,
+ [recovered_vk.pubkey.point for recovered_vk in recovered_vks],
 )
 
 def test_encoding(self):
@@ -715,6 +724,71 @@ class ECDSA(unittest.TestCase):
 from_uncompressed = VerifyingKey.from_string(b("\x06") + enc)
 self.assertEqual(from_uncompressed.pubkey.point, vk.pubkey.point)
 
+ def test_uncompressed_decoding_as_only_alowed(self):
+ enc = b(
+ "\x04"
+ "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+ "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+ "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+ )
+ vk = VerifyingKey.from_string(enc, valid_encodings=("uncompressed",))
+ sk = SigningKey.from_secret_exponent(123456789)
+
+ self.assertEqual(vk, sk.verifying_key)
+
+ def test_raw_decoding_with_blocked_format(self):
+ enc = b(
+ "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+ "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+ "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+ )
+ with self.assertRaises(MalformedPointError) as exp:
+ VerifyingKey.from_string(enc, valid_encodings=("hybrid",))
+
+ self.assertIn("hybrid", str(exp.exception))
+
+ def test_decoding_with_unknown_format(self):
+ with self.assertRaises(ValueError) as e:
+ VerifyingKey.from_string(b"", valid_encodings=("raw", "foobar"))
+
+ self.assertIn("Only uncompressed, compressed", str(e.exception))
+
+ def test_uncompressed_decoding_with_blocked_format(self):
+ enc = b(
+ "\x04"
+ "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+ "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+ "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+ )
+ with self.assertRaises(MalformedPointError) as exp:
+ VerifyingKey.from_string(enc, valid_encodings=("hybrid",))
+
+ self.assertIn("Invalid X9.62 encoding", str(exp.exception))
+
+ def test_hybrid_decoding_with_blocked_format(self):
+ enc = b(
+ "\x06"
+ "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+ "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+ "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+ )
+ with self.assertRaises(MalformedPointError) as exp:
+ VerifyingKey.from_string(enc, valid_encodings=("uncompressed",))
+
+ self.assertIn("Invalid X9.62 encoding", str(exp.exception))
+
+ def test_compressed_decoding_with_blocked_format(self):
+ enc = b(
+ "\x02"
+ "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+ "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+ "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+ )[:25]
+ with self.assertRaises(MalformedPointError) as exp:
+ VerifyingKey.from_string(enc, valid_encodings=("hybrid", "raw"))
+
+ self.assertIn("(hybrid, raw)", str(exp.exception))
+
 def test_decoding_with_malformed_uncompressed(self):
 enc = b(
 "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
@@ -866,6 +940,34 @@ class OpenSSL(unittest.TestCase):
 # sig: 5:OpenSSL->python 6:python->OpenSSL
 
 @pytest.mark.skipif(
+ "secp112r1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support secp112r1",
+ )
+ def test_from_openssl_secp112r1(self):
+ return self.do_test_from_openssl(SECP112r1)
+
+ @pytest.mark.skipif(
+ "secp112r2" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support secp112r2",
+ )
+ def test_from_openssl_secp112r2(self):
+ return self.do_test_from_openssl(SECP112r2)
+
+ @pytest.mark.skipif(
+ "secp128r1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support secp128r1",
+ )
+ def test_from_openssl_secp128r1(self):
+ return self.do_test_from_openssl(SECP128r1)
+
+ @pytest.mark.skipif(
+ "secp160r1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support secp160r1",
+ )
+ def test_from_openssl_secp160r1(self):
+ return self.do_test_from_openssl(SECP160r1)
+
+ @pytest.mark.skipif(
 "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime192v1",
 )
@@ -1030,6 +1132,34 @@ class OpenSSL(unittest.TestCase):
 self.assertEqual(sk, sk_from_p8)
 
 @pytest.mark.skipif(
+ "secp112r1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support secp112r1",
+ )
+ def test_to_openssl_secp112r1(self):
+ self.do_test_to_openssl(SECP112r1)
+
+ @pytest.mark.skipif(
+ "secp112r2" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support secp112r2",
+ )
+ def test_to_openssl_secp112r2(self):
+ self.do_test_to_openssl(SECP112r2)
+
+ @pytest.mark.skipif(
+ "secp128r1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support secp128r1",
+ )
+ def test_to_openssl_secp128r1(self):
+ self.do_test_to_openssl(SECP128r1)
+
+ @pytest.mark.skipif(
+ "secp160r1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support secp160r1",
+ )
+ def test_to_openssl_secp160r1(self):
+ self.do_test_to_openssl(SECP160r1)
+
+ @pytest.mark.skipif(
 "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime192v1",
 )
@@ -1191,6 +1321,17 @@ class OpenSSL(unittest.TestCase):
 % mdarg
 )
 
+ with open("t/privkey-explicit.pem", "wb") as e:
+ e.write(sk.to_pem(curve_parameters_encoding="explicit"))
+ run_openssl(
+ "dgst %s -sign t/privkey-explicit.pem -out t/data.sig2 t/data.txt"
+ % mdarg
+ )
+ run_openssl(
+ "dgst %s -verify t/pubkey.pem -signature t/data.sig2 t/data.txt"
+ % mdarg
+ )
+
 with open("t/privkey-p8.pem", "wb") as e:
 e.write(sk.to_pem(format="pkcs8"))
 run_openssl(
@@ -1202,6 +1343,133 @@ class OpenSSL(unittest.TestCase):
 % mdarg
 )
 
+ with open("t/privkey-p8-explicit.pem", "wb") as e:
+ e.write(
+ sk.to_pem(format="pkcs8", curve_parameters_encoding="explicit")
+ )
+ run_openssl(
+ "dgst %s -sign t/privkey-p8-explicit.pem -out t/data.sig3 t/data.txt"
+ % mdarg
+ )
+ run_openssl(
+ "dgst %s -verify t/pubkey.pem -signature t/data.sig3 t/data.txt"
+ % mdarg
+ )
+
+ OPENSSL_SUPPORTED_TYPES = set()
+ try:
+ if "-rawin" in run_openssl("pkeyutl -help"):
+ OPENSSL_SUPPORTED_TYPES = set(
+ c.lower()
+ for c in ("ED25519", "ED448")
+ if c in run_openssl("list -public-key-methods")
+ )
+ except SubprocessError:
+ pass
+
+ def do_eddsa_test_to_openssl(self, curve):
+ curvename = curve.name.upper()
+
+ if os.path.isdir("t"):
+ shutil.rmtree("t")
+ os.mkdir("t")
+
+ sk = SigningKey.generate(curve=curve)
+ vk = sk.get_verifying_key()
+
+ data = b"data"
+ with open("t/pubkey.der", "wb") as e:
+ e.write(vk.to_der())
+ with open("t/pubkey.pem", "wb") as e:
+ e.write(vk.to_pem())
+
+ sig = sk.sign(data)
+
+ with open("t/data.sig", "wb") as e:
+ e.write(sig)
+ with open("t/data.txt", "wb") as e:
+ e.write(data)
+ with open("t/baddata.txt", "wb") as e:
+ e.write(data + b"corrupt")
+
+ with self.assertRaises(SubprocessError):
+ run_openssl(
+ "pkeyutl -verify -pubin -inkey t/pubkey.pem -rawin "
+ "-in t/baddata.txt -sigfile t/data.sig"
+ )
+ run_openssl(
+ "pkeyutl -verify -pubin -inkey t/pubkey.pem -rawin "
+ "-in t/data.txt -sigfile t/data.sig"
+ )
+
+ shutil.rmtree("t")
+
+ # in practice at least OpenSSL 3.0.0 is needed to make EdDSA signatures
+ # earlier versions support EdDSA only in X.509 certificates
+ @pytest.mark.skipif(
+ "ed25519" not in OPENSSL_SUPPORTED_TYPES,
+ reason="system openssl does not support signing with Ed25519",
+ )
+ def test_to_openssl_ed25519(self):
+ return self.do_eddsa_test_to_openssl(Ed25519)
+
+ @pytest.mark.skipif(
+ "ed448" not in OPENSSL_SUPPORTED_TYPES,
+ reason="system openssl does not support signing with Ed448",
+ )
+ def test_to_openssl_ed448(self):
+ return self.do_eddsa_test_to_openssl(Ed448)
+
+ def do_eddsa_test_from_openssl(self, curve):
+ curvename = curve.name
+
+ if os.path.isdir("t"):
+ shutil.rmtree("t")
+ os.mkdir("t")
+
+ data = b"data"
+
+ run_openssl(
+ "genpkey -algorithm {0} -outform PEM -out t/privkey.pem".format(
+ curvename
+ )
+ )
+ run_openssl(
+ "pkey -outform PEM -pubout -in t/privkey.pem -out t/pubkey.pem"
+ )
+
+ with open("t/data.txt", "wb") as e:
+ e.write(data)
+ run_openssl(
+ "pkeyutl -sign -inkey t/privkey.pem "
+ "-rawin -in t/data.txt -out t/data.sig"
+ )
+
+ with open("t/data.sig", "rb") as e:
+ sig = e.read()
+ with open("t/pubkey.pem", "rb") as e:
+ vk = VerifyingKey.from_pem(e.read())
+
+ self.assertIs(vk.curve, curve)
+
+ vk.verify(sig, data)
+
+ shutil.rmtree("t")
+
+ @pytest.mark.skipif(
+ "ed25519" not in OPENSSL_SUPPORTED_TYPES,
+ reason="system openssl does not support signing with Ed25519",
+ )
+ def test_from_openssl_ed25519(self):
+ return self.do_eddsa_test_from_openssl(Ed25519)
+
+ @pytest.mark.skipif(
+ "ed448" not in OPENSSL_SUPPORTED_TYPES,
+ reason="system openssl does not support signing with Ed448",
+ )
+ def test_from_openssl_ed448(self):
+ return self.do_eddsa_test_from_openssl(Ed448)
+
 
 class TooSmallCurve(unittest.TestCase):
 OPENSSL_SUPPORTED_CURVES = set(
@@ -1215,7 +1483,6 @@ class TooSmallCurve(unittest.TestCase):
 )
 def test_sign_too_small_curve_dont_allow_truncate_raises(self):
 sk = SigningKey.generate(curve=NIST192p)
- vk = sk.get_verifying_key()
 data = b("data")
 with self.assertRaises(BadDigestError):
 sk.sign(
@@ -1319,13 +1586,13 @@ class Util(unittest.TestCase):
 for i in range(1000):
 seed = "seed-%d" % i
 for order in (
- 2 ** 8 - 2,
- 2 ** 8 - 1,
- 2 ** 8,
- 2 ** 8 + 1,
- 2 ** 8 + 2,
- 2 ** 16 - 1,
- 2 ** 16 + 1,
+ 2**8 - 2,
+ 2**8 - 1,
+ 2**8,
+ 2**8 + 1,
+ 2**8 + 2,
+ 2**16 - 1,
+ 2**16 + 1,
 ):
 n = tta(seed, order)
 self.assertTrue(1 <= n < order, (1, n, order))
@@ -1335,24 +1602,35 @@ class Util(unittest.TestCase):
 b("6fa59d73bf0446ae8743cf748fc5ac11d5585a90356417e97155c3bc"),
 )
 
- @given(st.integers(min_value=0, max_value=10 ** 200))
+ def test_trytryagain_single(self):
+ tta = util.randrange_from_seed__trytryagain
+ order = 2**8 - 2
+ seed = b"text"
+ n = tta(seed, order)
+ # known issue: https://github.com/warner/python-ecdsa/issues/221
+ if sys.version_info < (3, 0): # pragma: no branch
+ self.assertEqual(n, 228)
+ else:
+ self.assertEqual(n, 18)
+
+ @given(st.integers(min_value=0, max_value=10**200))
 def test_randrange(self, i):
 # util.randrange does not provide long-term stability: we might
 # change the algorithm in the future.
 entropy = util.PRNG("seed-%d" % i)
 for order in (
- 2 ** 8 - 2,
- 2 ** 8 - 1,
- 2 ** 8,
- 2 ** 16 - 1,
- 2 ** 16 + 1,
+ 2**8 - 2,
+ 2**8 - 1,
+ 2**8,
+ 2**16 - 1,
+ 2**16 + 1,
 ):
 # that oddball 2**16+1 takes half our runtime
 n = util.randrange(order, entropy=entropy)
 self.assertTrue(1 <= n < order, (1, n, order))
 
 def OFF_test_prove_uniformity(self): # pragma: no cover
- order = 2 ** 8 - 2
+ order = 2**8 - 2
 counts = dict([(i, 0) for i in range(1, order)])
 assert 0 not in counts
 assert order not in counts
diff --git a/frozen_deps/ecdsa/test_rw_lock.py b/frozen_deps/ecdsa/test_rw_lock.py
index d360482..0a84b9c 100644
--- a/frozen_deps/ecdsa/test_rw_lock.py
+++ b/frozen_deps/ecdsa/test_rw_lock.py
@@ -2,7 +2,10 @@
 # https://code.activestate.com/recipes/577803-reader-writer-lock-with-priority-for-writers/
 # released under the MIT licence
 
-import unittest
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
 import threading
 import time
 import copy
diff --git a/frozen_deps/ecdsa/test_sha3.py b/frozen_deps/ecdsa/test_sha3.py
new file mode 100644
index 0000000..2c6bd15
--- /dev/null
+++ b/frozen_deps/ecdsa/test_sha3.py
@@ -0,0 +1,111 @@
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+import pytest
+
+try:
+ from gmpy2 import mpz
+
+ GMPY = True
+except ImportError:
+ try:
+ from gmpy import mpz
+
+ GMPY = True
+ except ImportError:
+ GMPY = False
+
+from ._sha3 import shake_256
+from ._compat import bytes_to_int, int_to_bytes
+
+B2I_VECTORS = [
+ (b"\x00\x01", "big", 1),
+ (b"\x00\x01", "little", 0x0100),
+ (b"", "big", 0),
+ (b"\x00", "little", 0),
+]
+
+
+[email protected]("bytes_in,endian,int_out", B2I_VECTORS)
+def test_bytes_to_int(bytes_in, endian, int_out):
+ out = bytes_to_int(bytes_in, endian)
+ assert out == int_out
+
+
+class TestBytesToInt(unittest.TestCase):
+ def test_bytes_to_int_wrong_endian(self):
+ with self.assertRaises(ValueError):
+ bytes_to_int(b"\x00", "middle")
+
+ def test_int_to_bytes_wrong_endian(self):
+ with self.assertRaises(ValueError):
+ int_to_bytes(0, byteorder="middle")
+
+
+[email protected](GMPY == False, reason="requites gmpy or gmpy2")
+def test_int_to_bytes_with_gmpy():
+ assert int_to_bytes(mpz(1)) == b"\x01"
+
+
+I2B_VECTORS = [
+ (0, None, "big", b""),
+ (0, 1, "big", b"\x00"),
+ (1, None, "big", b"\x01"),
+ (0x0100, None, "little", b"\x00\x01"),
+ (0x0100, 4, "little", b"\x00\x01\x00\x00"),
+ (1, 4, "big", b"\x00\x00\x00\x01"),
+]
+
+
+[email protected]("int_in,length,endian,bytes_out", I2B_VECTORS)
+def test_int_to_bytes(int_in, length, endian, bytes_out):
+ out = int_to_bytes(int_in, length, endian)
+ assert out == bytes_out
+
+
+SHAKE_256_VECTORS = [
+ (
+ b"Message.",
+ 32,
+ b"\x78\xa1\x37\xbb\x33\xae\xe2\x72\xb1\x02\x4f\x39\x43\xe5\xcf\x0c"
+ b"\x4e\x9c\x72\x76\x2e\x34\x4c\xf8\xf9\xc3\x25\x9d\x4f\x91\x2c\x3a",
+ ),
+ (
+ b"",
+ 32,
+ b"\x46\xb9\xdd\x2b\x0b\xa8\x8d\x13\x23\x3b\x3f\xeb\x74\x3e\xeb\x24"
+ b"\x3f\xcd\x52\xea\x62\xb8\x1b\x82\xb5\x0c\x27\x64\x6e\xd5\x76\x2f",
+ ),
+ (
+ b"message",
+ 32,
+ b"\x86\x16\xe1\xe4\xcf\xd8\xb5\xf7\xd9\x2d\x43\xd8\x6e\x1b\x14\x51"
+ b"\xa2\xa6\x5a\xf8\x64\xfc\xb1\x26\xc2\x66\x0a\xb3\x46\x51\xb1\x75",
+ ),
+ (
+ b"message",
+ 16,
+ b"\x86\x16\xe1\xe4\xcf\xd8\xb5\xf7\xd9\x2d\x43\xd8\x6e\x1b\x14\x51",
+ ),
+ (
+ b"message",
+ 64,
+ b"\x86\x16\xe1\xe4\xcf\xd8\xb5\xf7\xd9\x2d\x43\xd8\x6e\x1b\x14\x51"
+ b"\xa2\xa6\x5a\xf8\x64\xfc\xb1\x26\xc2\x66\x0a\xb3\x46\x51\xb1\x75"
+ b"\x30\xd6\xba\x2a\x46\x65\xf1\x9d\xf0\x62\x25\xb1\x26\xd1\x3e\xed"
+ b"\x91\xd5\x0d\xe7\xb9\xcb\x65\xf3\x3a\x46\xae\xd3\x6c\x7d\xc5\xe8",
+ ),
+ (
+ b"A" * 1024,
+ 32,
+ b"\xa5\xef\x7e\x30\x8b\xe8\x33\x64\xe5\x9c\xf3\xb5\xf3\xba\x20\xa3"
+ b"\x5a\xe7\x30\xfd\xbc\x33\x11\xbf\x83\x89\x50\x82\xb4\x41\xe9\xb3",
+ ),
+]
+
+
+[email protected]("msg,olen,ohash", SHAKE_256_VECTORS)
+def test_shake_256(msg, olen, ohash):
+ out = shake_256(msg, olen)
+ assert out == bytearray(ohash)
diff --git a/frozen_deps/ecdsa/util.py b/frozen_deps/ecdsa/util.py
index e77d61c..9a56110 100644
--- a/frozen_deps/ecdsa/util.py
+++ b/frozen_deps/ecdsa/util.py
@@ -33,13 +33,12 @@ oid_ecDH = (1, 3, 132, 1, 12)
 
 oid_ecMQV = (1, 3, 132, 1, 13)
 
-if sys.version_info >= (3,):
+if sys.version_info >= (3,): # pragma: no branch
 
 def entropy_to_bits(ent_256):
 """Convert a bytestring to string of 0's and 1's"""
 return bin(int.from_bytes(ent_256, "big"))[2:].zfill(len(ent_256) * 8)
 
-
 else:
 
 def entropy_to_bits(ent_256):
@@ -47,12 +46,11 @@ else:
 return "".join(bin(ord(x))[2:].zfill(8) for x in ent_256)
 
 
-if sys.version_info < (2, 7):
+if sys.version_info < (2, 7): # pragma: no branch
 # Can't add a method to a built-in type so we are stuck with this
 def bit_length(x):
 return len(bin(x)) - 2
 
-
 else:
 
 def bit_length(x):
@@ -99,7 +97,7 @@ class PRNG:
 def __call__(self, numbytes):
 a = [next(self.generator) for i in range(numbytes)]
 
- if PY2:
+ if PY2: # pragma: no branch
 return "".join(a)
 else:
 return bytes(a)
author	Determinant <[email protected]>	2022-11-17 18:08:59 -0800
committer	Determinant <[email protected]>	2022-11-17 18:08:59 -0800
commit	8154806fe2fccacdc3dafaa68181a07bcf8d6c4c (patch)
tree	f477e6a005599bb88c18db142c267b9297c6060b /frozen_deps/ecdsa
parent	be4dc086591c9bced04a507d127c83811c5700c4 (diff)