22 files changed, 1639 insertions, 383 deletions
diff --git a/frozen_deps/ecdsa/__init__.py b/frozen_deps/ecdsa/__init__.py
index ce8749a..342538e 100644
--- a/frozen_deps/ecdsa/__init__.py
+++ b/frozen_deps/ecdsa/__init__.py
@@ -28,6 +28,13 @@ from .curves import (
 SECP160r1,
 Ed25519,
 Ed448,
+ BRAINPOOLP160t1,
+ BRAINPOOLP192t1,
+ BRAINPOOLP224t1,
+ BRAINPOOLP256t1,
+ BRAINPOOLP320t1,
+ BRAINPOOLP384t1,
+ BRAINPOOLP512t1,
 )
 from .ecdh import (
 ECDH,
@@ -84,6 +91,13 @@ _hush_pyflakes = [
 Ed25519,
 Ed448,
 six.b(""),
+ BRAINPOOLP160t1,
+ BRAINPOOLP192t1,
+ BRAINPOOLP224t1,
+ BRAINPOOLP256t1,
+ BRAINPOOLP320t1,
+ BRAINPOOLP384t1,
+ BRAINPOOLP512t1,
 ]
 del _hush_pyflakes
 
diff --git a/frozen_deps/ecdsa/_compat.py b/frozen_deps/ecdsa/_compat.py
index 83d41a5..4558e33 100644
--- a/frozen_deps/ecdsa/_compat.py
+++ b/frozen_deps/ecdsa/_compat.py
@@ -91,28 +91,13 @@ if sys.version_info < (3, 0): # pragma: no branch
 raise ValueError("Only 'big' or 'little' endian supported")
 
 else:
- 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): # 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 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
@@ -142,7 +127,7 @@ else:
 if length is None:
 length = byte_length(val)
 # for gmpy we need to convert back to native int
- if type(val) != int:
+ if not isinstance(val, int):
 val = int(val)
 return bytearray(val.to_bytes(length=length, byteorder=byteorder))
 
diff --git a/frozen_deps/ecdsa/_version.py b/frozen_deps/ecdsa/_version.py
index 96aae17..cf329eb 100644
--- a/frozen_deps/ecdsa/_version.py
+++ b/frozen_deps/ecdsa/_version.py
@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2022-07-09T14:49:17+0200",
+ "date": "2024-04-08T20:59:55+0200",
 "dirty": false,
 "error": null,
