ccxt-ir 4.3.46.0.1__py2.py3-none-any.whl

ccxt/static_dependencies/ecdsa/der.py

@@ -0,0 +1,221 @@
+from __future__ import division
+
+import binascii
+import base64
+
+
+class UnexpectedDER(Exception):
+    pass
+
+
+def encode_constructed(tag, value):
+    return int.to_bytes(0xa0+tag, 1, 'big') + encode_length(len(value)) + value
+
+
+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
+    s = binascii.unhexlify(h)
+    num = s[0] if isinstance(s[0], int) else ord(s[0])
+    if num <= 0x7f:
+        return b'\x02' + int.to_bytes(len(s), 1, 'big') + 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' + int.to_bytes(len(s)+1, 1, 'big') + b'\x00' + s
+
+
+def encode_bitstring(s):
+    return b'\x03' + encode_length(len(s)) + s
+
+
+def encode_octet_string(s):
+    return b'\x04' + encode_length(len(s)) + s
+
+
+def encode_oid(first, second, *pieces):
+    assert first <= 2
+    assert second <= 39
+    encoded_pieces = [int.to_bytes(40*first+second, 1, 'big')] + [encode_number(p)
+                                                    for p in pieces]
+    body = b''.join(encoded_pieces)
+    return b'\x06' + encode_length(len(body)) + body
+
+
+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)
+
+
+def encode_number(n):
+    b128_digits = []
+    while n:
+        b128_digits.insert(0, (n & 0x7f) | 0x80)
+        n = n >> 7
+    if not b128_digits:
+        b128_digits.append(0)
+    b128_digits[-1] &= 0x7f
+    return b''.join([int.to_bytes(d, 1, 'big') for d in b128_digits])
+
+
+def remove_constructed(string):
+    s0 = string[0] if isinstance(string[0], int) else ord(string[0])
+    if (s0 & 0xe0) != 0xa0:
+        raise UnexpectedDER("wanted constructed tag (0xa0-0xbf), got 0x%02x"
+                            % s0)
+    tag = s0 & 0x1f
+    length, llen = read_length(string[1:])
+    body = string[1+llen:1+llen+length]
+    rest = string[1+llen+length:]
+    return tag, body, rest
+
+
+def remove_sequence(string):
+    if not string.startswith(b'\x30'):
+        n = string[0] if isinstance(string[0], int) else ord(string[0])
+        raise UnexpectedDER("wanted sequence (0x30), got 0x%02x" % n)
+    length, lengthlength = read_length(string[1:])
+    endseq = 1+lengthlength+length
+    return string[1+lengthlength:endseq], string[endseq:]
+
+
+def remove_octet_string(string):
+    if not string.startswith(b'\x04'):
+        n = string[0] if isinstance(string[0], int) else ord(string[0])
+        raise UnexpectedDER("wanted octetstring (0x04), got 0x%02x" % n)
+    length, llen = read_length(string[1:])
+    body = string[1+llen:1+llen+length]
+    rest = string[1+llen+length:]
+    return body, rest
+
+
+def remove_object(string):
+    if not string.startswith(b'\x06'):
+        n = string[0] if isinstance(string[0], int) else ord(string[0])
+        raise UnexpectedDER("wanted object (0x06), got 0x%02x" % n)
+    length, lengthlength = read_length(string[1:])
+    body = string[1+lengthlength:1+lengthlength+length]
+    rest = string[1+lengthlength+length:]
+    numbers = []
+    while body:
+        n, ll = read_number(body)
+        numbers.append(n)
+        body = body[ll:]
+    n0 = numbers.pop(0)
+    first = n0//40
+    second = n0-(40*first)
+    numbers.insert(0, first)
+    numbers.insert(1, second)
+    return tuple(numbers), rest
+
+
+def remove_integer(string):
+    if not string.startswith(b'\x02'):
+        n = string[0] if isinstance(string[0], int) else ord(string[0])
+        raise UnexpectedDER("wanted integer (0x02), got 0x%02x" % n)
+    length, llen = read_length(string[1:])
+    numberbytes = string[1+llen:1+llen+length]
+    rest = string[1+llen+length:]
+    nbytes = numberbytes[0] if isinstance(numberbytes[0], int) else ord(numberbytes[0])
+    assert nbytes < 0x80  # can't support negative numbers yet
+    return int(binascii.hexlify(numberbytes), 16), rest
+
+
+def read_number(string):
+    number = 0
+    llen = 0
+    # base-128 big endian, with b7 set in all but the last byte
+    while True:
+        if llen > len(string):
+            raise UnexpectedDER("ran out of length bytes")
+        number = number << 7
+        d = string[llen] if isinstance(string[llen], int) else ord(string[llen])
+        number += (d & 0x7f)
+        llen += 1
+        if not d & 0x80:
+            break
+    return number, llen
+
+
+def encode_length(l):
+    assert l >= 0
+    if l < 0x80:
+        return int.to_bytes(l, 1, 'big')
+    s = ("%x" % l).encode()
+    if len(s) % 2:
+        s = b'0' + s
+    s = binascii.unhexlify(s)
+    llen = len(s)
+    return int.to_bytes(0x80 | llen, 1, 'big') + s
+
+
+def read_length(string):
+    num = string[0] if isinstance(string[0], int) else ord(string[0])
+    if not (num & 0x80):
+        # short form
+        return (num & 0x7f), 1
+    # else long-form: b0&0x7f is number of additional base256 length bytes,
+    # big-endian
+    llen = num & 0x7f
+    if llen > len(string)-1:
+        raise UnexpectedDER("ran out of length bytes")
+    return int(binascii.hexlify(string[1:1+llen]), 16), 1+llen
+
+
+def remove_bitstring(string):
+    num = string[0] if isinstance(string[0], int) else ord(string[0])
+    if not string.startswith(b'\x03'):
+        raise UnexpectedDER("wanted bitstring (0x03), got 0x%02x" % num)
+    length, llen = read_length(string[1:])
+    body = string[1+llen:1+llen+length]
+    rest = string[1+llen+length:]
+    return body, rest
+
+# SEQUENCE([1, STRING(secexp), cont[0], OBJECT(curvename), cont[1], BINTSTRING)
+
+
+# signatures: (from RFC3279)
+#  ansi-X9-62  OBJECT IDENTIFIER ::= {
+#       iso(1) member-body(2) us(840) 10045 }
+#
+#  id-ecSigType OBJECT IDENTIFIER  ::=  {
+#       ansi-X9-62 signatures(4) }
+#  ecdsa-with-SHA1  OBJECT IDENTIFIER ::= {
+#       id-ecSigType 1 }
+## so 1,2,840,10045,4,1
+## so 0x42, .. ..
+
+#  Ecdsa-Sig-Value  ::=  SEQUENCE  {
+#       r     INTEGER,
+#       s     INTEGER  }
+
+# id-public-key-type OBJECT IDENTIFIER  ::= { ansi-X9.62 2 }
+#
+# id-ecPublicKey OBJECT IDENTIFIER ::= { id-publicKeyType 1 }
+
+# I think the secp224r1 identifier is (t=06,l=05,v=2b81040021)
+#  secp224r1 OBJECT IDENTIFIER ::= {
+#  iso(1) identified-organization(3) certicom(132) curve(0) 33 }
+# and the secp384r1 is (t=06,l=05,v=2b81040022)
+#  secp384r1 OBJECT IDENTIFIER ::= {
+#  iso(1) identified-organization(3) certicom(132) curve(0) 34 }
+
+def unpem(pem):
+    if isinstance(pem, str):
+        pem = pem.encode()
+
+    d = b''.join([l.strip() 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)
+    lines = [("-----BEGIN %s-----\n" % name).encode()]
+    lines.extend([b64[start:start+64]+b'\n'
+                  for start in range(0, len(b64), 64)])
+    lines.append(("-----END %s-----\n" % name).encode())
+    return b''.join(lines)

ccxt/static_dependencies/ecdsa/ecdsa.py

@@ -0,0 +1,310 @@
+#! /usr/bin/env python
+
+"""
+Implementation of Elliptic-Curve Digital Signatures.
+
+Classes and methods for elliptic-curve signatures:
+private keys, public keys, signatures,
+NIST prime-modulus curves with modulus lengths of
+192, 224, 256, 384, and 521 bits.
+
+Example:
+
+  # (In real-life applications, you would probably want to
+  # protect against defects in SystemRandom.)
+  from random import SystemRandom
+  randrange = SystemRandom().randrange
+
+  # Generate a public/private key pair using the NIST Curve P-192:
+
+  g = generator_192
+  n = g.order()
+  secret = randrange( 1, n )
+  pubkey = Public_key( g, g * secret )
+  privkey = Private_key( pubkey, secret )
+
+  # Signing a hash value:
+
+  hash = randrange( 1, n )
+  signature = privkey.sign( hash, randrange( 1, n ) )
+
+  # Verifying a signature for a hash value:
+
+  if pubkey.verifies( hash, signature ):
+    print_("Demo verification succeeded.")
+  else:
+    print_("*** Demo verification failed.")
+
+  # Verification fails if the hash value is modified:
+
+  if pubkey.verifies( hash-1, signature ):
+    print_("**** Demo verification failed to reject tampered hash.")
+  else:
+    print_("Demo verification correctly rejected tampered hash.")
+
+Version of 2009.05.16.
+
+Revision history:
+      2005.12.31 - Initial version.
+      2008.11.25 - Substantial revisions introducing new classes.
+      2009.05.16 - Warn against using random.randrange in real applications.
+      2009.05.17 - Use random.SystemRandom by default.
+
+Written in 2005 by Peter Pearson and placed in the public domain.
+"""
+
+from . import ellipticcurve
+from . import numbertheory
+
+
+class RSZeroError(RuntimeError):
+    pass
+
+
+class Signature(object):
+    """ECDSA signature.
+  """
+
+    def __init__(self, r, s, recovery_param):
+        self.r = r
+        self.s = s
+        self.recovery_param = recovery_param
+
+    def recover_public_keys(self, hash, generator):
+        """Returns two public keys for which the signature is valid
+    hash is signed hash
+    generator is the used generator of the signature
+    """
+        curve = generator.curve()
+        n = generator.order()
+        r = self.r
+        s = self.s
+        e = hash
+        x = r
+
+        # Compute the curve point with x as x-coordinate
+        alpha = (pow(x, 3, curve.p()) + (curve.a() * x) + curve.b()) % curve.p()
+        beta = numbertheory.square_root_mod_prime(alpha, curve.p())
+        y = beta if beta % 2 == 0 else curve.p() - beta
+
+        # Compute the public key
+        R1 = ellipticcurve.Point(curve, x, y, n)
+        Q1 = numbertheory.inverse_mod(r, n) * (s * R1 + (-e % n) * generator)
+        Pk1 = Public_key(generator, Q1)
+
+        # And the second solution
+        R2 = ellipticcurve.Point(curve, x, -y, n)
+        Q2 = numbertheory.inverse_mod(r, n) * (s * R2 + (-e % n) * generator)
+        Pk2 = Public_key(generator, Q2)
+
+        return [Pk1, Pk2]
+
+
+class Public_key(object):
+    """Public key for ECDSA.
+  """
+
+    def __init__(self, generator, point):
+        """generator is the Point that generates the group,
+    point is the Point that defines the public key.
+    """
+
+        self.curve = generator.curve()
+        self.generator = generator
+        self.point = point
+        n = generator.order()
+        if not n:
+            raise RuntimeError("Generator point must have order.")
+        if not n * point == ellipticcurve.INFINITY:
+            raise RuntimeError("Generator point order is bad.")
+        if point.x() < 0 or n <= point.x() or point.y() < 0 or n <= point.y():
+            raise RuntimeError("Generator point has x or y out of range.")
+
+    def verifies(self, hash, signature):
+        """Verify that signature is a valid signature of hash.
+    Return True if the signature is valid.
+    """
+
+        # From X9.62 J.3.1.
+
+        G = self.generator
+        n = G.order()
+        r = signature.r
+        s = signature.s
+        if r < 1 or r > n - 1:
+            return False
+        if s < 1 or s > n - 1:
+            return False
+        c = numbertheory.inverse_mod(s, n)
+        u1 = (hash * c) % n
+        u2 = (r * c) % n
+        xy = u1 * G + u2 * self.point
+        v = xy.x() % n
+        return v == r
+
+
+class Private_key(object):
+    """Private key for ECDSA.
+  """
+
+    def __init__(self, public_key, secret_multiplier):
+        """public_key is of class Public_key;
+    secret_multiplier is a large integer.
+    """
+
+        self.public_key = public_key
+        self.secret_multiplier = secret_multiplier
+
+    def sign(self, hash, random_k):
+        """Return a signature for the provided hash, using the provided
+    random nonce.  It is absolutely vital that random_k be an unpredictable
+    number in the range [1, self.public_key.point.order()-1].  If
+    an attacker can guess random_k, he can compute our private key from a
+    single signature.  Also, if an attacker knows a few high-order
+    bits (or a few low-order bits) of random_k, he can compute our private
+    key from many signatures.  The generation of nonces with adequate
+    cryptographic strength is very difficult and far beyond the scope
+    of this comment.
+
+    May raise RuntimeError, in which case retrying with a new
+    random value k is in order.
+    """
+
+        G = self.public_key.generator
+        n = G.order()
+        k = random_k % n
+        p1 = k * G
+        r = p1.x() % n
+        if r == 0:
+            raise RSZeroError("amazingly unlucky random number r")
+        s = (numbertheory.inverse_mod(k, n) *
+             (hash + (self.secret_multiplier * r) % n)) % n
+        if s == 0:
+            raise RSZeroError("amazingly unlucky random number s")
+        recovery_param = p1.y() % 2 or (2 if p1.x() == k else 0)
+        return Signature(r, s, recovery_param)
+
+
+def int_to_string(x):
+    """Convert integer x into a string of bytes, as per X9.62."""
+    assert x >= 0
+    if x == 0:
+        return b'\0'
+    result = []
+    while x:
+        ordinal = x & 0xFF
+        result.append(int.to_bytes(ordinal, 1, 'big'))
+        x >>= 8
+
+    result.reverse()
+    return b''.join(result)
+
+
+def string_to_int(s):
+    """Convert a string of bytes into an integer, as per X9.62."""
+    result = 0
+    for c in s:
+        if not isinstance(c, int):
+            c = ord(c)
+        result = 256 * result + c
+    return result
+
+
+def digest_integer(m):
+    """Convert an integer into a string of bytes, compute
+     its SHA-1 hash, and convert the result to an integer."""
+    #
+    # I don't expect this function to be used much. I wrote
+    # it in order to be able to duplicate the examples
+    # in ECDSAVS.
+    #
+    from hashlib import sha1
+    return string_to_int(sha1(int_to_string(m)).digest())
+
+
+def point_is_valid(generator, x, y):
+    """Is (x,y) a valid public key based on the specified generator?"""
+
+    # These are the tests specified in X9.62.
+
+    n = generator.order()
+    curve = generator.curve()
+    if x < 0 or n <= x or y < 0 or n <= y:
+        return False
+    if not curve.contains_point(x, y):
+        return False
+    if not n * ellipticcurve.Point(curve, x, y) == ellipticcurve.INFINITY:
+        return False
+    return True
+
+
+# NIST Curve P-192:
+_p = 6277101735386680763835789423207666416083908700390324961279
+_r = 6277101735386680763835789423176059013767194773182842284081
+# s = 0x3045ae6fc8422f64ed579528d38120eae12196d5L
+# c = 0x3099d2bbbfcb2538542dcd5fb078b6ef5f3d6fe2c745de65L
+_b = 0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1
+_Gx = 0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012
+_Gy = 0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811
+
+curve_192 = ellipticcurve.CurveFp(_p, -3, _b)
+generator_192 = ellipticcurve.Point(curve_192, _Gx, _Gy, _r)
+
+# NIST Curve P-224:
+_p = 26959946667150639794667015087019630673557916260026308143510066298881
+_r = 26959946667150639794667015087019625940457807714424391721682722368061
+# s = 0xbd71344799d5c7fcdc45b59fa3b9ab8f6a948bc5L
+# c = 0x5b056c7e11dd68f40469ee7f3c7a7d74f7d121116506d031218291fbL
+_b = 0xb4050a850c04b3abf54132565044b0b7d7bfd8ba270b39432355ffb4
+_Gx = 0xb70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21
+_Gy = 0xbd376388b5f723fb4c22dfe6cd4375a05a07476444d5819985007e34
+
+curve_224 = ellipticcurve.CurveFp(_p, -3, _b)
+generator_224 = ellipticcurve.Point(curve_224, _Gx, _Gy, _r)
+
+# NIST Curve P-256:
+_p = 115792089210356248762697446949407573530086143415290314195533631308867097853951
+_r = 115792089210356248762697446949407573529996955224135760342422259061068512044369
+# s = 0xc49d360886e704936a6678e1139d26b7819f7e90L
+# c = 0x7efba1662985be9403cb055c75d4f7e0ce8d84a9c5114abcaf3177680104fa0dL
+_b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b
+_Gx = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296
+_Gy = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5
+
+curve_256 = ellipticcurve.CurveFp(_p, -3, _b)
+generator_256 = ellipticcurve.Point(curve_256, _Gx, _Gy, _r)
+
+# NIST Curve P-384:
+_p = 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319
+_r = 39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643
+# s = 0xa335926aa319a27a1d00896a6773a4827acdac73L
+# c = 0x79d1e655f868f02fff48dcdee14151ddb80643c1406d0ca10dfe6fc52009540a495e8042ea5f744f6e184667cc722483L
+_b = 0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef
+_Gx = 0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7
+_Gy = 0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f
+
+curve_384 = ellipticcurve.CurveFp(_p, -3, _b)
+generator_384 = ellipticcurve.Point(curve_384, _Gx, _Gy, _r)
+
+# NIST Curve P-521:
+_p = 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151
+_r = 6864797660130609714981900799081393217269435300143305409394463459185543183397655394245057746333217197532963996371363321113864768612440380340372808892707005449
+# s = 0xd09e8800291cb85396cc6717393284aaa0da64baL
+# c = 0x0b48bfa5f420a34949539d2bdfc264eeeeb077688e44fbf0ad8f6d0edb37bd6b533281000518e19f1b9ffbe0fe9ed8a3c2200b8f875e523868c70c1e5bf55bad637L
+_b = 0x051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00
+_Gx = 0xc6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66
+_Gy = 0x11839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650
+
+curve_521 = ellipticcurve.CurveFp(_p, -3, _b)
+generator_521 = ellipticcurve.Point(curve_521, _Gx, _Gy, _r)
+
+# Certicom secp256-k1
+_a = 0x0000000000000000000000000000000000000000000000000000000000000000
+_b = 0x0000000000000000000000000000000000000000000000000000000000000007
+_p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
+_Gx = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
+_Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
+_r = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
+
+curve_secp256k1 = ellipticcurve.CurveFp(_p, _a, _b)
+generator_secp256k1 = ellipticcurve.Point(curve_secp256k1, _Gx, _Gy, _r)