aboutsummaryrefslogtreecommitdiff
path: root/frozen_deps/ecdsa
diff options
context:
space:
mode:
authorDeterminant <[email protected]>2024-08-23 03:14:03 +0000
committerDeterminant <[email protected]>2024-08-22 20:34:57 -0700
commit8d1c76ec7caf247d5675e14260d20fc508977ffb (patch)
tree8fa7c8ce3b7e3f4ece150a6da5922b5eb2dc7772 /frozen_deps/ecdsa
parent258780284151d49cba1d9c0d2ce33f9a19bb058b (diff)
release v0.1.8
Diffstat (limited to 'frozen_deps/ecdsa')
-rw-r--r--frozen_deps/ecdsa/__init__.py14
-rw-r--r--frozen_deps/ecdsa/_compat.py27
-rw-r--r--frozen_deps/ecdsa/_version.py6
-rw-r--r--frozen_deps/ecdsa/curves.py77
-rw-r--r--frozen_deps/ecdsa/der.py32
-rw-r--r--frozen_deps/ecdsa/ecdsa.py247
-rw-r--r--frozen_deps/ecdsa/ellipticcurve.py28
-rw-r--r--frozen_deps/ecdsa/keys.py41
-rw-r--r--frozen_deps/ecdsa/numbertheory.py30
-rw-r--r--frozen_deps/ecdsa/ssh.py83
-rw-r--r--frozen_deps/ecdsa/test_der.py80
-rw-r--r--frozen_deps/ecdsa/test_ecdh.py8
-rw-r--r--frozen_deps/ecdsa/test_ecdsa.py45
-rw-r--r--frozen_deps/ecdsa/test_eddsa.py47
-rw-r--r--frozen_deps/ecdsa/test_ellipticcurve.py63
-rw-r--r--frozen_deps/ecdsa/test_jacobi.py140
-rw-r--r--frozen_deps/ecdsa/test_keys.py207
-rw-r--r--frozen_deps/ecdsa/test_malformed_sigs.py46
-rw-r--r--frozen_deps/ecdsa/test_numbertheory.py64
-rw-r--r--frozen_deps/ecdsa/test_pyecdsa.py607
-rw-r--r--frozen_deps/ecdsa/test_sha3.py4
-rw-r--r--frozen_deps/ecdsa/util.py126
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)
Powered by cgit, Themed by Ted Yin.