- "full-revisionid": "341e0d8be9fedf66fbc9a95630b4ed2138343380",
- "version": "0.18.0"
+ "full-revisionid": "be70016f8911f79e891a65dcfcb602e5ba866ed3",
+ "version": "0.19.0"
 }
 ''' # END VERSION_JSON
 
diff --git a/frozen_deps/ecdsa/curves.py b/frozen_deps/ecdsa/curves.py
index 1119ee5..38e3a75 100644
--- a/frozen_deps/ecdsa/curves.py
+++ b/frozen_deps/ecdsa/curves.py
@@ -26,12 +26,19 @@ __all__ = [
 "curve_by_name",
 "SECP256k1",
 "BRAINPOOLP160r1",
+ "BRAINPOOLP160t1",
 "BRAINPOOLP192r1",
+ "BRAINPOOLP192t1",
 "BRAINPOOLP224r1",
+ "BRAINPOOLP224t1",
 "BRAINPOOLP256r1",
+ "BRAINPOOLP256t1",
 "BRAINPOOLP320r1",
+ "BRAINPOOLP320t1",
 "BRAINPOOLP384r1",
+ "BRAINPOOLP384t1",
 "BRAINPOOLP512r1",
+ "BRAINPOOLP512t1",
 "PRIME_FIELD_OID",
 "CHARACTERISTIC_TWO_FIELD_OID",
 "Ed25519",
@@ -375,6 +382,15 @@ BRAINPOOLP160r1 = Curve(
 )
 
 
+BRAINPOOLP160t1 = Curve(
+ "BRAINPOOLP160t1",
+ ecdsa.curve_brainpoolp160t1,
+ ecdsa.generator_brainpoolp160t1,
+ (1, 3, 36, 3, 3, 2, 8, 1, 1, 2),
+ "brainpoolP160t1",
+)
+
+
 BRAINPOOLP192r1 = Curve(
 "BRAINPOOLP192r1",
 ecdsa.curve_brainpoolp192r1,
@@ -384,6 +400,15 @@ BRAINPOOLP192r1 = Curve(
 )
 
 
+BRAINPOOLP192t1 = Curve(
+ "BRAINPOOLP192t1",
+ ecdsa.curve_brainpoolp192t1,
+ ecdsa.generator_brainpoolp192t1,
+ (1, 3, 36, 3, 3, 2, 8, 1, 1, 4),
+ "brainpoolP192t1",
+)
+
+
 BRAINPOOLP224r1 = Curve(
 "BRAINPOOLP224r1",
 ecdsa.curve_brainpoolp224r1,
@@ -393,6 +418,15 @@ BRAINPOOLP224r1 = Curve(
 )
 
 
+BRAINPOOLP224t1 = Curve(
+ "BRAINPOOLP224t1",
+ ecdsa.curve_brainpoolp224t1,
+ ecdsa.generator_brainpoolp224t1,
+ (1, 3, 36, 3, 3, 2, 8, 1, 1, 6),
+ "brainpoolP224t1",
+)
+
+
 BRAINPOOLP256r1 = Curve(
 "BRAINPOOLP256r1",
 ecdsa.curve_brainpoolp256r1,
@@ -402,6 +436,15 @@ BRAINPOOLP256r1 = Curve(
 )
 
 
+BRAINPOOLP256t1 = Curve(
+ "BRAINPOOLP256t1",
+ ecdsa.curve_brainpoolp256t1,
+ ecdsa.generator_brainpoolp256t1,
+ (1, 3, 36, 3, 3, 2, 8, 1, 1, 8),
+ "brainpoolP256t1",
+)
+
+
 BRAINPOOLP320r1 = Curve(
 "BRAINPOOLP320r1",
 ecdsa.curve_brainpoolp320r1,
@@ -411,6 +454,15 @@ BRAINPOOLP320r1 = Curve(
 )
 
 
+BRAINPOOLP320t1 = Curve(
+ "BRAINPOOLP320t1",
+ ecdsa.curve_brainpoolp320t1,
+ ecdsa.generator_brainpoolp320t1,
+ (1, 3, 36, 3, 3, 2, 8, 1, 1, 10),
+ "brainpoolP320t1",
+)
+
+
 BRAINPOOLP384r1 = Curve(
 "BRAINPOOLP384r1",
 ecdsa.curve_brainpoolp384r1,
@@ -420,6 +472,15 @@ BRAINPOOLP384r1 = Curve(
 )
 
 
+BRAINPOOLP384t1 = Curve(
+ "BRAINPOOLP384t1",
+ ecdsa.curve_brainpoolp384t1,
+ ecdsa.generator_brainpoolp384t1,
+ (1, 3, 36, 3, 3, 2, 8, 1, 1, 12),
+ "brainpoolP384t1",
+)
+
+
 BRAINPOOLP512r1 = Curve(
 "BRAINPOOLP512r1",
 ecdsa.curve_brainpoolp512r1,
@@ -429,6 +490,15 @@ BRAINPOOLP512r1 = Curve(
 )
 
 
+BRAINPOOLP512t1 = Curve(
+ "BRAINPOOLP512t1",
+ ecdsa.curve_brainpoolp512t1,
+ ecdsa.generator_brainpoolp512t1,
+ (1, 3, 36, 3, 3, 2, 8, 1, 1, 14),
+ "brainpoolP512t1",
+)
+
+
 Ed25519 = Curve(
 "Ed25519",
 eddsa.curve_ed25519,
@@ -466,6 +536,13 @@ curves = [
 SECP160r1,
 Ed25519,
 Ed448,
+ BRAINPOOLP160t1,
+ BRAINPOOLP192t1,
+ BRAINPOOLP224t1,
+ BRAINPOOLP256t1,
+ BRAINPOOLP320t1,
+ BRAINPOOLP384t1,
+ BRAINPOOLP512t1,
 ]
 
 
diff --git a/frozen_deps/ecdsa/der.py b/frozen_deps/ecdsa/der.py
index 8b27941..b291485 100644
--- a/frozen_deps/ecdsa/der.py
+++ b/frozen_deps/ecdsa/der.py
@@ -4,8 +4,8 @@ import binascii
 import base64
 import warnings
 from itertools import chain
-from six import int2byte, b, text_type
-from ._compat import str_idx_as_int
+from six import int2byte, text_type
+from ._compat import compat26_str, str_idx_as_int
 
 
 class UnexpectedDER(Exception):
@@ -20,16 +20,16 @@ def encode_integer(r):
 assert r >= 0 # can't support negative numbers yet
 h = ("%x" % r).encode()
 if len(h) % 2:
- h = b("0") + h
+ h = b"0" + h
 s = binascii.unhexlify(h)
 num = str_idx_as_int(s, 0)
 if num <= 0x7F:
- return b("\x02") + encode_length(len(s)) + s
+ return b"\x02" + encode_length(len(s)) + s
 else:
 # DER integers are two's complement, so if the first byte is
 # 0x80-0xff then we need an extra 0x00 byte to prevent it from
 # looking negative.
- return b("\x02") + encode_length(len(s) + 1) + b("\x00") + s
+ return b"\x02" + encode_length(len(s) + 1) + b"\x00" + s
 
 
 # sentry object to check if an argument was specified (used to detect
@@ -91,11 +91,11 @@ def encode_bitstring(s, unused=_sentry):
 raise ValueError("unused bits must be zeros in DER")
 encoded_unused = int2byte(unused)
 len_extra = 1
- return b("\x03") + encode_length(len(s) + len_extra) + encoded_unused + s
+ return b"\x03" + encode_length(len(s) + len_extra) + encoded_unused + s
 
 
 def encode_octet_string(s):
- return b("\x04") + encode_length(len(s)) + s
+ return b"\x04" + encode_length(len(s)) + s
 
 
 def encode_oid(first, second, *pieces):
@@ -111,7 +111,7 @@ def encode_oid(first, second, *pieces):
 
 def encode_sequence(*encoded_pieces):
 total_len = sum([len(p) for p in encoded_pieces])
- return b("\x30") + encode_length(total_len) + b("").join(encoded_pieces)
+ return b"\x30" + encode_length(total_len) + b"".join(encoded_pieces)
 
 
 def encode_number(n):
@@ -122,7 +122,7 @@ def encode_number(n):
 if not b128_digits:
 b128_digits.append(0)
 b128_digits[-1] &= 0x7F
- return b("").join([int2byte(d) for d in b128_digits])
+ return b"".join([int2byte(d) for d in b128_digits])
 
 
 def is_sequence(string):
@@ -254,7 +254,7 @@ def encode_length(l):
 return int2byte(l)
 s = ("%x" % l).encode()
 if len(s) % 2:
- s = b("0") + s
+ s = b"0" + s
 s = binascii.unhexlify(s)
 llen = len(s)
 return int2byte(0x80 | llen) + s
@@ -389,21 +389,21 @@ def unpem(pem):
 if isinstance(pem, text_type): # pragma: no branch
 pem = pem.encode()
 
- d = b("").join(
+ d = b"".join(
 [
 l.strip()
- for l in pem.split(b("\n"))
- if l and not l.startswith(b("-----"))
+ for l in pem.split(b"\n")
+ if l and not l.startswith(b"-----")
 ]
 )
 return base64.b64decode(d)
 
 
 def topem(der, name):
- b64 = base64.b64encode(der)
+ b64 = base64.b64encode(compat26_str(der))
 lines = [("-----BEGIN %s-----\n" % name).encode()]
 lines.extend(
- [b64[start : start + 64] + b("\n") for start in range(0, len(b64), 64)]
+ [b64[start : start + 76] + b"\n" for start in range(0, len(b64), 76)]
 )
 lines.append(("-----END %s-----\n" % name).encode())
- return b("").join(lines)
+ return b"".join(lines)
diff --git a/frozen_deps/ecdsa/ecdsa.py b/frozen_deps/ecdsa/ecdsa.py
index 3328281..9284ace 100644
--- a/frozen_deps/ecdsa/ecdsa.py
+++ b/frozen_deps/ecdsa/ecdsa.py
@@ -64,7 +64,8 @@ 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
+import warnings
+from six import int2byte
 from . import ellipticcurve
 from . import numbertheory
 from .util import bit_length
@@ -269,11 +270,17 @@ class Private_key(object):
 return Signature(r, s)
 
 
-def int_to_string(x):
+def int_to_string(x): # pragma: no cover
 """Convert integer x into a string of bytes, as per X9.62."""
+ # deprecated in 0.19
+ warnings.warn(
+ "Function is unused in library code. If you use this code, "
+ "change to util.string_to_number.",
+ DeprecationWarning,
+ )
 assert x >= 0
 if x == 0:
- return b("\0")
+ return b"\0"
 result = []
 while x:
 ordinal = x & 0xFF
@@ -281,11 +288,17 @@ def int_to_string(x):
 x >>= 8
 
 result.reverse()
- return b("").join(result)
+ return b"".join(result)
 
 
-def string_to_int(s):
+def string_to_int(s): # pragma: no cover
 """Convert a string of bytes into an integer, as per X9.62."""
+ # deprecated in 0.19
+ warnings.warn(
+ "Function is unused in library code. If you use this code, "
+ "change to util.number_to_string.",
+ DeprecationWarning,
+ )
 result = 0
 for c in s:
 if not isinstance(c, int):
@@ -294,9 +307,16 @@ def string_to_int(s):
 return result
 
 
-def digest_integer(m):
+def digest_integer(m): # pragma: no cover
 """Convert an integer into a string of bytes, compute
 its SHA-1 hash, and convert the result to an integer."""
+ # deprecated in 0.19
+ warnings.warn(
+ "Function is unused in library code. If you use this code, "
+ "change to a one-liner with util.number_to_string and "
+ "util.string_to_number methods.",
+ DeprecationWarning,
+ )
 #
 # I don't expect this function to be used much. I wrote
 # it in order to be able to duplicate the examples
@@ -654,6 +674,18 @@ generator_brainpoolp160r1 = ellipticcurve.PointJacobi(
 curve_brainpoolp160r1, _Gx, _Gy, 1, _q, generator=True
 )
 
+# Brainpool P-160-t1
+_a = 0xE95E4A5F737059DC60DFC7AD95B3D8139515620C
+_b = 0x7A556B6DAE535B7B51ED2C4D7DAA7A0B5C55F380
+# _z = 0x24DBFF5DEC9B986BBFE5295A29BFBAE45E0F5D0B
+_Gx = 0xB199B13B9B34EFC1397E64BAEB05ACC265FF2378
+_Gy = 0xADD6718B7C7C1961F0991B842443772152C9E0AD
+_q = 0xE95E4A5F737059DC60DF5991D45029409E60FC09
+curve_brainpoolp160t1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp160t1 = ellipticcurve.PointJacobi(
+ curve_brainpoolp160t1, _Gx, _Gy, 1, _q, generator=True
+)
+
 # Brainpool P-192-r1
 _a = 0x6A91174076B1E0E19C39C031FE8685C1CAE040E5C69A28EF
 _b = 0x469A28EF7C28CCA3DC721D044F4496BCCA7EF4146FBF25C9
@@ -667,6 +699,19 @@ generator_brainpoolp192r1 = ellipticcurve.PointJacobi(
 curve_brainpoolp192r1, _Gx, _Gy, 1, _q, generator=True
 )
 
+# Brainpool P-192-t1
+_a = 0xC302F41D932A36CDA7A3463093D18DB78FCE476DE1A86294
+_b = 0x13D56FFAEC78681E68F9DEB43B35BEC2FB68542E27897B79
+# _z = 0x1B6F5CC8DB4DC7AF19458A9CB80DC2295E5EB9C3732104CB
+_Gx = 0x3AE9E58C82F63C30282E1FE7BBF43FA72C446AF6F4618129
+_Gy = 0x097E2C5667C2223A902AB5CA449D0084B7E5B3DE7CCC01C9
+_q = 0xC302F41D932A36CDA7A3462F9E9E916B5BE8F1029AC4ACC1
+
+curve_brainpoolp192t1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp192t1 = ellipticcurve.PointJacobi(
+ curve_brainpoolp192t1, _Gx, _Gy, 1, _q, generator=True
+)
+
 # Brainpool P-224-r1
 _a = 0x68A5E62CA9CE6C1C299803A6C1530B514E182AD8B0042A59CAD29F43
 _b = 0x2580F63CCFE44138870713B1A92369E33E2135D266DBB372386C400B
@@ -680,6 +725,19 @@ generator_brainpoolp224r1 = ellipticcurve.PointJacobi(
 curve_brainpoolp224r1, _Gx, _Gy, 1, _q, generator=True
 )
 
+# Brainpool P-224-t1
+_a = 0xD7C134AA264366862A18302575D1D787B09F075797DA89F57EC8C0FC
+_b = 0x4B337D934104CD7BEF271BF60CED1ED20DA14C08B3BB64F18A60888D
+# _z = 0x2DF271E14427A346910CF7A2E6CFA7B3F484E5C2CCE1C8B730E28B3F
+_Gx = 0x6AB1E344CE25FF3896424E7FFE14762ECB49F8928AC0C76029B4D580
+_Gy = 0x0374E9F5143E568CD23F3F4D7C0D4B1E41C8CC0D1C6ABD5F1A46DB4C
+_q = 0xD7C134AA264366862A18302575D0FB98D116BC4B6DDEBCA3A5A7939F
+
+curve_brainpoolp224t1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp224t1 = ellipticcurve.PointJacobi(
+ curve_brainpoolp224t1, _Gx, _Gy, 1, _q, generator=True
+)
+
 # Brainpool P-256-r1
 _a = 0x7D5A0975FC2C3057EEF67530417AFFE7FB8055C126DC5C6CE94A4B44F330B5D9
 _b = 0x26DC5C6CE94A4B44F330B5D9BBD77CBF958416295CF7E1CE6BCCDC18FF8C07B6
@@ -693,6 +751,19 @@ generator_brainpoolp256r1 = ellipticcurve.PointJacobi(
 curve_brainpoolp256r1, _Gx, _Gy, 1, _q, generator=True
 )
 
+# Brainpool P-256-t1
+_a = 0xA9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5374
+_b = 0x662C61C430D84EA4FE66A7733D0B76B7BF93EBC4AF2F49256AE58101FEE92B04
+# _z = 0x3E2D4BD9597B58639AE7AA669CAB9837CF5CF20A2C852D10F655668DFC150EF0
+_Gx = 0xA3E8EB3CC1CFE7B7732213B23A656149AFA142C47AAFBC2B79A191562E1305F4
+_Gy = 0x2D996C823439C56D7F7B22E14644417E69BCB6DE39D027001DABE8F35B25C9BE
+_q = 0xA9FB57DBA1EEA9BC3E660A909D838D718C397AA3B561A6F7901E0E82974856A7
+
+curve_brainpoolp256t1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp256t1 = ellipticcurve.PointJacobi(
+ curve_brainpoolp256t1, _Gx, _Gy, 1, _q, generator=True
+)
+
 # Brainpool P-320-r1
 _a = int(
 remove_whitespace(
@@ -748,6 +819,61 @@ generator_brainpoolp320r1 = ellipticcurve.PointJacobi(
 curve_brainpoolp320r1, _Gx, _Gy, 1, _q, generator=True
 )
 
+# Brainpool P-320-t1
+_a = int(
+ remove_whitespace(
+ """
+ D35E472036BC4FB7E13C785ED201E065F98FCFA6F6F40DEF4F92B9EC7893EC
+ 28FCD412B1F1B32E24"""
+ ),
+ 16,
+)
+_b = int(
+ remove_whitespace(
+ """
+ A7F561E038EB1ED560B3D147DB782013064C19F27ED27C6780AAF77FB8A547
+ CEB5B4FEF422340353"""
+ ),
+ 16,
+)
+# _z = int(
+# remove_whitespace(
+# """
+# 15F75CAF668077F7E85B42EB01F0A81FF56ECD6191D55CB82B7D861458A18F
+# EFC3E5AB7496F3C7B1"""
+# ),
+# 16,
+# )
+_Gx = int(
+ remove_whitespace(
+ """
+ 925BE9FB01AFC6FB4D3E7D4990010F813408AB106C4F09CB7EE07868CC136F
+ FF3357F624A21BED52"""
+ ),
+ 16,
+)
+_Gy = int(
+ remove_whitespace(
+ """
+ 63BA3A7A27483EBF6671DBEF7ABB30EBEE084E58A0B077AD42A5A0989D1EE7
+ 1B1B9BC0455FB0D2C3"""
+ ),
+ 16,
+)
+_q = int(
+ remove_whitespace(
+ """
+ D35E472036BC4FB7E13C785ED201E065F98FCFA5B68F12A32D482EC7EE8658
+ E98691555B44C59311"""
+ ),
+ 16,
+)
+
+curve_brainpoolp320t1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp320t1 = ellipticcurve.PointJacobi(
+ curve_brainpoolp320t1, _Gx, _Gy, 1, _q, generator=True
+)
+
 # Brainpool P-384-r1
 _a = int(
 remove_whitespace(
@@ -803,6 +929,60 @@ generator_brainpoolp384r1 = ellipticcurve.PointJacobi(
 curve_brainpoolp384r1, _Gx, _Gy, 1, _q, generator=True
 )
 
+_a = int(
+ remove_whitespace(
+ """
+ 8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B412B1DA197FB711
+ 23ACD3A729901D1A71874700133107EC50"""
+ ),
+ 16,
+)
+_b = int(
+ remove_whitespace(
+ """
+ 7F519EADA7BDA81BD826DBA647910F8C4B9346ED8CCDC64E4B1ABD11756DCE
+ 1D2074AA263B88805CED70355A33B471EE"""
+ ),
+ 16,
+)
+# _z = int(
+# remove_whitespace(
+# """
+# 41DFE8DD399331F7166A66076734A89CD0D2BCDB7D068E44E1F378F41ECBAE
+# 97D2D63DBC87BCCDDCCC5DA39E8589291C"""
+# ),
+# 16,
+# )
+_Gx = int(
+ remove_whitespace(
+ """
+ 18DE98B02DB9A306F2AFCD7235F72A819B80AB12EBD653172476FECD462AAB
+ FFC4FF191B946A5F54D8D0AA2F418808CC"""
+ ),
+ 16,
+)
+_Gy = int(
+ remove_whitespace(
+ """
+ 25AB056962D30651A114AFD2755AD336747F93475B7A1FCA3B88F2B6A208CC
+ FE469408584DC2B2912675BF5B9E582928"""
+ ),
+ 16,
+)
+_q = int(
+ remove_whitespace(
+ """
+ 8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B31F166E6CAC0425
+ A7CF3AB6AF6B7FC3103B883202E9046565"""
+ ),
+ 16,
+)
+
+curve_brainpoolp384t1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp384t1 = ellipticcurve.PointJacobi(
+ curve_brainpoolp384t1, _Gx, _Gy, 1, _q, generator=True
+)
+
 # Brainpool P-512-r1
 _a = int(
 remove_whitespace(
@@ -857,3 +1037,58 @@ curve_brainpoolp512r1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
 generator_brainpoolp512r1 = ellipticcurve.PointJacobi(
 curve_brainpoolp512r1, _Gx, _Gy, 1, _q, generator=True
 )
+
+# Brainpool P-512-t1
+_a = int(
+ remove_whitespace(
+ """
+ AADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308
+ 717D4D9B009BC66842AECDA12AE6A380E62881FF2F2D82C68528AA6056583A48F0"""
+ ),
+ 16,
+)
+_b = int(
+ remove_whitespace(
+ """
+ 7CBBBCF9441CFAB76E1890E46884EAE321F70C0BCB4981527897504BEC3E36
+ A62BCDFA2304976540F6450085F2DAE145C22553B465763689180EA2571867423E"""
+ ),
+ 16,
+)
+# _z = int(
+# remove_whitespace(
+# """
+# 12EE58E6764838B69782136F0F2D3BA06E27695716054092E60A80BEDB212B
+# 64E585D90BCE13761F85C3F1D2A64E3BE8FEA2220F01EBA5EEB0F35DBD29D922AB"""
+# ),
+# 16,
+# )
+_Gx = int(
+ remove_whitespace(
+ """
+ 640ECE5C12788717B9C1BA06CBC2A6FEBA85842458C56DDE9DB1758D39C031
+ 3D82BA51735CDB3EA499AA77A7D6943A64F7A3F25FE26F06B51BAA2696FA9035DA"""
+ ),
+ 16,
+)
+_Gy = int(
+ remove_whitespace(
+ """
+ 5B534BD595F5AF0FA2C892376C84ACE1BB4E3019B71634C01131159CAE03CE
+ E9D9932184BEEF216BD71DF2DADF86A627306ECFF96DBB8BACE198B61E00F8B332"""
+ ),
+ 16,
+)
+_q = int(
+ remove_whitespace(
+ """
+ AADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308
+ 70553E5C414CA92619418661197FAC10471DB1D381085DDADDB58796829CA90069"""
+ ),
+ 16,
+)
+
+curve_brainpoolp512t1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp512t1 = ellipticcurve.PointJacobi(
+ curve_brainpoolp512t1, _Gx, _Gy, 1, _q, generator=True
+)
diff --git a/frozen_deps/ecdsa/ellipticcurve.py b/frozen_deps/ecdsa/ellipticcurve.py
index d6f7146..18816a6 100644
--- a/frozen_deps/ecdsa/ellipticcurve.py
+++ b/frozen_deps/ecdsa/ellipticcurve.py
@@ -136,11 +136,17 @@ class CurveFp(object):
 return (y * y - ((x * x + self.__a) * x + self.__b)) % self.__p == 0
 
 def __str__(self):
- return "CurveFp(p=%d, a=%d, b=%d, h=%d)" % (
+ if self.__h is not None:
+ return "CurveFp(p={0}, a={1}, b={2}, h={3})".format(
+ self.__p,
+ self.__a,
+ self.__b,
+ self.__h,
+ )
+ return "CurveFp(p={0}, a={1}, b={2})".format(
 self.__p,
 self.__a,
 self.__b,
- self.__h,
 )
 
 
@@ -219,11 +225,17 @@ class CurveEdTw(object):
 return self.__h
 
 def __str__(self):
- return "CurveEdTw(p={0}, a={1}, d={2}, h={3})".format(
+ if self.__h is not None:
+ return "CurveEdTw(p={0}, a={1}, d={2}, h={3})".format(
+ self.__p,
+ self.__a,
+ self.__d,
+ self.__h,
+ )
+ return "CurveEdTw(p={0}, a={1}, d={2})".format(
 self.__p,
 self.__a,
 self.__d,
- self.__h,
 )
 
 
@@ -1008,8 +1020,8 @@ class PointJacobi(AbstractPoint):
 # 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)
+ mApB_X, mApB_Y, mApB_Z = pAmB_X, -pAmB_Y, pAmB_Z
+ pApB_X, pApB_Y, pApB_Z = mAmB_X, -mAmB_Y, mAmB_Z
 # 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
@@ -1520,7 +1532,9 @@ class PointEdwards(AbstractPoint):
 
 X3, Y3, Z3, T3 = self._double(X1, Y1, Z1, T1, p, a)
 
- if not X3 or not T3:
+ # both Ed25519 and Ed448 have prime order, so no point added to
+ # itself will equal zero
+ if not X3 or not T3: # pragma: no branch
 return INFINITY
 return PointEdwards(self.__curve, X3, Y3, Z3, T3, self.__order)
 
diff --git a/frozen_deps/ecdsa/keys.py b/frozen_deps/ecdsa/keys.py
index 2b7d316..f74252c 100644
--- a/frozen_deps/ecdsa/keys.py
+++ b/frozen_deps/ecdsa/keys.py
@@ -5,9 +5,9 @@ Primary classes for performing signing and verification operations.
 import binascii
 from hashlib import sha1
 import os
-from six import PY2, b
+from six import PY2
 from . import ecdsa, eddsa
-from . import der
+from . import der, ssh
 from . import rfc6979
 from . import ellipticcurve
 from .curves import NIST192p, Curve, Ed25519, Ed448
@@ -614,6 +614,18 @@ class VerifyingKey(object):
 der.encode_bitstring(point_str, 0),
 )
 
+ def to_ssh(self):
+ """
+ Convert the public key to the SSH format.
+
+ :return: SSH encoding of the public key
+ :rtype: bytes
+ """
+ return ssh.serialize_public(
+ self.curve.name,
+ self.to_string(),
+ )
+
 def verify(
 self,
 signature,
@@ -1032,7 +1044,7 @@ class SigningKey(object):
 curve = None
 
 s, empty = der.remove_sequence(s)
- if empty != b(""):
+ if empty != b"":
 raise der.UnexpectedDER(
 "trailing junk after DER privkey: %s" % binascii.hexlify(empty)
 )
@@ -1090,12 +1102,6 @@ class SigningKey(object):
 
 curve = Curve.from_der(algorithm_identifier, valid_curve_encodings)
 
- if empty != b"":
- raise der.UnexpectedDER(
- "unexpected data after algorithm identifier: %s"
- % binascii.hexlify(empty)
- )
-
 # Up next is an octet string containing an ECPrivateKey. Ignore
 # the optional "attributes" and "publicKey" fields that come after.
 s, _ = der.remove_octet_string(s)
@@ -1103,7 +1109,7 @@ class SigningKey(object):
 # Unpack the ECPrivateKey to get to the key data octet string,
 # and rejoin the ssleay parsing path.
 s, empty = der.remove_sequence(s)
- if empty != b(""):
+ if empty != b"":
 raise der.UnexpectedDER(
 "trailing junk after DER privkey: %s"
 % binascii.hexlify(empty)
@@ -1143,7 +1149,7 @@ class SigningKey(object):
 # our from_string method likes fixed-length privkey strings
 if len(privkey_str) < curve.baselen:
 privkey_str = (
- b("\x00") * (curve.baselen - len(privkey_str)) + privkey_str
+ b"\x00" * (curve.baselen - len(privkey_str)) + privkey_str
 )
 return cls.from_string(privkey_str, curve, hashfunc)
 
@@ -1281,6 +1287,19 @@ class SigningKey(object):
 der.encode_octet_string(ec_private_key),
 )
 
+ def to_ssh(self):
+ """
+ Convert the private key to the SSH format.
+
+ :return: SSH encoded private key
+ :rtype: bytes
+ """
+ return ssh.serialize_private(
+ self.curve.name,
+ self.verifying_key.to_string(),
+ self.to_string(),
+ )
+
 def get_verifying_key(self):
 """
 Return the VerifyingKey associated with this private key.
diff --git a/frozen_deps/ecdsa/numbertheory.py b/frozen_deps/ecdsa/numbertheory.py
index d3500c7..fe974f8 100644
--- a/frozen_deps/ecdsa/numbertheory.py
+++ b/frozen_deps/ecdsa/numbertheory.py
@@ -20,11 +20,11 @@ try:
 except NameError:
 xrange = range
 try:
- from gmpy2 import powmod
+ from gmpy2 import powmod, mpz
 
 GMPY2 = True
 GMPY = False
-except ImportError:
+except ImportError: # pragma: no branch
 GMPY2 = False
 try:
 from gmpy import mpz
@@ -33,8 +33,15 @@ except ImportError:
 except ImportError:
 GMPY = False
 
+
+if GMPY2 or GMPY: # pragma: no branch
+ integer_types = tuple(integer_types + (type(mpz(1)),))
+
+
 import math
 import warnings
+import random
+from .util import bit_length
 
 
 class Error(Exception):
@@ -216,14 +223,15 @@ def square_root_mod_prime(a, p):
 range_top = min(0x7FFFFFFF, p)
 else:
 range_top = p
- for b in xrange(2, range_top):
+ for b in xrange(2, range_top): # pragma: no branch
 if jacobi(b * b - 4 * a, p) == -1:
 f = (a, -b, 1)
 ff = polynomial_exp_mod((0, 1), (p + 1) // 2, f, p)
 if ff[1]:
 raise SquareRootError("p is not prime")
 return ff[0]
- raise RuntimeError("No b found.")
+ # just an assertion
+ raise RuntimeError("No b found.") # pragma: no cover
 
 
 # because all the inverse_mod code is arch/environment specific, and coveralls
@@ -346,7 +354,7 @@ def factorization(n):
 q, r = divmod(n, d)
 if r == 0:
 count = 1
- while d <= n:
+ while d <= n: # pragma: no branch
 n = q
 q, r = divmod(n, d)
 if r != 0:
@@ -370,7 +378,8 @@ def factorization(n):
 if r == 0: # d divides n. How many times?
 count = 1
 n = q
- while d <= n: # As long as d might still divide n,
+ # As long as d might still divide n,
+ while d <= n: # pragma: no branch
 q, r = divmod(n, d) # see if it does.
 if r != 0:
 break
@@ -555,8 +564,8 @@ def is_prime(n):
 return True
 else:
 return False
-
- if gcd(n, 2 * 3 * 5 * 7 * 11) != 1:
+ # 2310 = 2 * 3 * 5 * 7 * 11
+ if gcd(n, 2310) != 1:
 return False
 
 # Choose a number of iterations sufficient to reduce the
@@ -564,7 +573,8 @@ def is_prime(n):
 # (from Menezes et al. Table 4.4):
 
 t = 40
- n_bits = 1 + int(math.log(n, 2))
+ n_bits = 1 + bit_length(n)
+ assert 11 <= n_bits <= 16384
 for k, tt in (
 (100, 27),
 (150, 18),
@@ -591,7 +601,7 @@ def is_prime(n):
 s = s + 1
 r = r // 2
 for i in xrange(t):
- a = smallprimes[i]
+ a = random.choice(smallprimes)
 y = pow(a, r, n)
 if y != 1 and y != n - 1:
 j = 1
diff --git a/frozen_deps/ecdsa/ssh.py b/frozen_deps/ecdsa/ssh.py
new file mode 100644
index 0000000..64e9403
--- /dev/null
+++ b/frozen_deps/ecdsa/ssh.py
@@ -0,0 +1,83 @@
+import binascii
+from . import der
+from ._compat import compat26_str, int_to_bytes
+
+_SSH_ED25519 = b"ssh-ed25519"
+_SK_MAGIC = b"openssh-key-v1\0"
+_NONE = b"none"
+
+
+def _get_key_type(name):
+ if name == "Ed25519":
+ return _SSH_ED25519
+ else:
+ raise ValueError("Unsupported key type")
+
+
+class _Serializer:
+ def __init__(self):
+ self.bytes = b""
+
+ def put_raw(self, val):
+ self.bytes += val
+
+ def put_u32(self, val):
+ self.bytes += int_to_bytes(val, length=4, byteorder="big")
+
+ def put_str(self, val):
+ self.put_u32(len(val))
+ self.bytes += val
+
+ def put_pad(self, blklen=8):
+ padlen = blklen - (len(self.bytes) % blklen)
+ self.put_raw(bytearray(range(1, 1 + padlen)))
+
+ def encode(self):
+ return binascii.b2a_base64(compat26_str(self.bytes))
+
+ def tobytes(self):
+ return self.bytes
+
+ def topem(self):
+ return der.topem(self.bytes, "OPENSSH PRIVATE KEY")
+
+
+def serialize_public(name, pub):
+ serial = _Serializer()
+ ktype = _get_key_type(name)
+ serial.put_str(ktype)
+ serial.put_str(pub)
+ return b" ".join([ktype, serial.encode()])
+
+
+def serialize_private(name, pub, priv):
+ # encode public part
+ spub = _Serializer()
+ ktype = _get_key_type(name)
+ spub.put_str(ktype)
+ spub.put_str(pub)
+
+ # encode private part
+ spriv = _Serializer()
+ checksum = 0
+ spriv.put_u32(checksum)
+ spriv.put_u32(checksum)
+ spriv.put_raw(spub.tobytes())
+ spriv.put_str(priv + pub)
+ comment = b""
+ spriv.put_str(comment)
+ spriv.put_pad()
+
+ # top-level structure
+ main = _Serializer()
+ main.put_raw(_SK_MAGIC)
+ ciphername = kdfname = _NONE
+ main.put_str(ciphername)
+ main.put_str(kdfname)
+ nokdf = 0
+ main.put_u32(nokdf)
+ nkeys = 1
+ main.put_u32(nkeys)
+ main.put_str(spub.tobytes())
+ main.put_str(spriv.tobytes())
+ return main.topem()
diff --git a/frozen_deps/ecdsa/test_der.py b/frozen_deps/ecdsa/test_der.py
index 0ca5bd7..0c2dc4d 100644
--- a/frozen_deps/ecdsa/test_der.py
+++ b/frozen_deps/ecdsa/test_der.py
@@ -7,9 +7,9 @@ try:
 import unittest2 as unittest
 except ImportError:
 import unittest
-from six import b
+import sys
 import hypothesis.strategies as st
-from hypothesis import given
+from hypothesis import given, settings
 import pytest
 from ._compat import str_idx_as_int
 from .curves import NIST256p, NIST224p
@@ -32,44 +32,44 @@ class TestRemoveInteger(unittest.TestCase):
 # interpreted as negative, check if those errors are detected
 def test_non_minimal_encoding(self):
 with self.assertRaises(UnexpectedDER):
- remove_integer(b("\x02\x02\x00\x01"))
+ remove_integer(b"\x02\x02\x00\x01")
 
 def test_negative_with_high_bit_set(self):
 with self.assertRaises(UnexpectedDER):
- remove_integer(b("\x02\x01\x80"))
+ remove_integer(b"\x02\x01\x80")
 
 def test_minimal_with_high_bit_set(self):
- val, rem = remove_integer(b("\x02\x02\x00\x80"))
+ val, rem = remove_integer(b"\x02\x02\x00\x80")
 
 self.assertEqual(val, 0x80)
 self.assertEqual(rem, b"")
 
 def test_two_zero_bytes_with_high_bit_set(self):
 with self.assertRaises(UnexpectedDER):
- remove_integer(b("\x02\x03\x00\x00\xff"))
+ remove_integer(b"\x02\x03\x00\x00\xff")
 
 def test_zero_length_integer(self):
 with self.assertRaises(UnexpectedDER):
- remove_integer(b("\x02\x00"))
+ remove_integer(b"\x02\x00")
 
 def test_empty_string(self):
 with self.assertRaises(UnexpectedDER):
- remove_integer(b(""))
+ remove_integer(b"")
 
 def test_encoding_of_zero(self):
- val, rem = remove_integer(b("\x02\x01\x00"))
+ val, rem = remove_integer(b"\x02\x01\x00")
 
 self.assertEqual(val, 0)
 self.assertEqual(rem, b"")
 
 def test_encoding_of_127(self):
- val, rem = remove_integer(b("\x02\x01\x7f"))
+ val, rem = remove_integer(b"\x02\x01\x7f")
 
 self.assertEqual(val, 127)
 self.assertEqual(rem, b"")
 
 def test_encoding_of_128(self):
- val, rem = remove_integer(b("\x02\x02\x00\x80"))
+ val, rem = remove_integer(b"\x02\x02\x00\x80")
 
 self.assertEqual(val, 128)
 self.assertEqual(rem, b"")
@@ -92,37 +92,37 @@ class TestReadLength(unittest.TestCase):
 # form and lengths above that encoded with minimal number of bytes
 # necessary
 def test_zero_length(self):
- self.assertEqual((0, 1), read_length(b("\x00")))
+ self.assertEqual((0, 1), read_length(b"\x00"))
 
 def test_two_byte_zero_length(self):
 with self.assertRaises(UnexpectedDER):
- read_length(b("\x81\x00"))
+ read_length(b"\x81\x00")
 
 def test_two_byte_small_length(self):
 with self.assertRaises(UnexpectedDER):
- read_length(b("\x81\x7f"))
+ read_length(b"\x81\x7f")
 
 def test_long_form_with_zero_length(self):
 with self.assertRaises(UnexpectedDER):
- read_length(b("\x80"))
+ read_length(b"\x80")
 
 def test_smallest_two_byte_length(self):
- self.assertEqual((128, 2), read_length(b("\x81\x80")))
+ self.assertEqual((128, 2), read_length(b"\x81\x80"))
 
 def test_zero_padded_length(self):
 with self.assertRaises(UnexpectedDER):
- read_length(b("\x82\x00\x80"))
+ read_length(b"\x82\x00\x80")
 
 def test_two_three_byte_length(self):
 self.assertEqual((256, 3), read_length(b"\x82\x01\x00"))
 
 def test_empty_string(self):
 with self.assertRaises(UnexpectedDER):
- read_length(b(""))
+ read_length(b"")
 
 def test_length_overflow(self):
 with self.assertRaises(UnexpectedDER):
- read_length(b("\x83\x01\x00"))
+ read_length(b"\x83\x01\x00")
 
 
 class TestEncodeBitstring(unittest.TestCase):
@@ -144,26 +144,22 @@ class TestEncodeBitstring(unittest.TestCase):
 
 def test_new_call_convention(self):
 """This is how it should be called now."""
- warnings.simplefilter("always")
- with pytest.warns(None) as warns:
+ # make sure no warnings are raised
+ with warnings.catch_warnings():
+ warnings.simplefilter("error")
 der = encode_bitstring(b"\xff", 0)
 
- # verify that new call convention doesn't raise Warnings
- self.assertEqual(len(warns), 0)
-
 self.assertEqual(der, b"\x03\x02\x00\xff")
 
 def test_implicit_unused_bits(self):
 """
 Writing bit string with already included the number of unused bits.
 """
- warnings.simplefilter("always")
- with pytest.warns(None) as warns:
+ # make sure no warnings are raised
+ with warnings.catch_warnings():
+ warnings.simplefilter("error")
 der = encode_bitstring(b"\x00\xff", None)
 
- # verify that new call convention doesn't raise Warnings
- self.assertEqual(len(warns), 0)
-
 self.assertEqual(der, b"\x03\x02\x00\xff")
 
 def test_explicit_unused_bits(self):
@@ -203,22 +199,20 @@ class TestRemoveBitstring(unittest.TestCase):
 self.assertEqual(rest, b"")
 
 def test_new_call_convention(self):
- warnings.simplefilter("always")
- with pytest.warns(None) as warns:
+ # make sure no warnings are raised
+ with warnings.catch_warnings():
+ warnings.simplefilter("error")
 bits, rest = remove_bitstring(b"\x03\x02\x00\xff", 0)
 
- self.assertEqual(len(warns), 0)
-
 self.assertEqual(bits, b"\xff")
 self.assertEqual(rest, b"")
 
 def test_implicit_unexpected_unused(self):
- warnings.simplefilter("always")
- with pytest.warns(None) as warns:
+ # make sure no warnings are raised
+ with warnings.catch_warnings():
+ warnings.simplefilter("error")
 bits, rest = remove_bitstring(b"\x03\x02\x00\xff", None)
 
- self.assertEqual(len(warns), 0)
-
 self.assertEqual(bits, (b"\xff", 0))
 self.assertEqual(rest, b"")
 
@@ -275,10 +269,10 @@ class TestStrIdxAsInt(unittest.TestCase):
 class TestEncodeOid(unittest.TestCase):
 def test_pub_key_oid(self):
 oid_ecPublicKey = encode_oid(1, 2, 840, 10045, 2, 1)
- self.assertEqual(hexlify(oid_ecPublicKey), b("06072a8648ce3d0201"))
+ self.assertEqual(hexlify(oid_ecPublicKey), b"06072a8648ce3d0201")
 
 def test_nist224p_oid(self):
- self.assertEqual(hexlify(NIST224p.encoded_oid), b("06052b81040021"))
+ self.assertEqual(hexlify(NIST224p.encoded_oid), b"06052b81040021")
 
 def test_nist256p_oid(self):
 self.assertEqual(
@@ -468,6 +462,14 @@ def st_oid(draw, max_value=2**512, max_size=50):
 return (first, second) + tuple(rest)
 
 
+HYP_SETTINGS = {}
+
+
+if "--fast" in sys.argv: # pragma: no cover
+ HYP_SETTINGS["max_examples"] = 2
+
+
+@settings(**HYP_SETTINGS)
 @given(st_oid())
 def test_oids(ids):
 encoded_oid = encode_oid(*ids)
diff --git a/frozen_deps/ecdsa/test_ecdh.py b/frozen_deps/ecdsa/test_ecdh.py
index 872d4d1..cb22580 100644
--- a/frozen_deps/ecdsa/test_ecdh.py
+++ b/frozen_deps/ecdsa/test_ecdh.py
@@ -1,4 +1,5 @@
 import os
+import sys
 import shutil
 import subprocess
 import pytest
@@ -16,6 +17,8 @@ from .curves import (
 NIST384p,
 NIST521p,
 BRAINPOOLP160r1,
+ SECP112r2,
+ SECP128r1,
 )
 from .curves import curves
 from .ecdh import (
@@ -29,6 +32,10 @@ from .keys import SigningKey, VerifyingKey
 from .ellipticcurve import CurveEdTw
 
 
+if "--fast" in sys.argv: # pragma: no cover
+ curves = [SECP112r2, SECP128r1]
+
+
 @pytest.mark.parametrize(
 "vcurve",
 curves,
@@ -366,6 +373,7 @@ OPENSSL_SUPPORTED_CURVES = set(
 )
 
 
+[email protected]
 @pytest.mark.parametrize(
 "vcurve",
 curves,
diff --git a/frozen_deps/ecdsa/test_ecdsa.py b/frozen_deps/ecdsa/test_ecdsa.py
index dbc4a6e..c1e2582 100644
--- a/frozen_deps/ecdsa/test_ecdsa.py
+++ b/frozen_deps/ecdsa/test_ecdsa.py
@@ -27,6 +27,7 @@ from .ecdsa import (
 generator_112r2,
 int_to_string,
 )
+from .ellipticcurve import Point
 
 
 HYP_SETTINGS = {}
@@ -76,6 +77,19 @@ class TestP192FromX9_62(unittest.TestCase):
 def test_rejection(self):
 assert not self.pubk.verifies(self.msg - 1, self.sig)
 
+ def test_verification_with_regular_point(self):
+ pubk = Public_key(
+ Point(
+ generator_192.curve(),
+ generator_192.x(),
+ generator_192.y(),
+ generator_192.order(),
+ ),
+ self.pubk.point,
+ )
+
+ assert pubk.verifies(self.msg, self.sig)
+
 
 class TestPublicKey(unittest.TestCase):
 def test_equality_public_keys(self):
@@ -584,7 +598,13 @@ def test_signature_validity(gen, msg, qx, qy, r, s, expected):
 elliptic curve of `gen`, `r` and `s` are the signature, and
 `expected` is True iff the signature is expected to be valid."""
 pubk = Public_key(gen, ellipticcurve.Point(gen.curve(), qx, qy))
- assert expected == pubk.verifies(digest_integer(msg), Signature(r, s))
+ with pytest.warns(DeprecationWarning) as warns:
+ msg_dgst = digest_integer(msg)
+ assert len(warns) == 3
+ assert "unused" in warns[0].message.args[0]
+ assert "unused" in warns[1].message.args[0]
+ assert "unused" in warns[2].message.args[0]
+ assert expected == pubk.verifies(msg_dgst, Signature(r, s))
 
 
 @pytest.mark.parametrize(
@@ -593,7 +613,13 @@ def test_signature_validity(gen, msg, qx, qy, r, s, expected):
 def test_pk_recovery(gen, msg, r, s, qx, qy, expected):
 del expected
 sign = Signature(r, s)
- pks = sign.recover_public_keys(digest_integer(msg), gen)
+ with pytest.warns(DeprecationWarning) as warns:
+ msg_dgst = digest_integer(msg)
+ assert len(warns) == 3
+ assert "unused" in warns[0].message.args[0]
+ assert "unused" in warns[1].message.args[0]
+ assert "unused" in warns[2].message.args[0]
+ pks = sign.recover_public_keys(msg_dgst, gen)
 
 assert pks
 
@@ -622,19 +648,22 @@ def st_random_gen_key_msg_nonce(draw):
 name = draw(st.sampled_from(sorted(name_gen.keys())))
 note("Generator used: {0}".format(name))
 generator = name_gen[name]
- order = int(generator.order())
+ order = int(generator.order()) - 1
 
 key = draw(st.integers(min_value=1, max_value=order))
 msg = draw(st.integers(min_value=1, max_value=order))
 nonce = draw(
- st.integers(min_value=1, max_value=order + 1)
+ st.integers(min_value=1, max_value=order)
 | st.integers(min_value=order >> 1, max_value=order)
 )
 return generator, key, msg, nonce
 
 
 SIG_VER_SETTINGS = dict(HYP_SETTINGS)
-SIG_VER_SETTINGS["max_examples"] = 10
+if "--fast" in sys.argv: # pragma: no cover
+ SIG_VER_SETTINGS["max_examples"] = 1
+else:
+ SIG_VER_SETTINGS["max_examples"] = 10
 
 
 @settings(**SIG_VER_SETTINGS)
@@ -658,4 +687,8 @@ def test_sig_verify(args):
 
 
 def test_int_to_string_with_zero():
- assert int_to_string(0) == b"\x00"
+ with pytest.warns(DeprecationWarning) as warns:
+ assert int_to_string(0) == b"\x00"
+
+ assert len(warns) == 1
+ assert "unused" in warns[0].message.args[0]
diff --git a/frozen_deps/ecdsa/test_eddsa.py b/frozen_deps/ecdsa/test_eddsa.py
index 7a09ad7..6821b3b 100644
--- a/frozen_deps/ecdsa/test_eddsa.py
+++ b/frozen_deps/ecdsa/test_eddsa.py
@@ -1,3 +1,4 @@
+import sys
 import pickle
 import hashlib
 import pytest
@@ -162,6 +163,27 @@ def test_ed25519_eq_x_different_y():
 assert a != b
 
 
+def test_ed25519_mul_by_order():
+ g = PointEdwards(
+ curve_ed25519,
+ generator_ed25519.x(),
+ generator_ed25519.y(),
+ 1,
+ generator_ed25519.x() * generator_ed25519.y(),
+ )
+
+ assert g * generator_ed25519.order() == INFINITY
+
+
+def test_radd():
+
+ a = PointEdwards(curve_ed25519, 1, 1, 1, 1)
+
+ p = INFINITY + a
+
+ assert p == a
+
+
 def test_ed25519_test_normalisation_and_scaling():
 x = generator_ed25519.x()
 y = generator_ed25519.y()
@@ -259,6 +281,22 @@ class TestEd25519(unittest.TestCase):
 self.assertIn("different curve", str(e.exception))
 
 
+def test_generate_with_point():
+ x1 = int(
+ "427838232691226969392843410947554224151809796397784248136826"
+ "78720006717057747"
+ )
+ y1 = int(
+ "463168356949264781694283940034751631413079938662562256157830"
+ "33603165251855960"
+ )
+ p = PointEdwards(curve_ed25519, x1, y1, 1, x1 * y1)
+
+ pk = PublicKey(generator_ed25519, b"0" * 32, public_point=p)
+
+ assert pk.public_point() == p
+
+
 def test_ed25519_mul_to_order_min_1():
 x1 = int(
 "427838232691226969392843410947554224151809796397784248136826"
@@ -500,6 +538,7 @@ class TestEdDSAEquality(unittest.TestCase):
 key2 = PublicKey(generator_ed25519, b"\x01" * 32)
 
 self.assertEqual(key1, key2)
+ # verify that `__ne__` works as expected
 self.assertFalse(key1 != key2)
 
 def test_unequal_public_points(self):
@@ -519,6 +558,7 @@ class TestEdDSAEquality(unittest.TestCase):
 key2 = PublicKey(generator_ed448, b"\x03" * 56 + b"\x00")
 
 self.assertNotEqual(key1, key2)
+ # verify that `__ne__` works as expected
 self.assertTrue(key1 != key2)
 
 def test_equal_private_keys(self):
@@ -526,6 +566,7 @@ class TestEdDSAEquality(unittest.TestCase):
 key2 = PrivateKey(generator_ed25519, b"\x01" * 32)
 
 self.assertEqual(key1, key2)
+ # verify that `__ne__` works as expected
 self.assertFalse(key1 != key2)
 
 def test_unequal_private_keys(self):
@@ -533,6 +574,7 @@ class TestEdDSAEquality(unittest.TestCase):
 key2 = PrivateKey(generator_ed25519, b"\x02" * 32)
 
 self.assertNotEqual(key1, key2)
+ # verify that `__ne__` works as expected
 self.assertTrue(key1 != key2)
 
 def test_unequal_privatekey_to_string(self):
@@ -643,7 +685,10 @@ class TestInvalidEdDSAInputs(unittest.TestCase):
 
 
 HYP_SETTINGS = dict()
-HYP_SETTINGS["max_examples"] = 10
+if "--fast" in sys.argv: # pragma: no cover
+ HYP_SETTINGS["max_examples"] = 2
+else:
+ HYP_SETTINGS["max_examples"] = 10
 
 
 @settings(**HYP_SETTINGS)
diff --git a/frozen_deps/ecdsa/test_ellipticcurve.py b/frozen_deps/ecdsa/test_ellipticcurve.py
index 85faef4..9bf0951 100644
--- a/frozen_deps/ecdsa/test_ellipticcurve.py
+++ b/frozen_deps/ecdsa/test_ellipticcurve.py
@@ -14,7 +14,7 @@ try:
 except ImportError: # pragma: no cover
 HC_PRESENT = False
 from .numbertheory import inverse_mod
-from .ellipticcurve import CurveFp, INFINITY, Point
+from .ellipticcurve import CurveFp, INFINITY, Point, CurveEdTw
 
 
 HYP_SETTINGS = {}
@@ -40,11 +40,11 @@ g_23 = Point(c_23, 13, 7, 7)
 
 
 HYP_SLOW_SETTINGS = dict(HYP_SETTINGS)
-HYP_SLOW_SETTINGS["max_examples"] = 10
+HYP_SLOW_SETTINGS["max_examples"] = 2
 
 
 @settings(**HYP_SLOW_SETTINGS)
-@given(st.integers(min_value=1, max_value=r + 1))
+@given(st.integers(min_value=1, max_value=r - 1))
 def test_p192_mult_tests(multiple):
 inv_m = inverse_mod(multiple, r)
 
@@ -97,6 +97,32 @@ class TestCurve(unittest.TestCase):
 self.assertDictEqual({c_23: None}, {eq1: None})
 self.assertIn(eq2, {eq3: None})
 
+ def test___str__(self):
+ self.assertEqual(str(self.c_23), "CurveFp(p=23, a=1, b=1)")
+
+ def test___str___with_cofactor(self):
+ c = CurveFp(23, 1, 1, 4)
+ self.assertEqual(str(c), "CurveFp(p=23, a=1, b=1, h=4)")
+
+
+class TestCurveEdTw(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.c_23 = CurveEdTw(23, 1, 1)
+
+ def test___str__(self):
+ self.assertEqual(str(self.c_23), "CurveEdTw(p=23, a=1, d=1)")
+
+ def test___str___with_cofactor(self):
+ c = CurveEdTw(23, 1, 1, 4)
+ self.assertEqual(str(c), "CurveEdTw(p=23, a=1, d=1, h=4)")
+
+ def test_usability_in_a_hashed_collection_curves(self):
+ {self.c_23: None}
+
+ def test_hashability_curves(self):
+ hash(self.c_23)
+
 
 class TestPoint(unittest.TestCase):
 @classmethod
@@ -197,3 +223,34 @@ class TestPoint(unittest.TestCase):
 def test_inequality_points_diff_types(self):
 c = CurveFp(100, -3, 100)
 self.assertNotEqual(self.g_23, c)
+
+ def test_to_bytes_from_bytes(self):
+ p = Point(self.c_23, 3, 10)
+
+ self.assertEqual(p, Point.from_bytes(self.c_23, p.to_bytes()))
+
+ def test_add_to_neg_self(self):
+ p = Point(self.c_23, 3, 10)
+
+ self.assertEqual(INFINITY, p + (-p))
+
+ def test_add_to_infinity(self):
+ p = Point(self.c_23, 3, 10)
+
+ self.assertIs(p, p + INFINITY)
+
+ def test_mul_infinity_by_scalar(self):
+ self.assertIs(INFINITY, INFINITY * 10)
+
+ def test_mul_by_negative(self):
+ p = Point(self.c_23, 3, 10)
+
+ self.assertEqual(p * -5, (-p) * 5)
+
+ def test_str_infinity(self):
+ self.assertEqual(str(INFINITY), "infinity")
+
+ def test_str_point(self):
+ p = Point(self.c_23, 3, 10)
+
+ self.assertEqual(str(p), "(3,10)")
diff --git a/frozen_deps/ecdsa/test_jacobi.py b/frozen_deps/ecdsa/test_jacobi.py
index 1f52804..9a46afe 100644
--- a/frozen_deps/ecdsa/test_jacobi.py
+++ b/frozen_deps/ecdsa/test_jacobi.py
@@ -1,4 +1,5 @@
 import pickle
+import sys
 
 try:
 import unittest2 as unittest
@@ -6,7 +7,6 @@ except ImportError:
 import unittest
 
 import os
-import sys
 import signal
 import pytest
 import threading
@@ -22,6 +22,7 @@ from .ecdsa import (
 generator_brainpoolp160r1,
 curve_brainpoolp160r1,
 generator_112r2,
+ curve_112r2,
 )
 from .numbertheory import inverse_mod
 from .util import randrange
@@ -32,6 +33,13 @@ if sys.version_info > (2, 7): # pragma: no branch
 NO_OLD_SETTINGS["deadline"] = 5000
 
 
+SLOW_SETTINGS = {}
+if "--fast" in sys.argv: # pragma: no cover
+ SLOW_SETTINGS["max_examples"] = 2
+else:
+ SLOW_SETTINGS["max_examples"] = 10
+
+
 class TestJacobi(unittest.TestCase):
 def test___init__(self):
 curve = object()
@@ -50,7 +58,7 @@ class TestJacobi(unittest.TestCase):
 p_a = PointJacobi.from_affine(generator_256)
 p_b = PointJacobi.from_affine(generator_224)
 
- with self.assertRaises(ValueError):
+ with self.assertRaises(ValueError): # pragma: no branch
 p_a + p_b
 
 def test_compare_different_curves(self):
@@ -199,10 +207,10 @@ class TestJacobi(unittest.TestCase):
 
 self.assertEqual(dbl, mlpl)
 
- @settings(max_examples=10)
+ @settings(**SLOW_SETTINGS)
 @given(
 st.integers(
- min_value=0, max_value=int(generator_brainpoolp160r1.order())
+ min_value=0, max_value=int(generator_brainpoolp160r1.order() - 1)
 )
 )
 def test_multiplications(self, mul):
@@ -214,10 +222,10 @@ class TestJacobi(unittest.TestCase):
 self.assertEqual((pj.x(), pj.y()), (pw.x(), pw.y()))
 self.assertEqual(pj, pw)
 
- @settings(max_examples=10)
+ @settings(**SLOW_SETTINGS)
 @given(
 st.integers(
- min_value=0, max_value=int(generator_brainpoolp160r1.order())
+ min_value=0, max_value=int(generator_brainpoolp160r1.order() - 1)
 )
 )
 @example(0)
@@ -232,13 +240,13 @@ class TestJacobi(unittest.TestCase):
 
 self.assertEqual(a, b)
 
- @settings(max_examples=10)
+ @settings(**SLOW_SETTINGS)
 @given(
 st.integers(
- min_value=1, max_value=int(generator_brainpoolp160r1.order())
+ min_value=1, max_value=int(generator_brainpoolp160r1.order() - 1)
 ),
 st.integers(
- min_value=1, max_value=int(generator_brainpoolp160r1.order())
+ min_value=1, max_value=int(generator_brainpoolp160r1.order() - 1)
 ),
 )
 @example(3, 3)
@@ -251,13 +259,13 @@ class TestJacobi(unittest.TestCase):
 
 self.assertEqual(c, j_g * (a_mul + b_mul))
 
- @settings(max_examples=10)
+ @settings(**SLOW_SETTINGS)
 @given(
 st.integers(
- min_value=1, max_value=int(generator_brainpoolp160r1.order())
+ min_value=1, max_value=int(generator_brainpoolp160r1.order() - 1)
 ),
 st.integers(
- min_value=1, max_value=int(generator_brainpoolp160r1.order())
+ min_value=1, max_value=int(generator_brainpoolp160r1.order() - 1)
 ),
 st.integers(min_value=1, max_value=int(curve_brainpoolp160r1.p() - 1)),
 )
@@ -283,13 +291,14 @@ class TestJacobi(unittest.TestCase):
 
 self.assertEqual(c, j_g * (a_mul + b_mul))
 
- @settings(max_examples=10)
+ @pytest.mark.slow
+ @settings(**SLOW_SETTINGS)
 @given(
 st.integers(
- min_value=1, max_value=int(generator_brainpoolp160r1.order())
+ min_value=1, max_value=int(generator_brainpoolp160r1.order() - 1)
 ),
 st.integers(
- min_value=1, max_value=int(generator_brainpoolp160r1.order())
+ min_value=1, max_value=int(generator_brainpoolp160r1.order() - 1)
 ),
 st.integers(min_value=1, max_value=int(curve_brainpoolp160r1.p() - 1)),
 )
@@ -348,13 +357,14 @@ class TestJacobi(unittest.TestCase):
 
 self.assertEqual(c, x + y)
 
- @settings(max_examples=14)
+ @pytest.mark.slow
+ @settings(**SLOW_SETTINGS)
 @given(
 st.integers(
- min_value=1, max_value=int(generator_brainpoolp160r1.order())
+ min_value=1, max_value=int(generator_brainpoolp160r1.order() - 1)
 ),
 st.integers(
- min_value=1, max_value=int(generator_brainpoolp160r1.order())
+ min_value=1, max_value=int(generator_brainpoolp160r1.order() - 1)
 ),
 st.lists(
 st.integers(
@@ -423,6 +433,78 @@ class TestJacobi(unittest.TestCase):
 
 self.assertEqual(c, x + y)
 
+ def test_add_different_points_same_scale_static(self):
+ j_g = generator_brainpoolp160r1
+ p = curve_brainpoolp160r1.p()
+ a = j_g * 11
+ a.scale()
+ b = j_g * 12
+ z = 13
+ x = PointJacobi(
+ curve_brainpoolp160r1,
+ a.x() * z**2 % p,
+ a.y() * z**3 % p,
+ z,
+ )
+ y = PointJacobi(
+ curve_brainpoolp160r1,
+ b.x() * z**2 % p,
+ b.y() * z**3 % p,
+ z,
+ )
+
+ c = a + b
+
+ self.assertEqual(c, x + y)
+
+ def test_add_same_point_different_scale_second_z_1_static(self):
+ j_g = generator_112r2
+ p = curve_112r2.p()
+ z = 11
+ a = j_g * z
+ a.scale()
+
+ x = PointJacobi(
+ curve_112r2,
+ a.x() * z**2 % p,
+ a.y() * z**3 % p,
+ z,
+ )
+ y = PointJacobi(
+ curve_112r2,
+ a.x(),
+ a.y(),
+ 1,
+ )
+
+ c = a + a
+
+ self.assertEqual(c, x + y)
+
+ def test_add_to_infinity_static(self):
+ j_g = generator_112r2
+
+ z = 11
+ a = j_g * z
+ a.scale()
+
+ b = -a
+
+ x = PointJacobi(
+ curve_112r2,
+ a.x(),
+ a.y(),
+ 1,
+ )
+ y = PointJacobi(
+ curve_112r2,
+ b.x(),
+ b.y(),
+ 1,
+ )
+
+ self.assertEqual(INFINITY, x + y)
+
 def test_add_point_3_times(self):
 j_g = PointJacobi.from_affine(generator_256)
 
@@ -553,13 +635,24 @@ class TestJacobi(unittest.TestCase):
 
 self.assertNotEqual(p_a, p_b)
 
+ def test_add_with_point_at_infinity(self):
+ pj1 = PointJacobi(curve=CurveFp(23, 1, 1, 1), x=2, y=3, z=1, order=1)
+ x, y, z = pj1._add(2, 3, 1, 5, 5, 0, 23)
+
+ self.assertEqual((x, y, z), (2, 3, 1))
+
 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)
 
+ @pytest.mark.slow
 @settings(**NO_OLD_SETTINGS)
+ @pytest.mark.skipif(
+ platform.python_implementation() == "PyPy",
+ reason="threading on PyPy breaks coverage",
+ )
 @given(st.integers(min_value=1, max_value=10))
- def test_multithreading(self, thread_num):
+ def test_multithreading(self, thread_num): # pragma: no cover
 # ensure that generator's precomputation table is filled
 generator_112r2 * 2
 
@@ -591,11 +684,14 @@ class TestJacobi(unittest.TestCase):
 generator_112r2._PointJacobi__precompute,
 )
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
- platform.system() == "Windows",
- reason="there are no signals on Windows",
+ platform.system() == "Windows"
+ or platform.python_implementation() == "PyPy",
+ reason="there are no signals on Windows, and threading breaks coverage"
+ " on PyPy",
 )
- def test_multithreading_with_interrupts(self):
+ def test_multithreading_with_interrupts(self): # pragma: no cover
 thread_num = 10
 # ensure that generator's precomputation table is filled
 generator_112r2 * 2
diff --git a/frozen_deps/ecdsa/test_keys.py b/frozen_deps/ecdsa/test_keys.py
index 25386b1..348475e 100644
--- a/frozen_deps/ecdsa/test_keys.py
+++ b/frozen_deps/ecdsa/test_keys.py
@@ -13,13 +13,20 @@ import array
 import pytest
 import hashlib
 
-from .keys import VerifyingKey, SigningKey, MalformedPointError
+from .keys import (
+ VerifyingKey,
+ SigningKey,
+ MalformedPointError,
+ BadSignatureError,
+)
 from .der import (
 unpem,
 UnexpectedDER,
 encode_sequence,
 encode_oid,
 encode_bitstring,
+ encode_integer,
+ encode_octet_string,
 )
 from .util import (
 sigencode_string,
@@ -120,6 +127,10 @@ class TestVerifyingKeyFromString(unittest.TestCase):
 
 self.assertEqual(self.vk.to_string(), vk.to_string())
 
+ def test_ed25519_VerifyingKey_from_string_imported(self):
+ with self.assertRaises(MalformedPointError):
+ VerifyingKey.from_string(b"AAA", Ed25519)
+
 
 class TestVerifyingKeyFromDer(unittest.TestCase):
 """
@@ -249,13 +260,13 @@ class TestVerifyingKeyFromDer(unittest.TestCase):
 self.assertEqual(self.vk.to_string(), vk.to_string())
 
 def test_equality_on_verifying_keys(self):
- self.assertEqual(self.vk, self.sk.get_verifying_key())
+ self.assertTrue(self.vk == self.sk.get_verifying_key())
 
 def test_inequality_on_verifying_keys(self):
- self.assertNotEqual(self.vk, self.vk2)
+ self.assertFalse(self.vk == self.vk2)
 
 def test_inequality_on_verifying_keys_not_implemented(self):
- self.assertNotEqual(self.vk, None)
+ self.assertFalse(self.vk == None)
 
 def test_VerifyingKey_inequality_on_same_curve(self):
 self.assertNotEqual(self.vk, self.sk2.verifying_key)
@@ -264,7 +275,7 @@ class TestVerifyingKeyFromDer(unittest.TestCase):
 self.assertNotEqual(self.sk, self.sk2)
 
 def test_inequality_on_wrong_types(self):
- self.assertNotEqual(self.vk, self.sk)
+ self.assertFalse(self.vk == self.sk)
 
 def test_from_public_point_old(self):
 pj = self.vk.pubkey.point
@@ -272,7 +283,7 @@ class TestVerifyingKeyFromDer(unittest.TestCase):
 
 vk = VerifyingKey.from_public_point(point, self.vk.curve)
 
- self.assertEqual(vk, self.vk)
+ self.assertTrue(vk == self.vk)
 
 def test_ed25519_VerifyingKey_repr__(self):
 sk = SigningKey.from_string(Ed25519.generator.to_bytes(), Ed25519)
@@ -364,6 +375,18 @@ class TestVerifyingKeyFromDer(unittest.TestCase):
 
 self.assertEqual(vk_pem, vk.to_pem())
 
+ def test_export_ed255_to_ssh(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_ssh = b"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAICMAUNDWZCIojuNViX5uQVeNrt5EJu5WJ7yF5gsvKstl\n"
+
+ self.assertEqual(vk_ssh, vk.to_ssh())
+
 def test_ed25519_export_import(self):
 sk = SigningKey.generate(Ed25519)
 vk = sk.verifying_key
@@ -393,6 +416,28 @@ class TestVerifyingKeyFromDer(unittest.TestCase):
 
 self.assertTrue(vk.verify(sig, data))
 
+ def test_ed25519_sig_verify_malformed(self):
+ vk_pem = (
+ "-----BEGIN PUBLIC KEY-----\n"
+ "MCowBQYDK2VwAyEAIwBQ0NZkIiiO41WJfm5BV42u3kQm7lYnvIXmCy8qy2U=\n"
+ "-----END PUBLIC KEY-----\n"
+ )
+
+ vk = VerifyingKey.from_pem(vk_pem)
+
+ data = b"data\n"
+
+ # modified signature from test_ed25519_sig_verify
+ sig = (
+ b"\xAA\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"
+ )
+
+ with self.assertRaises(BadSignatureError):
+ vk.verify(sig, data)
+
 def test_ed448_from_pem(self):
 pem_str = (
 "-----BEGIN PUBLIC KEY-----\n"
@@ -428,8 +473,8 @@ class TestVerifyingKeyFromDer(unittest.TestCase):
 
 vk_pem = (
 b"-----BEGIN PUBLIC KEY-----\n"
- b"MEMwBQYDK2VxAzoAeQtetSu7CMEzE+XWB10Bg47LCA0giNikOxHzdp+tZ/eK/En0\n"
- b"dTdYD2ll94g58MhSnBiBQB9A1MMA\n"
+ b"MEMwBQYDK2VxAzoAeQtetSu7CMEzE+XWB10Bg47LCA0giNikOxHzdp+tZ/eK/En0dTdYD2ll94g5\n"
+ b"8MhSnBiBQB9A1MMA\n"
 b"-----END PUBLIC KEY-----\n"
 )
 
@@ -505,6 +550,17 @@ class TestSigningKey(unittest.TestCase):
 )
 cls.sk2 = SigningKey.from_pem(prv_key_str)
 
+ def test_to_der_pkcs8(self):
+ self.assertEqual(
+ self.sk1.to_der(format="pkcs8"),
+ b"0o\x02\x01\x010\x13\x06\x07*\x86H\xce=\x02\x01\x06\x08*\x86H"
+ b"\xce=\x03\x01\x01\x04U0S\x02\x01\x01\x04\x18^\xc8B\x0b\xd6\xef"
+ b"\x92R\xa9B\xe9\x89\x04<\xa2\x9fV\x1f\xa5%w\x0e\xb1\xc5\xa14\x03"
+ b"2\x00\x04\xb8\x81w\xd0\x84\xef\x17\xf5\xe4V9@\x80(6\x0f\x9fY"
+ b"\xb4\xa4\xd7&Nb\xda\x06Q\xdc\xe4z5\xa4\xc5\xb4\\\xf5\x15\x93B:"
+ b"\x8bU{\x9c \x99\xf3l",
+ )
+
 def test_decoding_explicit_curve_parameters(self):
 prv_key_str = (
 "-----BEGIN PRIVATE KEY-----\n"
@@ -614,6 +670,99 @@ class TestSigningKey(unittest.TestCase):
 
 self.assertEqual(sk, sk_str)
 
+ def test_ed25519_from_der_bad_alg_id_params(self):
+ der_str = encode_sequence(
+ encode_integer(1),
+ encode_sequence(encode_oid(*Ed25519.oid), encode_integer(1)),
+ encode_octet_string(encode_octet_string(b"A" * 32)),
+ )
+
+ with self.assertRaises(UnexpectedDER) as e:
+ SigningKey.from_der(der_str)
+
+ self.assertIn("Non NULL parameters", str(e.exception))
+
+ def test_ed25519_from_der_junk_after_priv_key(self):
+ der_str = encode_sequence(
+ encode_integer(1),
+ encode_sequence(
+ encode_oid(*Ed25519.oid),
+ ),
+ encode_octet_string(encode_octet_string(b"A" * 32) + b"B"),
+ )
+
+ with self.assertRaises(UnexpectedDER) as e:
+ SigningKey.from_der(der_str)
+
+ self.assertIn(
+ "trailing junk after the encoded private key", str(e.exception)
+ )
+
+ def test_ed25519_sign(self):
+ 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,
+ )
+
+ msg = b"message"
+
+ sig = sk_str.sign(msg, sigencode=sigencode_der)
+
+ self.assertEqual(
+ sig,
+ b"\xe1,v\xc9>%\xda\xd2~>\xc3&\na\xf4@|\x9e`X\x11\x13@<\x987\xd4"
+ b"\r\xb1\xf5\xb3\x15\x7f%i{\xdf}\xdd\xb1\xf3\x02\x7f\x80\x02\xc2"
+ b'|\xe5\xd6\x06\xc4\n\xa3\xb0\xf6}\xc0\xed)"+E\xaf\x00',
+ )
+
+ def test_ed25519_sign_digest_deterministic(self):
+ 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,
+ )
+ with self.assertRaises(ValueError) as e:
+ sk_str.sign_digest_deterministic(b"a" * 20)
+
+ self.assertIn("Method unsupported for Edwards", str(e.exception))
+
+ def test_ed25519_sign_digest(self):
+ 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,
+ )
+ with self.assertRaises(ValueError) as e:
+ sk_str.sign_digest(b"a" * 20)
+
+ self.assertIn("Method unsupported for Edwards", str(e.exception))
+
+ def test_ed25519_sign_number(self):
+ 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,
+ )
+ with self.assertRaises(ValueError) as e:
+ sk_str.sign_number(20)
+
+ self.assertIn("Method unsupported for Edwards", str(e.exception))
+
+ def test_ed25519_to_der_ssleay(self):
+ pem_str = (
+ "-----BEGIN PRIVATE KEY-----\n"
+ "MC4CAQAwBQYDK2VwBCIEIDS6x9FO1PG8T4xIPg8Zd0z8uL6sVGZFEZrX17gHC/XU\n"
+ "-----END PRIVATE KEY-----\n"
+ )
+
+ sk = SigningKey.from_pem(pem_str)
+
+ with self.assertRaises(ValueError) as e:
+ sk.to_der(format="ssleay")
+
+ self.assertIn("Only PKCS#8 format", str(e.exception))
+
 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"
@@ -629,6 +778,25 @@ class TestSigningKey(unittest.TestCase):
 
 self.assertEqual(sk.to_pem(format="pkcs8"), pem_str)
 
+ def test_ed25519_to_ssh(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,
+ )
+
+ ssh_str = (
+ b"-----BEGIN OPENSSH PRIVATE KEY-----\n"
+ b"b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZWQyNTUx\n"
+ b"OQAAACAjAFDQ1mQiKI7jVYl+bkFXja7eRCbuVie8heYLLyrLZQAAAIgAAAAAAAAAAAAAAAtzc2gt\n"
+ b"ZWQyNTUxOQAAACAjAFDQ1mQiKI7jVYl+bkFXja7eRCbuVie8heYLLyrLZQAAAEA0usfRTtTxvE+M\n"
+ b"SD4PGXdM/Li+rFRmRRGa19e4Bwv11CMAUNDWZCIojuNViX5uQVeNrt5EJu5WJ7yF5gsvKstlAAAA\n"
+ b"AAECAwQF\n"
+ b"-----END OPENSSH PRIVATE KEY-----\n"
+ )
+
+ self.assertEqual(sk.to_ssh(), ssh_str)
+
 def test_ed25519_to_and_from_pem(self):
 sk = SigningKey.generate(Ed25519)
 
@@ -636,6 +804,17 @@ class TestSigningKey(unittest.TestCase):
 
 self.assertEqual(sk, decoded)
 
+ def test_ed25519_custom_entropy(self):
+ sk = SigningKey.generate(Ed25519, entropy=os.urandom)
+
+ self.assertIsNotNone(sk)
+
+ def test_ed25519_from_secret_exponent(self):
+ with self.assertRaises(ValueError) as e:
+ SigningKey.from_secret_exponent(1234567890, curve=Ed25519)
+
+ self.assertIn("don't support setting the secret", str(e.exception))
+
 def test_ed448_from_pem(self):
 pem_str = (
 "-----BEGIN PRIVATE KEY-----\n"
@@ -665,8 +844,8 @@ class TestSigningKey(unittest.TestCase):
 )
 pem_str = (
 b"-----BEGIN PRIVATE KEY-----\n"
- b"MEcCAQAwBQYDK2VxBDsEOTyFuXqFLXgJlV8uDqcOw9nG4IqzLiZ/i5NfBDoHPzmP\n"
- b"OP0JMYaLGlTzwovmvCDJ2zLaezu9NLz9aQ==\n"
+ b"MEcCAQAwBQYDK2VxBDsEOTyFuXqFLXgJlV8uDqcOw9nG4IqzLiZ/i5NfBDoHPzmPOP0JMYaLGlTz\n"
+ b"wovmvCDJ2zLaezu9NLz9aQ==\n"
 b"-----END PRIVATE KEY-----\n"
 )
 
@@ -769,8 +948,8 @@ assert isinstance(sig_strings[0], bytes)
 verifiers = []
 for modifier, fun in [
 ("bytes", lambda x: x),
- ("bytes memoryview", lambda x: buffer(x)),
- ("bytearray", lambda x: bytearray(x)),
+ ("bytes memoryview", buffer),
+ ("bytearray", bytearray),
 ("bytearray memoryview", lambda x: buffer(bytearray(x))),
 ("array.array of bytes", lambda x: array.array("B", x)),
 ("array.array of bytes memoryview", lambda x: buffer(array.array("B", x))),
@@ -939,14 +1118,14 @@ 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
+ assert not (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
+ assert not (sk1.verifying_key == sk2.verifying_key)
 
 
 def test_SigningKey_from_pem_pkcs8v2_EdDSA():
diff --git a/frozen_deps/ecdsa/test_malformed_sigs.py b/frozen_deps/ecdsa/test_malformed_sigs.py
index 8e1b611..e5a87c2 100644
--- a/frozen_deps/ecdsa/test_malformed_sigs.py
+++ b/frozen_deps/ecdsa/test_malformed_sigs.py
@@ -31,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
+from .curves import curves, SECP112r2, SECP128r1
 from .der import (
 encode_integer,
 encode_bitstring,
@@ -55,6 +55,10 @@ Needed for pairing with curves as we don't support hashes
 bigger than order sizes of curves."""
 
 
+if "--fast" in sys.argv: # pragma: no cover
+ curves = [SECP112r2, SECP128r1]
+
+
 keys_and_sigs = []
 """Name of the curve+hash combination, VerifyingKey and DER signature."""
 
@@ -91,7 +95,7 @@ def test_signatures(verifying_key, signature):
 
 
 @st.composite
-def st_fuzzed_sig(draw, keys_and_sigs):
+def st_fuzzed_sig(draw, keys_and_sigs): # pragma: no cover
 """
 Hypothesis strategy that generates pairs of VerifyingKey and malformed
 signatures created by fuzzing of a valid signature.
@@ -111,6 +115,7 @@ def st_fuzzed_sig(draw, keys_and_sigs):
 note("Remove bytes: {0}".format(to_remove))
 
 # decide which bytes of the original signature should be changed
+ xors = None
 if sig: # pragma: no branch
 xors = draw(
 st.dictionaries(
@@ -153,12 +158,17 @@ if sys.version_info >= (2, 7): # pragma: no branch
 HealthCheck.filter_too_much,
 HealthCheck.too_slow,
 ]
+if "--fast" in sys.argv: # pragma: no cover
+ params["max_examples"] = 20
 
 slow_params = dict(params)
-slow_params["max_examples"] = 10
+if "--fast" in sys.argv: # pragma: no cover
+ slow_params["max_examples"] = 1
+else:
+ slow_params["max_examples"] = 10
 
 
-@settings(**params)
+@settings(**slow_params)
 @given(st_fuzzed_sig(keys_and_sigs))
 def test_fuzzed_der_signatures(args):
 verifying_key, sig = args
@@ -168,7 +178,7 @@ def test_fuzzed_der_signatures(args):
 
 
 @st.composite
-def st_random_der_ecdsa_sig_value(draw):
+def st_random_der_ecdsa_sig_value(draw): # pragma: no cover
 """
 Hypothesis strategy for selecting random values and encoding them
 to ECDSA-Sig-Value object::
@@ -214,7 +224,7 @@ def test_random_der_ecdsa_sig_value(params):
 verifying_key.verify(sig, example_data, sigdecode=sigdecode_der)
 
 
-def st_der_integer(*args, **kwargs):
+def st_der_integer(*args, **kwargs): # pragma: no cover
 """
 Hypothesis strategy that returns a random positive integer as DER
 INTEGER.
@@ -226,7 +236,7 @@ def st_der_integer(*args, **kwargs):
 
 
 @st.composite
-def st_der_bit_string(draw, *args, **kwargs):
+def st_der_bit_string(draw, *args, **kwargs): # pragma: no cover
 """
 Hypothesis strategy that returns a random DER BIT STRING.
 Parameters are passed to hypothesis.strategy.binary.
@@ -242,7 +252,7 @@ def st_der_bit_string(draw, *args, **kwargs):
 return encode_bitstring(data, unused)
 
 
-def st_der_octet_string(*args, **kwargs):
+def st_der_octet_string(*args, **kwargs): # pragma: no cover
 """
 Hypothesis strategy that returns a random DER OCTET STRING object.
 Parameters are passed to hypothesis.strategy.binary
@@ -250,7 +260,7 @@ def st_der_octet_string(*args, **kwargs):
 return st.builds(encode_octet_string, st.binary(*args, **kwargs))
 
 
-def st_der_null():
+def st_der_null(): # pragma: no cover
 """
 Hypothesis strategy that returns DER NULL object.
 """
@@ -258,7 +268,7 @@ def st_der_null():
 
 
 @st.composite
-def st_der_oid(draw):
+def st_der_oid(draw): # pragma: no cover
 """
 Hypothesis strategy that returns DER OBJECT IDENTIFIER objects.
 """
@@ -273,7 +283,7 @@ def st_der_oid(draw):
 return encode_oid(first, second, *rest)
 
 
-def st_der():
+def st_der(): # pragma: no cover
 """
 Hypothesis strategy that returns random DER structures.
 
@@ -281,22 +291,20 @@ def st_der():
 of a valid DER structure, sequence of valid DER objects or a constructed
 encoding of any of the above.
 """
- return st.recursive(
+ return st.recursive( # pragma: no branch
 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_null()
 | st_der_oid(),
- lambda children: st.builds(
- lambda x: encode_octet_string(x), st.one_of(children)
- )
+ lambda children: st.builds(encode_octet_string, st.one_of(children))
 | st.builds(lambda x: encode_bitstring(x, 0), st.one_of(children))
 | st.builds(
 lambda x: encode_sequence(*x), st.lists(children, max_size=200)
 )
 | st.builds(
- lambda tag, x: encode_constructed(tag, x),
+ encode_constructed,
 st.integers(min_value=0, max_value=0x3F),
 st.one_of(children),
 ),
@@ -304,7 +312,7 @@ def st_der():
 )
 
 
-@settings(**params)
+@settings(**slow_params)
 @given(st.sampled_from(keys_and_sigs), st_der())
 def test_random_der_as_signature(params, der):
 """Check if random DER structures are rejected as signature"""
@@ -314,7 +322,7 @@ def test_random_der_as_signature(params, der):
 verifying_key.verify(der, example_data, sigdecode=sigdecode_der)
 
 
-@settings(**params)
+@settings(**slow_params)
 @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))
@@ -361,7 +369,7 @@ keys_and_string_sigs += [
 ]
 
 
-@settings(**params)
+@settings(**slow_params)
 @given(st_fuzzed_sig(keys_and_string_sigs))
 def test_fuzzed_string_signatures(params):
 verifying_key, sig = params
diff --git a/frozen_deps/ecdsa/test_numbertheory.py b/frozen_deps/ecdsa/test_numbertheory.py
index 8bc787f..966eca2 100644
--- a/frozen_deps/ecdsa/test_numbertheory.py
+++ b/frozen_deps/ecdsa/test_numbertheory.py
@@ -1,5 +1,6 @@
 import operator
 from functools import reduce
+import sys
 
 try:
 import unittest2 as unittest
@@ -29,6 +30,16 @@ from .numbertheory import (
 square_root_mod_prime,
 )
 
+try:
+ from gmpy2 import mpz
+except ImportError:
+ try:
+ from gmpy import mpz
+ except ImportError:
+
+ def mpz(x):
+ return x
+
 
 BIGPRIMES = (
 999671,
@@ -66,6 +77,7 @@ def test_next_prime_with_nums_less_2(val):
 assert next_prime(val) == 2
 
 
+[email protected]
 @pytest.mark.parametrize("prime", smallprimes)
 def test_square_root_mod_prime_for_small_primes(prime):
 squares = set()
@@ -182,7 +194,7 @@ def st_comp_with_com_fac(draw):
 # select at most 20 lists (returned numbers),
 # each having at most 30 primes (factors) including none (then the number
 # will be 1)
- comp_primes = draw(
+ comp_primes = draw( # pragma: no branch
 st.integers(min_value=1, max_value=20).flatmap(
 lambda n: st.lists(
 st.lists(st.sampled_from(primes), max_size=30),
@@ -225,7 +237,7 @@ def st_comp_no_com_fac(draw):
 
 # select at most 20 lists, each having at most 30 primes
 # selected from the leftover_primes list
- number_primes = draw(
+ number_primes = draw( # pragma: no branch
 st.integers(min_value=1, max_value=20).flatmap(
 lambda n: st.lists(
 st.lists(st.sampled_from(leftover_primes), max_size=30),
@@ -251,9 +263,15 @@ if HC_PRESENT: # pragma: no branch
 # the factorization() sometimes takes a long time to finish
 HYP_SETTINGS["deadline"] = 5000
 
+if "--fast" in sys.argv: # pragma: no cover
+ HYP_SETTINGS["max_examples"] = 20
+
 
 HYP_SLOW_SETTINGS = dict(HYP_SETTINGS)
-HYP_SLOW_SETTINGS["max_examples"] = 10
+if "--fast" in sys.argv: # pragma: no cover
+ HYP_SLOW_SETTINGS["max_examples"] = 1
+else:
+ HYP_SLOW_SETTINGS["max_examples"] = 20
 
 
 class TestIsPrime(unittest.TestCase):
@@ -285,7 +303,30 @@ class TestIsPrime(unittest.TestCase):
 
 def test_large_prime(self):
 # nextPrime[2^2048]
- assert is_prime(2**2048 + 0x3D5)
+ assert is_prime(mpz(2) ** 2048 + 0x3D5)
+
+ def test_pseudoprime_base_19(self):
+ assert not is_prime(1543267864443420616877677640751301)
+
+ def test_pseudoprime_base_300(self):
+ # F. Arnault "Constructing Carmichael Numbers Which Are Strong
+ # Pseudoprimes to Several Bases". Journal of Symbolic
+ # Computation. 20 (2): 151-161. doi:10.1006/jsco.1995.1042.
+ # Section 4.4 Large Example (a pseudoprime to all bases up to
+ # 300)
+ p = int(
+ "29 674 495 668 685 510 550 154 174 642 905 332 730 "
+ "771 991 799 853 043 350 995 075 531 276 838 753 171 "
+ "770 199 594 238 596 428 121 188 033 664 754 218 345 "
+ "562 493 168 782 883".replace(" ", "")
+ )
+
+ assert is_prime(p)
+ for _ in range(10):
+ if not is_prime(p * (313 * (p - 1) + 1) * (353 * (p - 1) + 1)):
+ break
+ else:
+ assert False, "composite not detected"
 
 
 class TestNumbertheory(unittest.TestCase):
@@ -301,6 +342,7 @@ class TestNumbertheory(unittest.TestCase):
 "case times-out on it",
 )
 @settings(**HYP_SLOW_SETTINGS)
+ @example([877 * 1151, 877 * 1009])
 @given(st_comp_with_com_fac())
 def test_gcd_with_com_factor(self, numbers):
 n = gcd(numbers)
@@ -315,11 +357,13 @@ class TestNumbertheory(unittest.TestCase):
 "case times-out on it",
 )
 @settings(**HYP_SLOW_SETTINGS)
+ @example([1151, 1069, 1009])
 @given(st_comp_no_com_fac())
 def test_gcd_with_uncom_factor(self, numbers):
 n = gcd(numbers)
 assert n == 1
 
+ @settings(**HYP_SLOW_SETTINGS)
 @given(
 st.lists(
 st.integers(min_value=1, max_value=2**8192),
@@ -338,6 +382,7 @@ class TestNumbertheory(unittest.TestCase):
 assert lcm([3, 5 * 3, 7 * 3]) == 3 * 5 * 7
 assert lcm(3) == 3
 
+ @settings(**HYP_SLOW_SETTINGS)
 @given(
 st.lists(
 st.integers(min_value=1, max_value=2**8192),
@@ -356,7 +401,7 @@ class TestNumbertheory(unittest.TestCase):
 "meet requirements (like `is_prime()`), the test "
 "case times-out on it",
 )
- @settings(**HYP_SETTINGS)
+ @settings(**HYP_SLOW_SETTINGS)
 @given(st_num_square_prime())
 def test_square_root_mod_prime(self, vals):
 square, prime = vals
@@ -364,7 +409,8 @@ class TestNumbertheory(unittest.TestCase):
 calc = square_root_mod_prime(square, prime)
 assert calc * calc % prime == square
 
- @settings(**HYP_SETTINGS)
+ @pytest.mark.slow
+ @settings(**HYP_SLOW_SETTINGS)
 @given(st.integers(min_value=1, max_value=10**12))
 @example(265399 * 1526929)
 @example(373297**2 * 553991)
@@ -401,16 +447,19 @@ class TestNumbertheory(unittest.TestCase):
 def test_jacobi_with_one(self):
 assert jacobi(1, 3) == 1
 
- @settings(**HYP_SETTINGS)
+ @settings(**HYP_SLOW_SETTINGS)
 @given(st.integers(min_value=3, max_value=1000).filter(lambda x: x % 2))
 def test_jacobi(self, mod):
+ mod = mpz(mod)
 if is_prime(mod):
 squares = set()
 for root in range(1, mod):
+ root = mpz(root)
 assert jacobi(root * root, mod) == 1
 squares.add(root * root % mod)
 for i in range(1, mod):
 if i not in squares:
+ i = mpz(i)
 assert jacobi(i, mod) == -1
 else:
 factors = factorization(mod)
@@ -420,6 +469,7 @@ class TestNumbertheory(unittest.TestCase):
 c *= jacobi(a, i[0]) ** i[1]
 assert c == jacobi(a, mod)
 
+ @settings(**HYP_SLOW_SETTINGS)
 @given(st_two_nums_rel_prime())
 def test_inverse_mod(self, nums):
 num, mod = nums
diff --git a/frozen_deps/ecdsa/test_pyecdsa.py b/frozen_deps/ecdsa/test_pyecdsa.py
index d61f508..20201ba 100644
--- a/frozen_deps/ecdsa/test_pyecdsa.py
+++ b/frozen_deps/ecdsa/test_pyecdsa.py
@@ -5,24 +5,29 @@ try:
 except ImportError:
 import unittest
 import os
-import sys
 import shutil
 import subprocess
 import pytest
+import sys
 from binascii import hexlify, unhexlify
-from hashlib import sha1, sha256, sha384, sha512
 import hashlib
 from functools import partial
 
-from hypothesis import given
+from hypothesis import given, settings
 import hypothesis.strategies as st
 
 from six import b, print_, binary_type
 from .keys import SigningKey, VerifyingKey
 from .keys import BadSignatureError, MalformedPointError, BadDigestError
 from . import util
-from .util import sigencode_der, sigencode_strings
-from .util import sigdecode_der, sigdecode_strings
+from .util import (
+ sigencode_der,
+ sigencode_strings,
+ sigencode_strings_canonize,
+ sigencode_string_canonize,
+ sigencode_der_canonize,
+)
+from .util import sigdecode_der, sigdecode_strings, sigdecode_string
 from .util import number_to_string, encoded_oid_ecPublicKey, MalformedSignature
 from .curves import Curve, UnknownCurveError
 from .curves import (
@@ -43,6 +48,13 @@ from .curves import (
 BRAINPOOLP320r1,
 BRAINPOOLP384r1,
 BRAINPOOLP512r1,
+ BRAINPOOLP160t1,
+ BRAINPOOLP192t1,
+ BRAINPOOLP224t1,
+ BRAINPOOLP256t1,
+ BRAINPOOLP320t1,
+ BRAINPOOLP384t1,
+ BRAINPOOLP512t1,
 Ed25519,
 Ed448,
 curves,
@@ -63,6 +75,13 @@ class SubprocessError(Exception):
 pass
 
 
+HYP_SETTINGS = {}
+
+
+if "--fast" in sys.argv: # pragma: no cover
+ HYP_SETTINGS["max_examples"] = 2
+
+
 def run_openssl(cmd):
 OPENSSL = "openssl"
 p = subprocess.Popen(
@@ -84,24 +103,29 @@ class ECDSA(unittest.TestCase):
 priv = SigningKey.generate()
 pub = priv.get_verifying_key()
 
- data = b("blahblah")
+ data = b"blahblah"
 sig = priv.sign(data)
 
 self.assertTrue(pub.verify(sig, data))
- self.assertRaises(BadSignatureError, pub.verify, sig, data + b("bad"))
+ self.assertRaises(BadSignatureError, pub.verify, sig, data + b"bad")
 
 pub2 = VerifyingKey.from_string(pub.to_string())
 self.assertTrue(pub2.verify(sig, data))
 
 def test_deterministic(self):
- data = b("blahblah")
+ data = b"blahblah"
 secexp = int("9d0219792467d7d37b4d43298a7d0c05", 16)
 
- priv = SigningKey.from_secret_exponent(secexp, SECP256k1, sha256)
+ priv = SigningKey.from_secret_exponent(
+ secexp, SECP256k1, hashlib.sha256
+ )
 pub = priv.get_verifying_key()
 
 k = rfc6979.generate_k(
- SECP256k1.generator.order(), secexp, sha256, sha256(data).digest()
+ SECP256k1.generator.order(),
+ secexp,
+ hashlib.sha256,
+ hashlib.sha256(data).digest(),
 )
 
 sig1 = priv.sign(data, k=k)
@@ -110,7 +134,7 @@ class ECDSA(unittest.TestCase):
 sig2 = priv.sign(data, k=k)
 self.assertTrue(pub.verify(sig2, data))
 
- sig3 = priv.sign_deterministic(data, sha256)
+ sig3 = priv.sign_deterministic(data, hashlib.sha256)
 self.assertTrue(pub.verify(sig3, data))
 
 self.assertEqual(sig1, sig2)
@@ -121,37 +145,16 @@ class ECDSA(unittest.TestCase):
 self.assertRaises(TypeError, SigningKey)
 self.assertRaises(TypeError, VerifyingKey)
 
- def test_lengths(self):
+ def test_lengths_default(self):
 default = NIST192p
 priv = SigningKey.generate()
 pub = priv.get_verifying_key()
 self.assertEqual(len(pub.to_string()), default.verifying_key_length)
- sig = priv.sign(b("data"))
+ sig = priv.sign(b"data")
 self.assertEqual(len(sig), default.signature_length)
- for curve in (
- NIST192p,
- NIST224p,
- NIST256p,
- NIST384p,
- NIST521p,
- BRAINPOOLP160r1,
- BRAINPOOLP192r1,
- BRAINPOOLP224r1,
- BRAINPOOLP256r1,
- BRAINPOOLP320r1,
- BRAINPOOLP384r1,
- BRAINPOOLP512r1,
- ):
- priv = SigningKey.generate(curve=curve)
- pub1 = priv.get_verifying_key()
- 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)
- sig = priv.sign(b("data"))
- self.assertEqual(len(sig), curve.signature_length)
 
 def test_serialize(self):
- seed = b("secret")
+ seed = b"secret"
 curve = NIST192p
 secexp1 = util.randrange_from_seed__trytryagain(seed, curve.order)
 secexp2 = util.randrange_from_seed__trytryagain(seed, curve.order)
@@ -164,7 +167,7 @@ class ECDSA(unittest.TestCase):
 self.assertEqual(priv1.to_pem(), priv2.to_pem())
 pub1 = priv1.get_verifying_key()
 pub2 = priv2.get_verifying_key()
- data = b("data")
+ data = b"data"
 sig1 = priv1.sign(data)
 sig2 = priv2.sign(data)
 self.assertTrue(pub1.verify(sig1, data))
@@ -174,7 +177,7 @@ class ECDSA(unittest.TestCase):
 self.assertEqual(hexlify(pub1.to_string()), hexlify(pub2.to_string()))
 
 def test_nonrandom(self):
- s = b("all the entropy in the entire world, compressed into one line")
+ s = b"all the entropy in the entire world, compressed into one line"
 
 def not_much_entropy(numbytes):
 return s[:numbytes]
@@ -190,8 +193,8 @@ class ECDSA(unittest.TestCase):
 # want to do this with keys you care about, because the secrecy of
 # the private key depends upon using different random numbers for
 # each signature
- sig1 = priv1.sign(b("data"), entropy=not_much_entropy)
- sig2 = priv2.sign(b("data"), entropy=not_much_entropy)
+ sig1 = priv1.sign(b"data", entropy=not_much_entropy)
+ sig2 = priv2.sign(b"data", entropy=not_much_entropy)
 self.assertEqual(hexlify(sig1), hexlify(sig2))
 
 def assertTruePrivkeysEqual(self, priv1, priv2):
@@ -204,7 +207,7 @@ class ECDSA(unittest.TestCase):
 )
 
 def test_privkey_creation(self):
- s = b("all the entropy in the entire world, compressed into one line")
+ s = b"all the entropy in the entire world, compressed into one line"
 
 def not_much_entropy(numbytes):
 return s[:numbytes]
@@ -239,8 +242,8 @@ class ECDSA(unittest.TestCase):
 
 s1 = priv1.to_pem()
 self.assertEqual(type(s1), binary_type)
- self.assertTrue(s1.startswith(b("-----BEGIN EC PRIVATE KEY-----")))
- self.assertTrue(s1.strip().endswith(b("-----END EC PRIVATE KEY-----")))
+ self.assertTrue(s1.startswith(b"-----BEGIN EC PRIVATE KEY-----"))
+ self.assertTrue(s1.strip().endswith(b"-----END EC PRIVATE KEY-----"))
 priv2 = SigningKey.from_pem(s1)
 self.assertTruePrivkeysEqual(priv1, priv2)
 
@@ -252,8 +255,8 @@ class ECDSA(unittest.TestCase):
 priv1 = SigningKey.generate(curve=NIST256p)
 s1 = priv1.to_pem()
 self.assertEqual(type(s1), binary_type)
- self.assertTrue(s1.startswith(b("-----BEGIN EC PRIVATE KEY-----")))
- self.assertTrue(s1.strip().endswith(b("-----END EC PRIVATE KEY-----")))
+ self.assertTrue(s1.startswith(b"-----BEGIN EC PRIVATE KEY-----"))
+ self.assertTrue(s1.strip().endswith(b"-----END EC PRIVATE KEY-----"))
 priv2 = SigningKey.from_pem(s1)
 self.assertTruePrivkeysEqual(priv1, priv2)
 
@@ -266,8 +269,8 @@ class ECDSA(unittest.TestCase):
 priv1 = SigningKey.generate(curve=BRAINPOOLP512r1)
 s1 = priv1.to_pem()
 self.assertEqual(type(s1), binary_type)
- self.assertTrue(s1.startswith(b("-----BEGIN EC PRIVATE KEY-----")))
- self.assertTrue(s1.strip().endswith(b("-----END EC PRIVATE KEY-----")))
+ self.assertTrue(s1.startswith(b"-----BEGIN EC PRIVATE KEY-----"))
+ self.assertTrue(s1.strip().endswith(b"-----END EC PRIVATE KEY-----"))
 priv2 = SigningKey.from_pem(s1)
 self.assertTruePrivkeysEqual(priv1, priv2)
 
@@ -304,7 +307,7 @@ class ECDSA(unittest.TestCase):
 self.assertTruePubkeysEqual(pub1, pub2)
 
 self.assertRaises(
- der.UnexpectedDER, VerifyingKey.from_der, pub1_der + b("junk")
+ der.UnexpectedDER, VerifyingKey.from_der, pub1_der + b"junk"
 )
 badpub = VerifyingKey.from_der(pub1_der)
 
@@ -328,10 +331,8 @@ class ECDSA(unittest.TestCase):
 
 pem = pub1.to_pem()
 self.assertEqual(type(pem), binary_type)
- self.assertTrue(pem.startswith(b("-----BEGIN PUBLIC KEY-----")), pem)
- self.assertTrue(
- pem.strip().endswith(b("-----END PUBLIC KEY-----")), pem
- )
+ self.assertTrue(pem.startswith(b"-----BEGIN PUBLIC KEY-----"), pem)
+ self.assertTrue(pem.strip().endswith(b"-----END PUBLIC KEY-----"), pem)
 pub2 = VerifyingKey.from_pem(pem)
 self.assertTruePubkeysEqual(pub1, pub2)
 
@@ -388,7 +389,7 @@ class ECDSA(unittest.TestCase):
 type_oid_der = encoded_oid_ecPublicKey
 curve_oid_der = der.encode_oid(*(1, 2, 840, 10045, 3, 1, 1))
 enc_type_der = der.encode_sequence(type_oid_der, curve_oid_der)
- point_der = der.encode_bitstring(b"\x00\xff", None) + b("garbage")
+ point_der = der.encode_bitstring(b"\x00\xff", None) + b"garbage"
 to_decode = der.encode_sequence(enc_type_der, point_der)
 
 with self.assertRaises(der.UnexpectedDER):
@@ -427,7 +428,7 @@ class ECDSA(unittest.TestCase):
 def test_signature_strings(self):
 priv1 = SigningKey.generate()
 pub1 = priv1.get_verifying_key()
- data = b("data")
+ data = b"data"
 
 sig = priv1.sign(data)
 self.assertEqual(type(sig), binary_type)
@@ -447,24 +448,96 @@ class ECDSA(unittest.TestCase):
 self.assertEqual(type(sig_der), binary_type)
 self.assertTrue(pub1.verify(sig_der, data, sigdecode=sigdecode_der))
 
+ def test_sigencode_string_canonize_no_change(self):
+ r = 12
+ s = 400
+ order = SECP112r1.order
+
+ new_r, new_s = sigdecode_string(
+ sigencode_string_canonize(r, s, order), order
+ )
+
+ self.assertEqual(r, new_r)
+ self.assertEqual(s, new_s)
+
+ def test_sigencode_string_canonize(self):
+ r = 12
+ order = SECP112r1.order
+ s = order - 10
+
+ new_r, new_s = sigdecode_string(
+ sigencode_string_canonize(r, s, order), order
+ )
+
+ self.assertEqual(r, new_r)
+ self.assertEqual(order - s, new_s)
+
+ def test_sigencode_strings_canonize_no_change(self):
+ r = 12
+ s = 400
+ order = SECP112r1.order
+
+ new_r, new_s = sigdecode_strings(
+ sigencode_strings_canonize(r, s, order), order
+ )
+
+ self.assertEqual(r, new_r)
+ self.assertEqual(s, new_s)
+
+ def test_sigencode_strings_canonize(self):
+ r = 12
+ order = SECP112r1.order
+ s = order - 10
+
+ new_r, new_s = sigdecode_strings(
+ sigencode_strings_canonize(r, s, order), order
+ )
+
+ self.assertEqual(r, new_r)
+ self.assertEqual(order - s, new_s)
+
+ def test_sigencode_der_canonize_no_change(self):
+ r = 13
+ s = 200
+ order = SECP112r1.order
+
+ new_r, new_s = sigdecode_der(
+ sigencode_der_canonize(r, s, order), order
+ )
+
+ self.assertEqual(r, new_r)
+ self.assertEqual(s, new_s)
+
+ def test_sigencode_der_canonize(self):
+ r = 13
+ order = SECP112r1.order
+ s = order - 14
+
+ new_r, new_s = sigdecode_der(
+ sigencode_der_canonize(r, s, order), order
+ )
+
+ self.assertEqual(r, new_r)
+ self.assertEqual(order - s, new_s)
+
 def test_sig_decode_strings_with_invalid_count(self):
 with self.assertRaises(MalformedSignature):
- sigdecode_strings([b("one"), b("two"), b("three")], 0xFF)
+ sigdecode_strings([b"one", b"two", b"three"], 0xFF)
 
 def test_sig_decode_strings_with_wrong_r_len(self):
 with self.assertRaises(MalformedSignature):
- sigdecode_strings([b("one"), b("two")], 0xFF)
+ sigdecode_strings([b"one", b"two"], 0xFF)
 
 def test_sig_decode_strings_with_wrong_s_len(self):
 with self.assertRaises(MalformedSignature):
- sigdecode_strings([b("\xa0"), b("\xb0\xff")], 0xFF)
+ sigdecode_strings([b"\xa0", b"\xb0\xff"], 0xFF)
 
 def test_verify_with_too_long_input(self):
 sk = SigningKey.generate()
 vk = sk.verifying_key
 
 with self.assertRaises(BadDigestError):
- vk.verify_digest(None, b("\x00") * 128)
+ vk.verify_digest(None, b"\x00" * 128)
 
 def test_sk_from_secret_exponent_with_wrong_sec_exponent(self):
 with self.assertRaises(MalformedPointError):
@@ -472,11 +545,11 @@ class ECDSA(unittest.TestCase):
 
 def test_sk_from_string_with_wrong_len_string(self):
 with self.assertRaises(MalformedPointError):
- SigningKey.from_string(b("\x01"))
+ SigningKey.from_string(b"\x01")
 
 def test_sk_from_der_with_junk_after_sequence(self):
 ver_der = der.encode_integer(1)
- to_decode = der.encode_sequence(ver_der) + b("garbage")
+ to_decode = der.encode_sequence(ver_der) + b"garbage"
 
 with self.assertRaises(der.UnexpectedDER):
 SigningKey.from_der(to_decode)
@@ -490,7 +563,7 @@ class ECDSA(unittest.TestCase):
 
 def test_sk_from_der_invalid_const_tag(self):
 ver_der = der.encode_integer(1)
- privkey_der = der.encode_octet_string(b("\x00\xff"))
+ privkey_der = der.encode_octet_string(b"\x00\xff")
 curve_oid_der = der.encode_oid(*(1, 2, 3))
 const_der = der.encode_constructed(1, curve_oid_der)
 to_decode = der.encode_sequence(
@@ -502,8 +575,8 @@ class ECDSA(unittest.TestCase):
 
 def test_sk_from_der_garbage_after_privkey_oid(self):
 ver_der = der.encode_integer(1)
- privkey_der = der.encode_octet_string(b("\x00\xff"))
- curve_oid_der = der.encode_oid(*(1, 2, 3)) + b("garbage")
+ privkey_der = der.encode_octet_string(b"\x00\xff")
+ curve_oid_der = der.encode_oid(*(1, 2, 3)) + b"garbage"
 const_der = der.encode_constructed(0, curve_oid_der)
 to_decode = der.encode_sequence(
 ver_der, privkey_der, const_der, curve_oid_der
@@ -514,7 +587,7 @@ class ECDSA(unittest.TestCase):
 
 def test_sk_from_der_with_short_privkey(self):
 ver_der = der.encode_integer(1)
- privkey_der = der.encode_octet_string(b("\x00\xff"))
+ privkey_der = der.encode_octet_string(b"\x00\xff")
 curve_oid_der = der.encode_oid(*(1, 2, 840, 10045, 3, 1, 1))
 const_der = der.encode_constructed(0, curve_oid_der)
 to_decode = der.encode_sequence(
@@ -598,30 +671,32 @@ class ECDSA(unittest.TestCase):
 sk = SigningKey.from_secret_exponent(12)
 
 with self.assertRaises(BadDigestError):
- sk.sign_digest(b("\xff") * 64)
+ sk.sign_digest(b"\xff" * 64)
 
 def test_hashfunc(self):
- sk = SigningKey.generate(curve=NIST256p, hashfunc=sha256)
- data = b("security level is 128 bits")
+ sk = SigningKey.generate(curve=NIST256p, hashfunc=hashlib.sha256)
+ data = b"security level is 128 bits"
 sig = sk.sign(data)
 vk = VerifyingKey.from_string(
- sk.get_verifying_key().to_string(), curve=NIST256p, hashfunc=sha256
+ sk.get_verifying_key().to_string(),
+ curve=NIST256p,
+ hashfunc=hashlib.sha256,
 )
 self.assertTrue(vk.verify(sig, data))
 
 sk2 = SigningKey.generate(curve=NIST256p)
- sig2 = sk2.sign(data, hashfunc=sha256)
+ sig2 = sk2.sign(data, hashfunc=hashlib.sha256)
 vk2 = VerifyingKey.from_string(
 sk2.get_verifying_key().to_string(),
 curve=NIST256p,
- hashfunc=sha256,
+ hashfunc=hashlib.sha256,
 )
 self.assertTrue(vk2.verify(sig2, data))
 
 vk3 = VerifyingKey.from_string(
 sk.get_verifying_key().to_string(), curve=NIST256p
 )
- self.assertTrue(vk3.verify(sig, data, hashfunc=sha256))
+ self.assertTrue(vk3.verify(sig, data, hashfunc=hashlib.sha256))
 
 def test_public_key_recovery(self):
 # Create keys
@@ -631,7 +706,7 @@ class ECDSA(unittest.TestCase):
 vk = sk.get_verifying_key()
 
 # Sign a message
- data = b("blahblah")
+ data = b"blahblah"
 signature = sk.sign(data)
 
 # Recover verifying keys
@@ -660,16 +735,20 @@ class ECDSA(unittest.TestCase):
 # Create keys
 curve = BRAINPOOLP160r1
 
- sk = SigningKey.generate(curve=curve, hashfunc=sha256)
+ sk = SigningKey.generate(curve=curve, hashfunc=hashlib.sha256)
 vk = sk.get_verifying_key()
 
 # Sign a message
- data = b("blahblah")
+ data = b"blahblah"
 signature = sk.sign(data)
 
 # Recover verifying keys
 recovered_vks = VerifyingKey.from_public_key_recovery(
- signature, data, curve, hashfunc=sha256, allow_truncate=True
+ signature,
+ data,
+ curve,
+ hashfunc=hashlib.sha256,
+ allow_truncate=True,
 )
 
 # Test if each pk is valid
@@ -679,7 +758,7 @@ class ECDSA(unittest.TestCase):
 
 # Test if properties are equal
 self.assertEqual(vk.curve, recovered_vk.curve)
- self.assertEqual(sha256, recovered_vk.default_hashfunc)
+ self.assertEqual(hashlib.sha256, recovered_vk.default_hashfunc)
 
 # Test if original vk is the list of recovered keys
 self.assertIn(
@@ -698,9 +777,9 @@ class ECDSA(unittest.TestCase):
 )
 self.assertEqual(vk.to_string(), exp)
 self.assertEqual(vk.to_string("raw"), exp)
- self.assertEqual(vk.to_string("uncompressed"), b("\x04") + exp)
- self.assertEqual(vk.to_string("compressed"), b("\x02") + exp[:24])
- self.assertEqual(vk.to_string("hybrid"), b("\x06") + exp)
+ self.assertEqual(vk.to_string("uncompressed"), b"\x04" + exp)
+ self.assertEqual(vk.to_string("compressed"), b"\x02" + exp[:24])
+ self.assertEqual(vk.to_string("hybrid"), b"\x06" + exp)
 
 def test_decoding(self):
 sk = SigningKey.from_secret_exponent(123456789)
@@ -715,13 +794,13 @@ class ECDSA(unittest.TestCase):
 from_raw = VerifyingKey.from_string(enc)
 self.assertEqual(from_raw.pubkey.point, vk.pubkey.point)
 
- from_uncompressed = VerifyingKey.from_string(b("\x04") + enc)
+ from_uncompressed = VerifyingKey.from_string(b"\x04" + enc)
 self.assertEqual(from_uncompressed.pubkey.point, vk.pubkey.point)
 
- from_compressed = VerifyingKey.from_string(b("\x02") + enc[:24])
+ from_compressed = VerifyingKey.from_string(b"\x02" + enc[:24])
 self.assertEqual(from_compressed.pubkey.point, vk.pubkey.point)
 
- from_uncompressed = VerifyingKey.from_string(b("\x06") + enc)
+ 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):
@@ -797,7 +876,7 @@ class ECDSA(unittest.TestCase):
 )
 
 with self.assertRaises(MalformedPointError):
- VerifyingKey.from_string(b("\x02") + enc)
+ VerifyingKey.from_string(b"\x02" + enc)
 
 def test_decoding_with_malformed_compressed(self):
 enc = b(
@@ -807,7 +886,7 @@ class ECDSA(unittest.TestCase):
 )
 
 with self.assertRaises(MalformedPointError):
- VerifyingKey.from_string(b("\x01") + enc[:24])
+ VerifyingKey.from_string(b"\x01" + enc[:24])
 
 def test_decoding_with_inconsistent_hybrid(self):
 enc = b(
@@ -817,7 +896,7 @@ class ECDSA(unittest.TestCase):
 )
 
 with self.assertRaises(MalformedPointError):
- VerifyingKey.from_string(b("\x07") + enc)
+ VerifyingKey.from_string(b"\x07" + enc)
 
 def test_decoding_with_point_not_on_curve(self):
 enc = b(
@@ -827,18 +906,18 @@ class ECDSA(unittest.TestCase):
 )
 
 with self.assertRaises(MalformedPointError):
- VerifyingKey.from_string(enc[:47] + b("\x00"))
+ VerifyingKey.from_string(enc[:47] + b"\x00")
 
 def test_decoding_with_point_at_infinity(self):
 # decoding it is unsupported, as it's not necessary to encode it
 with self.assertRaises(MalformedPointError):
- VerifyingKey.from_string(b("\x00"))
+ VerifyingKey.from_string(b"\x00")
 
 def test_not_lying_on_curve(self):
 enc = number_to_string(NIST192p.curve.p(), NIST192p.curve.p() + 1)
 
 with self.assertRaises(MalformedPointError):
- VerifyingKey.from_string(b("\x02") + enc)
+ VerifyingKey.from_string(b"\x02" + enc)
 
 def test_from_string_with_invalid_curve_too_short_ver_key_len(self):
 # both verifying_key_length and baselen are calculated internally
@@ -849,7 +928,7 @@ class ECDSA(unittest.TestCase):
 curve.baselen = 32
 
 with self.assertRaises(MalformedPointError):
- VerifyingKey.from_string(b("\x00") * 16, curve)
+ VerifyingKey.from_string(b"\x00" * 16, curve)
 
 def test_from_string_with_invalid_curve_too_long_ver_key_len(self):
 # both verifying_key_length and baselen are calculated internally
@@ -860,7 +939,7 @@ class ECDSA(unittest.TestCase):
 curve.baselen = 16
 
 with self.assertRaises(MalformedPointError):
- VerifyingKey.from_string(b("\x00") * 16, curve)
+ VerifyingKey.from_string(b"\x00" * 16, curve)
 
 
 @pytest.mark.parametrize(
@@ -870,9 +949,9 @@ def test_VerifyingKey_decode_with_small_values(val, even):
 enc = number_to_string(val, NIST192p.order)
 
 if even:
- enc = b("\x02") + enc
+ enc = b"\x02" + enc
 else:
- enc = b("\x03") + enc
+ enc = b"\x03" + enc
 
 # small values can both be actual valid public keys and not, verify that
 # only expected exceptions are raised if they are not
@@ -903,6 +982,24 @@ def test_VerifyingKey_encode_decode(curve, encoding):
 assert vk.pubkey.point == from_enc.pubkey.point
 
 
+if "--fast" in sys.argv: # pragma: no cover
+ params = [NIST192p, BRAINPOOLP160r1]
+else:
+ params = curves
+
+
+[email protected]("curve", params)
+def test_lengths(curve):
+ priv = SigningKey.generate(curve=curve)
+ pub1 = priv.get_verifying_key()
+ pub2 = VerifyingKey.from_string(pub1.to_string(), curve)
+ assert pub1.to_string() == pub2.to_string()
+ assert len(pub1.to_string()) == curve.verifying_key_length
+ sig = priv.sign(b"data")
+ assert len(sig) == curve.signature_length
+
+
+[email protected]
 class OpenSSL(unittest.TestCase):
 # test interoperability with OpenSSL tools. Note that openssl's ECDSA
 # sign/verify arguments changed between 0.9.8 and 1.0.0: the early
@@ -939,6 +1036,7 @@ class OpenSSL(unittest.TestCase):
 # vk: 3:OpenSSL->python 4:python->OpenSSL
 # sig: 5:OpenSSL->python 6:python->OpenSSL
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp112r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp112r1",
@@ -946,6 +1044,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_secp112r1(self):
 return self.do_test_from_openssl(SECP112r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp112r2" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp112r2",
@@ -953,6 +1052,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_secp112r2(self):
 return self.do_test_from_openssl(SECP112r2)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp128r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp128r1",
@@ -960,6 +1060,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_secp128r1(self):
 return self.do_test_from_openssl(SECP128r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp160r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp160r1",
@@ -967,6 +1068,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_secp160r1(self):
 return self.do_test_from_openssl(SECP160r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime192v1",
@@ -974,6 +1076,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_nist192p(self):
 return self.do_test_from_openssl(NIST192p)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime192v1",
@@ -981,6 +1084,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_nist192p_sha256(self):
 return self.do_test_from_openssl(NIST192p, "SHA256")
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp224r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp224r1",
@@ -988,6 +1092,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_nist224p(self):
 return self.do_test_from_openssl(NIST224p)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime256v1",
@@ -995,6 +1100,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_nist256p(self):
 return self.do_test_from_openssl(NIST256p)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime256v1",
@@ -1002,6 +1108,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_nist256p_sha384(self):
 return self.do_test_from_openssl(NIST256p, "SHA384")
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime256v1",
@@ -1009,6 +1116,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_nist256p_sha512(self):
 return self.do_test_from_openssl(NIST256p, "SHA512")
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp384r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp384r1",
@@ -1016,6 +1124,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_nist384p(self):
 return self.do_test_from_openssl(NIST384p)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp521r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp521r1",
@@ -1023,6 +1132,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_nist521p(self):
 return self.do_test_from_openssl(NIST521p)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp256k1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp256k1",
@@ -1030,6 +1140,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_secp256k1(self):
 return self.do_test_from_openssl(SECP256k1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP160r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP160r1",
@@ -1037,6 +1148,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_brainpoolp160r1(self):
 return self.do_test_from_openssl(BRAINPOOLP160r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP192r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP192r1",
@@ -1044,6 +1156,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_brainpoolp192r1(self):
 return self.do_test_from_openssl(BRAINPOOLP192r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP224r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP224r1",
@@ -1051,6 +1164,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_brainpoolp224r1(self):
 return self.do_test_from_openssl(BRAINPOOLP224r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP256r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP256r1",
@@ -1058,6 +1172,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_brainpoolp256r1(self):
 return self.do_test_from_openssl(BRAINPOOLP256r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP320r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP320r1",
@@ -1065,6 +1180,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_brainpoolp320r1(self):
 return self.do_test_from_openssl(BRAINPOOLP320r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP384r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP384r1",
@@ -1072,6 +1188,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_brainpoolp384r1(self):
 return self.do_test_from_openssl(BRAINPOOLP384r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP512r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP512r1",
@@ -1079,6 +1196,62 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_brainpoolp512r1(self):
 return self.do_test_from_openssl(BRAINPOOLP512r1)
 
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP160t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP160t1",
+ )
+ def test_from_openssl_brainpoolp160t1(self):
+ return self.do_test_from_openssl(BRAINPOOLP160t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP192t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP192t1",
+ )
+ def test_from_openssl_brainpoolp192t1(self):
+ return self.do_test_from_openssl(BRAINPOOLP192t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP224t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP224t1",
+ )
+ def test_from_openssl_brainpoolp224t1(self):
+ return self.do_test_from_openssl(BRAINPOOLP224t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP256t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP256t1",
+ )
+ def test_from_openssl_brainpoolp256t1(self):
+ return self.do_test_from_openssl(BRAINPOOLP256t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP320t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP320t1",
+ )
+ def test_from_openssl_brainpoolp320t1(self):
+ return self.do_test_from_openssl(BRAINPOOLP320t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP384t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP384t1",
+ )
+ def test_from_openssl_brainpoolp384t1(self):
+ return self.do_test_from_openssl(BRAINPOOLP384t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP512t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP512t1",
+ )
+ def test_from_openssl_brainpoolp512t1(self):
+ return self.do_test_from_openssl(BRAINPOOLP512t1)
+
 def do_test_from_openssl(self, curve, hash_name="SHA1"):
 curvename = curve.openssl_name
 assert curvename
@@ -1090,7 +1263,7 @@ class OpenSSL(unittest.TestCase):
 os.mkdir("t")
 run_openssl("ecparam -name %s -genkey -out t/privkey.pem" % curvename)
 run_openssl("ec -in t/privkey.pem -pubout -out t/pubkey.pem")
- data = b("data")
+ data = b"data"
 with open("t/data.txt", "wb") as e:
 e.write(data)
 run_openssl(
@@ -1131,6 +1304,7 @@ class OpenSSL(unittest.TestCase):
 sk_from_p8 = SigningKey.from_pem(privkey_p8_pem)
 self.assertEqual(sk, sk_from_p8)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp112r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp112r1",
@@ -1138,6 +1312,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_secp112r1(self):
 self.do_test_to_openssl(SECP112r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp112r2" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp112r2",
@@ -1145,6 +1320,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_secp112r2(self):
 self.do_test_to_openssl(SECP112r2)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp128r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp128r1",
@@ -1152,6 +1328,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_secp128r1(self):
 self.do_test_to_openssl(SECP128r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp160r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp160r1",
@@ -1159,6 +1336,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_secp160r1(self):
 self.do_test_to_openssl(SECP160r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime192v1",
@@ -1166,6 +1344,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_nist192p(self):
 self.do_test_to_openssl(NIST192p)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime192v1",
@@ -1173,6 +1352,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_nist192p_sha256(self):
 self.do_test_to_openssl(NIST192p, "SHA256")
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp224r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp224r1",
@@ -1180,6 +1360,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_nist224p(self):
 self.do_test_to_openssl(NIST224p)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime256v1",
@@ -1187,6 +1368,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_nist256p(self):
 self.do_test_to_openssl(NIST256p)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime256v1",
@@ -1194,6 +1376,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_nist256p_sha384(self):
 self.do_test_to_openssl(NIST256p, "SHA384")
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support prime256v1",
@@ -1201,6 +1384,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_nist256p_sha512(self):
 self.do_test_to_openssl(NIST256p, "SHA512")
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp384r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp384r1",
@@ -1208,6 +1392,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_nist384p(self):
 self.do_test_to_openssl(NIST384p)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp521r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp521r1",
@@ -1215,6 +1400,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_nist521p(self):
 self.do_test_to_openssl(NIST521p)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "secp256k1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support secp256k1",
@@ -1222,6 +1408,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_secp256k1(self):
 self.do_test_to_openssl(SECP256k1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP160r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP160r1",
@@ -1229,6 +1416,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_brainpoolp160r1(self):
 self.do_test_to_openssl(BRAINPOOLP160r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP192r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP192r1",
@@ -1236,6 +1424,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_brainpoolp192r1(self):
 self.do_test_to_openssl(BRAINPOOLP192r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP224r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP224r1",
@@ -1243,6 +1432,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_brainpoolp224r1(self):
 self.do_test_to_openssl(BRAINPOOLP224r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP256r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP256r1",
@@ -1250,6 +1440,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_brainpoolp256r1(self):
 self.do_test_to_openssl(BRAINPOOLP256r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP320r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP320r1",
@@ -1257,6 +1448,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_brainpoolp320r1(self):
 self.do_test_to_openssl(BRAINPOOLP320r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP384r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP384r1",
@@ -1264,6 +1456,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_brainpoolp384r1(self):
 self.do_test_to_openssl(BRAINPOOLP384r1)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "brainpoolP512r1" not in OPENSSL_SUPPORTED_CURVES,
 reason="system openssl does not support brainpoolP512r1",
@@ -1271,6 +1464,62 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_brainpoolp512r1(self):
 self.do_test_to_openssl(BRAINPOOLP512r1)
 
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP160t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP160t1",
+ )
+ def test_to_openssl_brainpoolp160t1(self):
+ self.do_test_to_openssl(BRAINPOOLP160t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP192t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP192t1",
+ )
+ def test_to_openssl_brainpoolp192t1(self):
+ self.do_test_to_openssl(BRAINPOOLP192t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP224t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP224t1",
+ )
+ def test_to_openssl_brainpoolp224t1(self):
+ self.do_test_to_openssl(BRAINPOOLP224t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP256t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP256t1",
+ )
+ def test_to_openssl_brainpoolp256t1(self):
+ self.do_test_to_openssl(BRAINPOOLP256t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP320t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP320t1",
+ )
+ def test_to_openssl_brainpoolp320t1(self):
+ self.do_test_to_openssl(BRAINPOOLP320t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP384t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP384t1",
+ )
+ def test_to_openssl_brainpoolp384t1(self):
+ self.do_test_to_openssl(BRAINPOOLP384t1)
+
+ @pytest.mark.slow
+ @pytest.mark.skipif(
+ "brainpoolP512t1" not in OPENSSL_SUPPORTED_CURVES,
+ reason="system openssl does not support brainpoolP512t1",
+ )
+ def test_to_openssl_brainpoolp512t1(self):
+ self.do_test_to_openssl(BRAINPOOLP512t1)
+
 def do_test_to_openssl(self, curve, hash_name="SHA1"):
 curvename = curve.openssl_name
 assert curvename
@@ -1282,7 +1531,7 @@ class OpenSSL(unittest.TestCase):
 os.mkdir("t")
 sk = SigningKey.generate(curve=curve)
 vk = sk.get_verifying_key()
- data = b("data")
+ data = b"data"
 with open("t/pubkey.der", "wb") as e:
 e.write(vk.to_der()) # 4
 with open("t/pubkey.pem", "wb") as e:
@@ -1298,7 +1547,7 @@ class OpenSSL(unittest.TestCase):
 with open("t/data.txt", "wb") as e:
 e.write(data)
 with open("t/baddata.txt", "wb") as e:
- e.write(data + b("corrupt"))
+ e.write(data + b"corrupt")
 
 self.assertRaises(
 SubprocessError,
@@ -1359,17 +1608,15 @@ class OpenSSL(unittest.TestCase):
 OPENSSL_SUPPORTED_TYPES = set()
 try:
 if "-rawin" in run_openssl("pkeyutl -help"):
- OPENSSL_SUPPORTED_TYPES = set(
+ OPENSSL_SUPPORTED_TYPES = set( # pragma: no branch
 c.lower()
 for c in ("ED25519", "ED448")
 if c in run_openssl("list -public-key-methods")
 )
- except SubprocessError:
+ except SubprocessError: # pragma: no cover
 pass
 
 def do_eddsa_test_to_openssl(self, curve):
- curvename = curve.name.upper()
-
 if os.path.isdir("t"):
 shutil.rmtree("t")
 os.mkdir("t")
@@ -1406,6 +1653,7 @@ class OpenSSL(unittest.TestCase):
 
 # 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.slow
 @pytest.mark.skipif(
 "ed25519" not in OPENSSL_SUPPORTED_TYPES,
 reason="system openssl does not support signing with Ed25519",
@@ -1413,6 +1661,7 @@ class OpenSSL(unittest.TestCase):
 def test_to_openssl_ed25519(self):
 return self.do_eddsa_test_to_openssl(Ed25519)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "ed448" not in OPENSSL_SUPPORTED_TYPES,
 reason="system openssl does not support signing with Ed448",
@@ -1456,6 +1705,7 @@ class OpenSSL(unittest.TestCase):
 
 shutil.rmtree("t")
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "ed25519" not in OPENSSL_SUPPORTED_TYPES,
 reason="system openssl does not support signing with Ed25519",
@@ -1463,6 +1713,7 @@ class OpenSSL(unittest.TestCase):
 def test_from_openssl_ed25519(self):
 return self.do_eddsa_test_from_openssl(Ed25519)
 
+ @pytest.mark.slow
 @pytest.mark.skipif(
 "ed448" not in OPENSSL_SUPPORTED_TYPES,
 reason="system openssl does not support signing with Ed448",
@@ -1483,7 +1734,7 @@ class TooSmallCurve(unittest.TestCase):
 )
 def test_sign_too_small_curve_dont_allow_truncate_raises(self):
 sk = SigningKey.generate(curve=NIST192p)
- data = b("data")
+ data = b"data"
 with self.assertRaises(BadDigestError):
 sk.sign(
 data,
@@ -1499,7 +1750,7 @@ class TooSmallCurve(unittest.TestCase):
 def test_verify_too_small_curve_dont_allow_truncate_raises(self):
 sk = SigningKey.generate(curve=NIST192p)
 vk = sk.get_verifying_key()
- data = b("data")
+ data = b"data"
 sig_der = sk.sign(
 data,
 hashfunc=partial(hashlib.new, "SHA256"),
@@ -1518,69 +1769,70 @@ class TooSmallCurve(unittest.TestCase):
 
 class DER(unittest.TestCase):
 def test_integer(self):
- self.assertEqual(der.encode_integer(0), b("\x02\x01\x00"))
- self.assertEqual(der.encode_integer(1), b("\x02\x01\x01"))
- self.assertEqual(der.encode_integer(127), b("\x02\x01\x7f"))
- self.assertEqual(der.encode_integer(128), b("\x02\x02\x00\x80"))
- self.assertEqual(der.encode_integer(256), b("\x02\x02\x01\x00"))
- # self.assertEqual(der.encode_integer(-1), b("\x02\x01\xff"))
+ self.assertEqual(der.encode_integer(0), b"\x02\x01\x00")
+ self.assertEqual(der.encode_integer(1), b"\x02\x01\x01")
+ self.assertEqual(der.encode_integer(127), b"\x02\x01\x7f")
+ self.assertEqual(der.encode_integer(128), b"\x02\x02\x00\x80")
+ self.assertEqual(der.encode_integer(256), b"\x02\x02\x01\x00")
+ # self.assertEqual(der.encode_integer(-1), b"\x02\x01\xff")
 
 def s(n):
- return der.remove_integer(der.encode_integer(n) + b("junk"))
+ return der.remove_integer(der.encode_integer(n) + b"junk")
 
- self.assertEqual(s(0), (0, b("junk")))
- self.assertEqual(s(1), (1, b("junk")))
- self.assertEqual(s(127), (127, b("junk")))
- self.assertEqual(s(128), (128, b("junk")))
- self.assertEqual(s(256), (256, b("junk")))
+ self.assertEqual(s(0), (0, b"junk"))
+ self.assertEqual(s(1), (1, b"junk"))
+ self.assertEqual(s(127), (127, b"junk"))
+ self.assertEqual(s(128), (128, b"junk"))
+ self.assertEqual(s(256), (256, b"junk"))
 self.assertEqual(
 s(1234567890123456789012345678901234567890),
- (1234567890123456789012345678901234567890, b("junk")),
+ (1234567890123456789012345678901234567890, b"junk"),
 )
 
 def test_number(self):
- self.assertEqual(der.encode_number(0), b("\x00"))
- self.assertEqual(der.encode_number(127), b("\x7f"))
- self.assertEqual(der.encode_number(128), b("\x81\x00"))
- self.assertEqual(der.encode_number(3 * 128 + 7), b("\x83\x07"))
+ self.assertEqual(der.encode_number(0), b"\x00")
+ self.assertEqual(der.encode_number(127), b"\x7f")
+ self.assertEqual(der.encode_number(128), b"\x81\x00")
+ self.assertEqual(der.encode_number(3 * 128 + 7), b"\x83\x07")
 # self.assertEqual(der.read_number("\x81\x9b" + "more"), (155, 2))
- # self.assertEqual(der.encode_number(155), b("\x81\x9b"))
+ # self.assertEqual(der.encode_number(155), b"\x81\x9b")
 for n in (0, 1, 2, 127, 128, 3 * 128 + 7, 840, 10045): # , 155):
- x = der.encode_number(n) + b("more")
+ x = der.encode_number(n) + b"more"
 n1, llen = der.read_number(x)
 self.assertEqual(n1, n)
- self.assertEqual(x[llen:], b("more"))
+ self.assertEqual(x[llen:], b"more")
 
 def test_length(self):
- self.assertEqual(der.encode_length(0), b("\x00"))
- self.assertEqual(der.encode_length(127), b("\x7f"))
- self.assertEqual(der.encode_length(128), b("\x81\x80"))
- self.assertEqual(der.encode_length(255), b("\x81\xff"))
- self.assertEqual(der.encode_length(256), b("\x82\x01\x00"))
- self.assertEqual(der.encode_length(3 * 256 + 7), b("\x82\x03\x07"))
- self.assertEqual(der.read_length(b("\x81\x9b") + b("more")), (155, 2))
- self.assertEqual(der.encode_length(155), b("\x81\x9b"))
+ self.assertEqual(der.encode_length(0), b"\x00")
+ self.assertEqual(der.encode_length(127), b"\x7f")
+ self.assertEqual(der.encode_length(128), b"\x81\x80")
+ self.assertEqual(der.encode_length(255), b"\x81\xff")
+ self.assertEqual(der.encode_length(256), b"\x82\x01\x00")
+ self.assertEqual(der.encode_length(3 * 256 + 7), b"\x82\x03\x07")
+ self.assertEqual(der.read_length(b"\x81\x9b" + b"more"), (155, 2))
+ self.assertEqual(der.encode_length(155), b"\x81\x9b")
 for n in (0, 1, 2, 127, 128, 255, 256, 3 * 256 + 7, 155):
- x = der.encode_length(n) + b("more")
+ x = der.encode_length(n) + b"more"
 n1, llen = der.read_length(x)
 self.assertEqual(n1, n)
- self.assertEqual(x[llen:], b("more"))
+ self.assertEqual(x[llen:], b"more")
 
 def test_sequence(self):
- x = der.encode_sequence(b("ABC"), b("DEF")) + b("GHI")
- self.assertEqual(x, b("\x30\x06ABCDEFGHI"))
+ x = der.encode_sequence(b"ABC", b"DEF") + b"GHI"
+ self.assertEqual(x, b"\x30\x06ABCDEFGHI")
 x1, rest = der.remove_sequence(x)
- self.assertEqual(x1, b("ABCDEF"))
- self.assertEqual(rest, b("GHI"))
+ self.assertEqual(x1, b"ABCDEF")
+ self.assertEqual(rest, b"GHI")
 
 def test_constructed(self):
 x = der.encode_constructed(0, NIST224p.encoded_oid)
- self.assertEqual(hexlify(x), b("a007") + b("06052b81040021"))
- x = der.encode_constructed(1, unhexlify(b("0102030a0b0c")))
- self.assertEqual(hexlify(x), b("a106") + b("0102030a0b0c"))
+ self.assertEqual(hexlify(x), b"a007" + b"06052b81040021")
+ x = der.encode_constructed(1, unhexlify(b"0102030a0b0c"))
+ self.assertEqual(hexlify(x), b"a106" + b"0102030a0b0c")
 
 
 class Util(unittest.TestCase):
+ @pytest.mark.slow
 def test_trytryagain(self):
 tta = util.randrange_from_seed__trytryagain
 for i in range(1000):
@@ -1599,7 +1851,7 @@ class Util(unittest.TestCase):
 # this trytryagain *does* provide long-term stability
 self.assertEqual(
 ("%x" % (tta("seed", NIST224p.order))).encode(),
- b("6fa59d73bf0446ae8743cf748fc5ac11d5585a90356417e97155c3bc"),
+ b"6fa59d73bf0446ae8743cf748fc5ac11d5585a90356417e97155c3bc",
 )
 
 def test_trytryagain_single(self):
@@ -1610,9 +1862,10 @@ class Util(unittest.TestCase):
 # known issue: https://github.com/warner/python-ecdsa/issues/221
 if sys.version_info < (3, 0): # pragma: no branch
 self.assertEqual(n, 228)
- else:
+ else: # pragma: no branch
 self.assertEqual(n, 18)
 
+ @settings(**HYP_SETTINGS)
 @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
@@ -1656,8 +1909,8 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=SECP256k1.generator,
 secexp=int("9d0219792467d7d37b4d43298a7d0c05", 16),
- hsh=sha256(b("sample")).digest(),
- hash_func=sha256,
+ hsh=hashlib.sha256(b"sample").digest(),
+ hash_func=hashlib.sha256,
 expected=int(
 "8fa1f95d514760e498f28957b824ee6ec39ed64826ff4fecc2b5739ec45b91cd",
 16,
@@ -1671,8 +1924,8 @@ class RFC6979(unittest.TestCase):
 "cca9fbcc1b41e5a95d369eaa6ddcff73b61a4efaa279cfc6567e8daa39cbaf50",
 16,
 ),
- hsh=sha256(b("sample")).digest(),
- hash_func=sha256,
+ hsh=hashlib.sha256(b"sample").digest(),
+ hash_func=hashlib.sha256,
 expected=int(
 "2df40ca70e639d89528a6b670d9d48d9165fdc0febc0974056bdce192b8e16a3",
 16,
@@ -1683,8 +1936,8 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=SECP256k1.generator,
 secexp=0x1,
- hsh=sha256(b("Satoshi Nakamoto")).digest(),
- hash_func=sha256,
+ hsh=hashlib.sha256(b"Satoshi Nakamoto").digest(),
+ hash_func=hashlib.sha256,
 expected=0x8F8A276C19F4149656B280621E358CCE24F5F52542772691EE69063B74F15D15,
 )
 
@@ -1692,12 +1945,10 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=SECP256k1.generator,
 secexp=0x1,
- hsh=sha256(
- b(
- "All those moments will be lost in time, like tears in rain. Time to die..."
- )
+ hsh=hashlib.sha256(
+ b"All those moments will be lost in time, like tears in rain. Time to die..."
 ).digest(),
- hash_func=sha256,
+ hash_func=hashlib.sha256,
 expected=0x38AA22D72376B4DBC472E06C3BA403EE0A394DA63FC58D88686C611ABA98D6B3,
 )
 
@@ -1705,8 +1956,8 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=SECP256k1.generator,
 secexp=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140,
- hsh=sha256(b("Satoshi Nakamoto")).digest(),
- hash_func=sha256,
+ hsh=hashlib.sha256(b"Satoshi Nakamoto").digest(),
+ hash_func=hashlib.sha256,
 expected=0x33A19B60E25FB6F4435AF53A3D42D493644827367E6453928554F43E49AA6F90,
 )
 
@@ -1714,8 +1965,8 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=SECP256k1.generator,
 secexp=0xF8B8AF8CE3C7CCA5E300D33939540C10D45CE001B8F252BFBC57BA0342904181,
- hsh=sha256(b("Alan Turing")).digest(),
- hash_func=sha256,
+ hsh=hashlib.sha256(b"Alan Turing").digest(),
+ hash_func=hashlib.sha256,
 expected=0x525A82B70E67874398067543FD84C83D30C175FDC45FDEEE082FE13B1D7CFDF1,
 )
 
@@ -1734,7 +1985,7 @@ class RFC6979(unittest.TestCase):
 "AF2BDBE1AA9B6EC1E2ADE1D694F41FC71A831D0268E9891562113D8A62ADD1BF"
 )
 ),
- hash_func=sha256,
+ hash_func=hashlib.sha256,
 expected=int("23AF4074C90A02B3FE61D286D5C87F425E6BDD81B", 16),
 )
 
@@ -1742,8 +1993,8 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=NIST192p.generator,
 secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
- hsh=sha1(b("sample")).digest(),
- hash_func=sha1,
+ hsh=hashlib.sha1(b"sample").digest(),
+ hash_func=hashlib.sha1,
 expected=int(
 "37D7CA00D2C7B0E5E412AC03BD44BA837FDD5B28CD3B0021", 16
 ),
@@ -1753,8 +2004,8 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=NIST192p.generator,
 secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
- hsh=sha256(b("sample")).digest(),
- hash_func=sha256,
+ hsh=hashlib.sha256(b"sample").digest(),
+ hash_func=hashlib.sha256,
 expected=int(
 "32B1B6D7D42A05CB449065727A84804FB1A3E34D8F261496", 16
 ),
@@ -1764,8 +2015,8 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=NIST192p.generator,
 secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
- hsh=sha512(b("sample")).digest(),
- hash_func=sha512,
+ hsh=hashlib.sha512(b"sample").digest(),
+ hash_func=hashlib.sha512,
 expected=int(
 "A2AC7AB055E4F20692D49209544C203A7D1F2C0BFBC75DB1", 16
 ),
@@ -1775,8 +2026,8 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=NIST192p.generator,
 secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
- hsh=sha1(b("test")).digest(),
- hash_func=sha1,
+ hsh=hashlib.sha1(b"test").digest(),
+ hash_func=hashlib.sha1,
 expected=int(
 "D9CF9C3D3297D3260773A1DA7418DB5537AB8DD93DE7FA25", 16
 ),
@@ -1786,8 +2037,8 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=NIST192p.generator,
 secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
- hsh=sha256(b("test")).digest(),
- hash_func=sha256,
+ hsh=hashlib.sha256(b"test").digest(),
+ hash_func=hashlib.sha256,
 expected=int(
 "5C4CE89CF56D9E7C77C8585339B006B97B5F0680B4306C6C", 16
 ),
@@ -1797,8 +2048,8 @@ class RFC6979(unittest.TestCase):
 self._do(
 generator=NIST192p.generator,
 secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
- hsh=sha512(b("test")).digest(),
- hash_func=sha512,
+ hsh=hashlib.sha512(b"test").digest(),
+ hash_func=hashlib.sha512,
 expected=int(
 "0758753A5254759C7CFBAD2E2D9B0792EEE44136C9480527", 16
 ),
@@ -1811,8 +2062,8 @@ class RFC6979(unittest.TestCase):
 "0FAD06DAA62BA3B25D2FB40133DA757205DE67F5BB0018FEE8C86E1B68C7E75CAA896EB32F1F47C70855836A6D16FCC1466F6D8FBEC67DB89EC0C08B0E996B83538",
 16,
 ),
- hsh=sha1(b("sample")).digest(),
- hash_func=sha1,
+ hsh=hashlib.sha1(b"sample").digest(),
+ hash_func=hashlib.sha1,
 expected=int(
 "089C071B419E1C2820962321787258469511958E80582E95D8378E0C2CCDB3CB42BEDE42F50E3FA3C71F5A76724281D31D9C89F0F91FC1BE4918DB1C03A5838D0F9",
 16,
@@ -1826,8 +2077,8 @@ class RFC6979(unittest.TestCase):
 "0FAD06DAA62BA3B25D2FB40133DA757205DE67F5BB0018FEE8C86E1B68C7E75CAA896EB32F1F47C70855836A6D16FCC1466F6D8FBEC67DB89EC0C08B0E996B83538",
 16,
 ),
- hsh=sha256(b("sample")).digest(),
- hash_func=sha256,
+ hsh=hashlib.sha256(b"sample").digest(),
+ hash_func=hashlib.sha256,
 expected=int(
 "0EDF38AFCAAECAB4383358B34D67C9F2216C8382AAEA44A3DAD5FDC9C32575761793FEF24EB0FC276DFC4F6E3EC476752F043CF01415387470BCBD8678ED2C7E1A0",
 16,
@@ -1841,8 +2092,8 @@ class RFC6979(unittest.TestCase):
 "0FAD06DAA62BA3B25D2FB40133DA757205DE67F5BB0018FEE8C86E1B68C7E75CAA896EB32F1F47C70855836A6D16FCC1466F6D8FBEC67DB89EC0C08B0E996B83538",
 16,
 ),
- hsh=sha512(b("test")).digest(),
- hash_func=sha512,
+ hsh=hashlib.sha512(b"test").digest(),
+ hash_func=hashlib.sha512,
 expected=int(
 "16200813020EC986863BEDFC1B121F605C1215645018AEA1A7B215A564DE9EB1B38A67AA1128B80CE391C4FB71187654AAA3431027BFC7F395766CA988C964DC56D",
 16,
@@ -1945,6 +2196,7 @@ class RFC6932(ECDH):
 ),
 )
 
+ @pytest.mark.slow
 def test_brainpoolP384r1(self):
 self._do(
 curve=curve_brainpoolp384r1,
@@ -1991,6 +2243,7 @@ class RFC6932(ECDH):
 ),
 )
 
+ @pytest.mark.slow
 def test_brainpoolP512r1(self):
 self._do(
 curve=curve_brainpoolp512r1,
@@ -2095,6 +2348,7 @@ class RFC7027(ECDH):
 ),
 )
 
+ @pytest.mark.slow
 def test_brainpoolP384r1(self):
 self._do(
 curve=curve_brainpoolp384r1,
@@ -2141,6 +2395,7 @@ class RFC7027(ECDH):
 ),
 )
 
+ @pytest.mark.slow
 def test_brainpoolP512r1(self):
 self._do(
 curve=curve_brainpoolp512r1,
@@ -2206,7 +2461,7 @@ class RFC7027(ECDH):
 "6FC98BD7E50211A4A27102FA3549DF79EBCB4BF246B80945CDDFE7D509BBFD7D",
 "9E56F509196784D963D1C0A401510EE7ADA3DCC5DEE04B154BF61AF1D5A6DECE",
 b"abc",
- sha256,
+ hashlib.sha256,
 "CB28E0999B9C7715FD0A80D8E47A77079716CBBF917DD72E97566EA1C066957C",
 "86FA3BB4E26CAD5BF90B7F81899256CE7594BB1EA0C89212748BFF3B3D5B0315",
 NIST256p,
@@ -2222,7 +2477,7 @@ class RFC7027(ECDH):
 "B4B74E44D71A13D568003D7489908D564C7761E229C58CBFA18950096EB7463B"
 "854D7FA992F934D927376285E63414FA",
 b"abc",
- sha384,
+ hashlib.sha384,
 "FB017B914E29149432D8BAC29A514640B46F53DDAB2C69948084E2930F1C8F7E"
 "08E07C9C63F2D21A07DCB56A6AF56EB3",
 "B263A1305E057F984D38726A1B46874109F417BCA112674C528262A40A629AF1"
@@ -2244,7 +2499,7 @@ class RFC7027(ECDH):
 "373778F9DE6B6497B1EF825FF24F42F9B4A4BD7382CFC3378A540B1B7F0C1B95"
 "6C2F",
 b"abc",
- sha512,
+ hashlib.sha512,
 "0154FD3836AF92D0DCA57DD5341D3053988534FDE8318FC6AAAAB68E2E6F4339"
 "B19F2F281A7E0B22C269D93CF8794A9278880ED7DBB8D9362CAEACEE54432055"
 "2251",
diff --git a/frozen_deps/ecdsa/test_sha3.py b/frozen_deps/ecdsa/test_sha3.py
index 2c6bd15..d30381d 100644
--- a/frozen_deps/ecdsa/test_sha3.py
+++ b/frozen_deps/ecdsa/test_sha3.py
@@ -8,7 +8,7 @@ try:
 from gmpy2 import mpz
 
 GMPY = True
-except ImportError:
+except ImportError: # pragma: no cover
 try:
 from gmpy import mpz
 
@@ -43,7 +43,7 @@ class TestBytesToInt(unittest.TestCase):
 int_to_bytes(0, byteorder="middle")
 
 
-[email protected](GMPY == False, reason="requites gmpy or gmpy2")
+[email protected](GMPY == False, reason="requires gmpy or gmpy2")
 def test_int_to_bytes_with_gmpy():
 assert int_to_bytes(mpz(1)) == b"\x01"
 
diff --git a/frozen_deps/ecdsa/util.py b/frozen_deps/ecdsa/util.py
index 9a56110..639bc0c 100644
--- a/frozen_deps/ecdsa/util.py
+++ b/frozen_deps/ecdsa/util.py
@@ -1,3 +1,16 @@
+"""
+This module includes some utility functions.
+
+The methods most typically used are the sigencode and sigdecode functions
+to be used with :func:`~ecdsa.keys.SigningKey.sign` and
+:func:`~ecdsa.keys.VerifyingKey.verify`
+respectively. See the :func:`sigencode_strings`, :func:`sigdecode_string`,
+:func:`sigencode_der`, :func:`sigencode_strings_canonize`,
+:func:`sigencode_string_canonize`, :func:`sigencode_der_canonize`,
+:func:`sigdecode_strings`, :func:`sigdecode_string`, and
+:func:`sigdecode_der` functions.
+"""
+
 from __future__ import division
 
 import os
@@ -5,10 +18,11 @@ import math
 import binascii
 import sys
 from hashlib import sha256
-from six import PY2, int2byte, b, next
+from six import PY2, int2byte, next
 from . import der
 from ._compat import normalise_bytes
 
+
 # RFC5480:
 # The "unrestricted" algorithm identifier is:
 # id-ecPublicKey OBJECT IDENTIFIER ::= {
@@ -188,7 +202,7 @@ def randrange_from_seed__trytryagain(seed, order):
 bits, bytes, extrabits = bits_and_bytes(order)
 generate = PRNG(seed)
 while True:
- extrabyte = b("")
+ extrabyte = b""
 if extrabits:
 extrabyte = int2byte(ord(generate(1)) & lsb_of_ones(extrabits))
 guess = string_to_number(extrabyte + generate(bytes)) + 1
@@ -221,12 +235,24 @@ def string_to_number_fixedlen(string, order):
 return int(binascii.hexlify(string), 16)
 
 
-# these methods are useful for the sigencode= argument to SK.sign() and the
-# sigdecode= argument to VK.verify(), and control how the signature is packed
-# or unpacked.
+def sigencode_strings(r, s, order):
+ """
+ Encode the signature to a pair of strings in a tuple
+
+ Encodes signature into raw encoding (:term:`raw encoding`) with the
+ ``r`` and ``s`` parts of the signature encoded separately.
 
+ It's expected that this function will be used as a ``sigencode=`` parameter
+ in :func:`ecdsa.keys.SigningKey.sign` method.
 
-def sigencode_strings(r, s, order):
+ :param int r: first parameter of the signature
+ :param int s: second parameter of the signature
+ :param int order: the order of the curve over which the signature was
+ computed
+
+ :return: raw encoding of ECDSA signature
+ :rtype: tuple(bytes, bytes)
+ """
 r_str = number_to_string(r, order)
 s_str = number_to_string(s, order)
 return (r_str, s_str)
@@ -236,7 +262,7 @@ def sigencode_string(r, s, order):
 """
 Encode the signature to raw format (:term:`raw encoding`)
 
- It's expected that this function will be used as a `sigencode=` parameter
+ It's expected that this function will be used as a ``sigencode=`` parameter
 in :func:`ecdsa.keys.SigningKey.sign` method.
 
 :param int r: first parameter of the signature
@@ -264,7 +290,7 @@ def sigencode_der(r, s, order):
 s INTEGER
 }
 
- It's expected that this function will be used as a `sigencode=` parameter
+ It's expected that this function will be used as a ``sigencode=`` parameter
 in :func:`ecdsa.keys.SigningKey.sign` method.
 
 :param int r: first parameter of the signature
@@ -278,23 +304,83 @@ def sigencode_der(r, s, order):
 return der.encode_sequence(der.encode_integer(r), der.encode_integer(s))
 
 
-# canonical versions of sigencode methods
-# these enforce low S values, by negating the value (modulo the order) if
-# above order/2 see CECKey::Sign()
-# https://github.com/bitcoin/bitcoin/blob/master/src/key.cpp#L214
 def sigencode_strings_canonize(r, s, order):
+ """
+ Encode the signature to a pair of strings in a tuple
+
+ Encodes signature into raw encoding (:term:`raw encoding`) with the
+ ``r`` and ``s`` parts of the signature encoded separately.
+
+ Makes sure that the signature is encoded in the canonical format, where
+ the ``s`` parameter is always smaller than ``order / 2``.
+ Most commonly used in bitcoin.
+
+ It's expected that this function will be used as a ``sigencode=`` parameter
+ in :func:`ecdsa.keys.SigningKey.sign` method.
+
+ :param int r: first parameter of the signature
+ :param int s: second parameter of the signature
+ :param int order: the order of the curve over which the signature was
+ computed
+
+ :return: raw encoding of ECDSA signature
+ :rtype: tuple(bytes, bytes)
+ """
 if s > order / 2:
 s = order - s
 return sigencode_strings(r, s, order)
 
 
 def sigencode_string_canonize(r, s, order):
+ """
+ Encode the signature to raw format (:term:`raw encoding`)
+
+ Makes sure that the signature is encoded in the canonical format, where
+ the ``s`` parameter is always smaller than ``order / 2``.
+ Most commonly used in bitcoin.
+
+ It's expected that this function will be used as a ``sigencode=`` parameter
+ in :func:`ecdsa.keys.SigningKey.sign` method.
+
+ :param int r: first parameter of the signature
+ :param int s: second parameter of the signature
+ :param int order: the order of the curve over which the signature was
+ computed
+
+ :return: raw encoding of ECDSA signature
+ :rtype: bytes
+ """
 if s > order / 2:
 s = order - s
 return sigencode_string(r, s, order)
 
 
 def sigencode_der_canonize(r, s, order):
+ """
+ Encode the signature into the ECDSA-Sig-Value structure using :term:`DER`.
+
+ Makes sure that the signature is encoded in the canonical format, where
+ the ``s`` parameter is always smaller than ``order / 2``.
+ Most commonly used in bitcoin.
+
+ Encodes the signature to the following :term:`ASN.1` structure::
+
+ Ecdsa-Sig-Value ::= SEQUENCE {
+ r INTEGER,
+ s INTEGER
+ }
+
+ It's expected that this function will be used as a ``sigencode=`` parameter
+ in :func:`ecdsa.keys.SigningKey.sign` method.
+
+ :param int r: first parameter of the signature
+ :param int s: second parameter of the signature
+ :param int order: the order of the curve over which the signature was
+ computed
+
+ :return: DER encoding of ECDSA signature
+ :rtype: bytes
+ """
 if s > order / 2:
 s = order - s
 return sigencode_der(r, s, order)
@@ -321,7 +407,7 @@ def sigdecode_string(signature, order):
 the signature, with each encoded using the same amount of bytes depending
 on curve size/order.
 
- It's expected that this function will be used as the `sigdecode=`
+ It's expected that this function will be used as the ``sigdecode=``
 parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method.
 
 :param signature: encoded signature
@@ -331,7 +417,7 @@ def sigdecode_string(signature, order):
 
 :raises MalformedSignature: when the encoding of the signature is invalid
 
- :return: tuple with decoded 'r' and 's' values of signature
+ :return: tuple with decoded ``r`` and ``s`` values of signature
 :rtype: tuple of ints
 """
 signature = normalise_bytes(signature)
@@ -350,10 +436,10 @@ def sigdecode_strings(rs_strings, order):
 """
 Decode the signature from two strings.
 
- First string needs to be a big endian encoding of 'r', second needs to
- be a big endian encoding of the 's' parameter of an ECDSA signature.
+ First string needs to be a big endian encoding of ``r``, second needs to
+ be a big endian encoding of the ``s`` parameter of an ECDSA signature.
 
- It's expected that this function will be used as the `sigdecode=`
+ It's expected that this function will be used as the ``sigdecode=``
 parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method.
 
 :param list rs_strings: list of two bytes-like objects, each encoding one
@@ -362,7 +448,7 @@ def sigdecode_strings(rs_strings, order):
 
 :raises MalformedSignature: when the encoding of the signature is invalid
 
- :return: tuple with decoded 'r' and 's' values of signature
+ :return: tuple with decoded ``r`` and ``s`` values of signature
 :rtype: tuple of ints
 """
 if not len(rs_strings) == 2:
@@ -404,7 +490,7 @@ def sigdecode_der(sig_der, order):
 s INTEGER
 }
 
- It's expected that this function will be used as as the `sigdecode=`
+ It's expected that this function will be used as as the ``sigdecode=``
 parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method.
 
 :param sig_der: encoded signature
@@ -414,7 +500,7 @@ def sigdecode_der(sig_der, order):
 
 :raises UnexpectedDER: when the encoding of signature is invalid
 
- :return: tuple with decoded 'r' and 's' values of signature
+ :return: tuple with decoded ``r`` and ``s`` values of signature
 :rtype: tuple of ints
 """
 sig_der = normalise_bytes(sig_der)