hive-nectar 0.0.2__py3-none-any.whl

nectargraphenebase/ecdsasig.py

@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+import hashlib
+import logging
+import struct
+import time
+from binascii import hexlify
+
+import ecdsa
+
+from .account import PrivateKey, PublicKey
+from .py23 import bytes_types, py23_bytes
+
+log = logging.getLogger(__name__)
+
+SECP256K1_MODULE = None
+SECP256K1_AVAILABLE = False
+CRYPTOGRAPHY_AVAILABLE = False
+GMPY2_MODULE = False
+if not SECP256K1_MODULE:
+    try:
+        import secp256k1prp as secp256k1
+
+        SECP256K1_MODULE = "secp256k1"
+        SECP256K1_AVAILABLE = True
+    except:
+        try:
+            import secp256k1
+
+            SECP256K1_MODULE = "secp256k1"
+            SECP256K1_AVAILABLE = True
+        except ImportError:
+            try:
+                import cryptography
+
+                SECP256K1_MODULE = "cryptography"
+                CRYPTOGRAPHY_AVAILABLE = True
+            except ImportError:
+                SECP256K1_MODULE = "ecdsa"
+
+    try:
+        from cryptography.exceptions import InvalidSignature
+        from cryptography.hazmat.backends import default_backend
+        from cryptography.hazmat.primitives import hashes
+        from cryptography.hazmat.primitives.asymmetric import ec
+        from cryptography.hazmat.primitives.asymmetric.utils import (
+            decode_dss_signature,
+            encode_dss_signature,
+        )
+
+        CRYPTOGRAPHY_AVAILABLE = True
+    except ImportError:
+        CRYPTOGRAPHY_AVAILABLE = False
+        log.debug("Cryptography not available")
+
+log.debug("Using SECP256K1 module: %s" % SECP256K1_MODULE)
+
+
+def _is_canonical(sig):
+    sig = bytearray(sig)
+    return (
+        not (int(sig[0]) & 0x80)
+        and not (sig[0] == 0 and not (int(sig[1]) & 0x80))
+        and not (int(sig[32]) & 0x80)
+        and not (sig[32] == 0 and not (int(sig[33]) & 0x80))
+    )
+
+
+def compressedPubkey(pk):
+    if SECP256K1_MODULE == "cryptography" and not isinstance(pk, ecdsa.keys.VerifyingKey):
+        order = ecdsa.SECP256k1.order
+        x = pk.public_numbers().x
+        y = pk.public_numbers().y
+    else:
+        order = pk.curve.generator.order()
+        p = pk.pubkey.point
+        x = p.x()
+        y = p.y()
+    x_str = ecdsa.util.number_to_string(x, order)
+    return py23_bytes(chr(2 + (y & 1)), "ascii") + x_str
+
+
+def recover_public_key(digest, signature, i, message=None):
+    """Recover the public key from the the signature"""
+
+    # See http: //www.secg.org/download/aid-780/sec1-v2.pdf section 4.1.6 primarily
+    curve = ecdsa.SECP256k1.curve
+    G = ecdsa.SECP256k1.generator
+    order = ecdsa.SECP256k1.order
+    yp = i % 2
+    r, s = ecdsa.util.sigdecode_string(signature, order)
+    # 1.1
+    x = r + (i // 2) * order
+    # 1.3. This actually calculates for either effectively 02||X or 03||X depending on 'k' instead of always for 02||X as specified.
+    # This substitutes for the lack of reversing R later on. -R actually is defined to be just flipping the y-coordinate in the elliptic curve.
+    alpha = ((x * x * x) + (curve.a() * x) + curve.b()) % curve.p()
+    beta = ecdsa.numbertheory.square_root_mod_prime(alpha, curve.p())
+    y = beta if (beta - yp) % 2 == 0 else curve.p() - beta
+    # 1.4 Constructor of Point is supposed to check if nR is at infinity.
+    R = ecdsa.ellipticcurve.Point(curve, x, y, order)
+    # 1.5 Compute e
+    e = ecdsa.util.string_to_number(digest)
+    # 1.6 Compute Q = r^-1(sR - eG)
+    Q = ecdsa.numbertheory.inverse_mod(r, order) * (s * R + (-e % order) * G)
+
+    if SECP256K1_MODULE == "cryptography" and message is not None:
+        if not isinstance(message, bytes_types):
+            message = py23_bytes(message, "utf-8")
+        sigder = encode_dss_signature(r, s)
+        try:
+            Q_point = Q.to_affine()
+            public_key = ec.EllipticCurvePublicNumbers(
+                Q_point.x(), Q_point.y(), ec.SECP256K1()
+            ).public_key(default_backend())
+        except:
+            try:
+                public_key = ec.EllipticCurvePublicNumbers(
+                    Q._Point__x, Q._Point__y, ec.SECP256K1()
+                ).public_key(default_backend())
+            except:
+                Q_point = Q.to_affine()
+                public_key = ec.EllipticCurvePublicNumbers(
+                    int(Q_point.x()), int(Q_point.y()), ec.SECP256K1()
+                ).public_key(default_backend())
+        public_key.verify(sigder, message, ec.ECDSA(hashes.SHA256()))
+        return public_key
+    else:
+        # Not strictly necessary, but let's verify the message for paranoia's sake.
+        if not ecdsa.VerifyingKey.from_public_point(Q, curve=ecdsa.SECP256k1).verify_digest(
+            signature, digest, sigdecode=ecdsa.util.sigdecode_string
+        ):
+            return None
+        return ecdsa.VerifyingKey.from_public_point(Q, curve=ecdsa.SECP256k1)
+
+
+def recoverPubkeyParameter(message, digest, signature, pubkey):
+    """Use to derive a number that allows to easily recover the
+    public key from the signature
+    """
+    if not isinstance(message, bytes_types):
+        message = py23_bytes(message, "utf-8")
+    for i in range(0, 4):
+        if SECP256K1_MODULE == "secp256k1":
+            sig = pubkey.ecdsa_recoverable_deserialize(signature, i)
+            p = secp256k1.PublicKey(pubkey.ecdsa_recover(message, sig))
+            if p.serialize() == pubkey.serialize():
+                return i
+        elif SECP256K1_MODULE == "cryptography" and not isinstance(pubkey, PublicKey):
+            p = recover_public_key(digest, signature, i, message)
+            p_comp = hexlify(compressedPubkey(p))
+            pubkey_comp = hexlify(compressedPubkey(pubkey))
+            if p_comp == pubkey_comp:
+                return i
+        else:  # pragma: no cover
+            p = recover_public_key(digest, signature, i)
+            p_comp = hexlify(compressedPubkey(p))
+            p_string = hexlify(p.to_string())
+            if isinstance(pubkey, PublicKey):
+                pubkey_string = py23_bytes(repr(pubkey), "latin")
+            else:  # pragma: no cover
+                pubkey_string = hexlify(pubkey.to_string())
+            if p_string == pubkey_string or p_comp == pubkey_string:
+                return i
+    return None
+
+
+def sign_message(message, wif, hashfn=hashlib.sha256):
+    """Sign a digest with a wif key
+
+    :param str wif: Private key in
+    """
+
+    if not isinstance(message, bytes_types):
+        message = py23_bytes(message, "utf-8")
+
+    digest = hashfn(message).digest()
+    priv_key = PrivateKey(wif)
+    if SECP256K1_MODULE == "secp256k1":
+        p = py23_bytes(priv_key)
+        ndata = secp256k1.ffi.new("const int *ndata")
+        ndata[0] = 0
+        while True:
+            ndata[0] += 1
+            privkey = secp256k1.PrivateKey(p, raw=True)
+            sig = secp256k1.ffi.new("secp256k1_ecdsa_recoverable_signature *")
+            signed = secp256k1.lib.secp256k1_ecdsa_sign_recoverable(
+                privkey.ctx, sig, digest, privkey.private_key, secp256k1.ffi.NULL, ndata
+            )
+            if not signed == 1:
+                raise AssertionError()
+            signature, i = privkey.ecdsa_recoverable_serialize(sig)
+            if _is_canonical(signature):
+                i += 4  # compressed
+                i += 27  # compact
+                break
+    elif SECP256K1_MODULE == "cryptography":
+        cnt = 0
+        private_key = ec.derive_private_key(
+            int(repr(priv_key), 16), ec.SECP256K1(), default_backend()
+        )
+        public_key = private_key.public_key()
+        while True:
+            cnt += 1
+            if not cnt % 20:
+                log.info("Still searching for a canonical signature. Tried %d times already!" % cnt)
+            order = ecdsa.SECP256k1.order
+            sigder = private_key.sign(message, ec.ECDSA(hashes.SHA256()))
+            r, s = decode_dss_signature(sigder)
+            signature = ecdsa.util.sigencode_string(r, s, order)
+            # Make sure signature is canonical!
+            #
+            sigder = bytearray(sigder)
+            lenR = sigder[3]
+            lenS = sigder[5 + lenR]
+            if lenR == 32 and lenS == 32:
+                # Derive the recovery parameter
+                #
+                i = recoverPubkeyParameter(message, digest, signature, public_key)
+                i += 4  # compressed
+                i += 27  # compact
+                break
+    else:  # pragma: no branch  # pragma: no cover
+        cnt = 0
+        p = py23_bytes(priv_key)
+        sk = ecdsa.SigningKey.from_string(p, curve=ecdsa.SECP256k1)
+        while 1:
+            cnt += 1
+            if not cnt % 20:
+                log.info("Still searching for a canonical signature. Tried %d times already!" % cnt)
+
+            # Deterministic k
+            #
+            k = ecdsa.rfc6979.generate_k(
+                sk.curve.generator.order(),
+                sk.privkey.secret_multiplier,
+                hashlib.sha256,
+                hashlib.sha256(
+                    digest
+                    + struct.pack("d", time.time())  # use the local time to randomize the signature
+                ).digest(),
+            )
+
+            # Sign message
+            #
+            sigder = sk.sign_digest(digest, sigencode=ecdsa.util.sigencode_der, k=k)
+
+            # Reformating of signature
+            #
+            r, s = ecdsa.util.sigdecode_der(sigder, sk.curve.generator.order())
+            signature = ecdsa.util.sigencode_string(r, s, sk.curve.generator.order())
+
+            # Make sure signature is canonical!
+            #
+            sigder = bytearray(sigder)
+            lenR = sigder[3]
+            lenS = sigder[5 + lenR]
+            if lenR == 32 and lenS == 32:
+                # Derive the recovery parameter
+                #
+                i = recoverPubkeyParameter(message, digest, signature, sk.get_verifying_key())
+                i += 4  # compressed
+                i += 27  # compact
+                break
+
+    # pack signature
+    #
+    sigstr = struct.pack("<B", i)
+    sigstr += signature
+
+    return sigstr
+
+
+def verify_message(message, signature, hashfn=hashlib.sha256, recover_parameter=None):
+    if not isinstance(message, bytes_types):
+        message = py23_bytes(message, "utf-8")
+    if not isinstance(signature, bytes_types):
+        signature = py23_bytes(signature, "utf-8")
+    if not isinstance(message, bytes_types):
+        raise AssertionError()
+    if not isinstance(signature, bytes_types):
+        raise AssertionError()
+    digest = hashfn(message).digest()
+    sig = signature[1:]
+    if recover_parameter is None:
+        recover_parameter = bytearray(signature)[0] - 4 - 27  # recover parameter only
+    if recover_parameter < 0:
+        log.info("Could not recover parameter")
+        return None
+
+    if SECP256K1_MODULE == "secp256k1":
+        ALL_FLAGS = secp256k1.lib.SECP256K1_CONTEXT_VERIFY | secp256k1.lib.SECP256K1_CONTEXT_SIGN
+        # Placeholder
+        pub = secp256k1.PublicKey(flags=ALL_FLAGS)
+        # Recover raw signature
+        sig = pub.ecdsa_recoverable_deserialize(sig, recover_parameter)
+        # Recover PublicKey
+        verifyPub = secp256k1.PublicKey(pub.ecdsa_recover(message, sig))
+        # Convert recoverable sig to normal sig
+        normalSig = verifyPub.ecdsa_recoverable_convert(sig)
+        # Verify
+        verifyPub.ecdsa_verify(message, normalSig)
+        phex = verifyPub.serialize(compressed=True)
+    elif SECP256K1_MODULE == "cryptography":
+        p = recover_public_key(digest, sig, recover_parameter, message)
+        order = ecdsa.SECP256k1.order
+        r, s = ecdsa.util.sigdecode_string(sig, order)
+        sigder = encode_dss_signature(r, s)
+        p.verify(sigder, message, ec.ECDSA(hashes.SHA256()))
+        phex = compressedPubkey(p)
+    else:  # pragma: no branch  # pragma: no cover
+        p = recover_public_key(digest, sig, recover_parameter)
+        # Will throw an exception of not valid
+        p.verify_digest(sig, digest, sigdecode=ecdsa.util.sigdecode_string)
+        phex = compressedPubkey(p)
+
+    return phex
+
+
+def tweakaddPubkey(pk, digest256, SECP256K1_MODULE=SECP256K1_MODULE):
+    if SECP256K1_MODULE == "secp256k1":
+        tmp_key = secp256k1.PublicKey(pubkey=bytes(pk), raw=True)
+        new_key = tmp_key.tweak_add(digest256)  # <-- add
+        raw_key = hexlify(new_key.serialize()).decode("ascii")
+    else:
+        raise Exception("Must have secp256k1 for `tweak_add`")
+        # raw_key = ecmult(pk, 1, digest256, SECP256K1_MODULE)
+    return PublicKey(raw_key, prefix=pk.prefix)

nectargraphenebase/objects.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+import json
+
+from nectargraphenebase.types import Id, JsonObj, Optional, String
+
+from .operationids import operations
+from .py23 import integer_types, py23_bytes, string_types
+
+
+class Operation(object):
+    def __init__(self, op):
+        if isinstance(op, list) and len(op) == 2:
+            if isinstance(op[0], integer_types):
+                self.opId = op[0]
+                name = self.getOperationNameForId(self.opId)
+            else:
+                self.opId = self.operations().get(op[0], None)
+                name = op[0]
+                if self.opId is None:
+                    raise ValueError("Unknown operation")
+            self.name = name[0].upper() + name[1:]  # klassname
+            try:
+                klass = self._getklass(self.name)
+            except Exception:
+                raise NotImplementedError("Unimplemented Operation %s" % self.name)
+            self.op = klass(op[1])
+            self.appbase = False
+        elif isinstance(op, dict):
+            if len(op["type"]) > 10 and op["type"][-9:] == "operation":
+                name = op["type"][:-10]
+            else:
+                name = op["type"]
+            self.opId = self.operations().get(name, None)
+            if self.opId is None:
+                raise ValueError("Unknown operation")
+            self.name = name[0].upper() + name[1:]  # klassname
+            try:
+                klass = self._getklass(self.name)
+            except Exception:
+                raise NotImplementedError("Unimplemented Operation %s" % self.name)
+            self.op = klass(op["value"])
+            self.appbase = True
+        else:
+            self.op = op
+            self.name = type(self.op).__name__.lower()  # also store name
+            self.opId = self.operations()[self.name]
+
+    def operations(self):
+        return operations
+
+    def getOperationNameForId(self, i):
+        """Convert an operation id into the corresponding string"""
+        for key in self.operations():
+            if int(self.operations()[key]) is int(i):
+                return key
+        return "Unknown Operation ID %d" % i
+
+    def _getklass(self, name):
+        module = __import__("graphenebase.operations", fromlist=["operations"])
+        class_ = getattr(module, name)
+        return class_
+
+    def __bytes__(self):
+        return py23_bytes(Id(self.opId)) + py23_bytes(self.op)
+
+    def __str__(self):
+        return json.dumps([self.opId, self.op.toJson()])
+
+
+class GrapheneObject(object):
+    """Core abstraction class
+
+    This class is used for any JSON reflected object in Graphene.
+
+    * ``instance.__json__()``: encodes data into json format
+    * ``bytes(instance)``: encodes data into wire format
+    * ``str(instances)``: dumps json object as string
+
+    """
+
+    def __init__(self, data=None):
+        self.data = data
+
+    def __bytes__(self):
+        if self.data is None:
+            return py23_bytes()
+        b = b""
+        for name, value in list(self.data.items()):
+            if isinstance(value, string_types):
+                b += py23_bytes(value, "utf-8")
+            else:
+                b += py23_bytes(value)
+        return b
+
+    def __json__(self):
+        if self.data is None:
+            return {}
+        d = {}  # JSON output is *not* ordered
+        for name, value in list(self.data.items()):
+            if isinstance(value, Optional) and value.isempty():
+                continue
+
+            if isinstance(value, String):
+                d.update({name: str(value)})
+            else:
+                try:
+                    d.update({name: JsonObj(value)})
+                except Exception:
+                    d.update({name: value.__str__()})
+        return d
+
+    def __str__(self):
+        return json.dumps(self.__json__())
+
+    def toJson(self):
+        return self.__json__()
+
+    def json(self):
+        return self.__json__()
+
+
+def isArgsThisClass(self, args):
+    return len(args) == 1 and type(args[0]).__name__ == type(self).__name__

nectargraphenebase/objecttypes.py

@@ -0,0 +1,6 @@
+#: Object types for object ids
+object_type = {}
+object_type["null"] = 0
+object_type["base"] = 1
+object_type["account"] = 2
+object_type["OBJECT_TYPE_COUNT"] = 3

nectargraphenebase/operationids.py

@@ -0,0 +1,3 @@
+#: Operation ids
+operations = {}
+operations["demooepration"] = 0

nectargraphenebase/operations.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+from .objects import GrapheneObject, isArgsThisClass
+from .types import (
+    Set,
+    String,
+)
+
+
+class Demooepration(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+            super(Demooepration, self).__init__(
+                OrderedDict(
+                    [
+                        ("string", String(kwargs["string"], "account")),
+                        ("extensions", Set([])),
+                    ]
+                )
+            )

nectargraphenebase/prefix.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+class Prefix:
+    """This class is meant to allow changing the prefix.
+    The prefix is used to link a public key to a specific blockchain.
+    """
+
+    prefix = "STM"
+
+    def set_prefix(self, prefix):
+        if prefix:
+            self.prefix = prefix

nectargraphenebase/py23.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+import sys
+
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+
+if PY3:
+    bytes_types = (bytes,)
+    string_types = (str,)
+    integer_types = (int,)
+    text_type = str
+    binary_type = bytes
+else:
+    bytes_types = (bytes,)
+    string_types = (basestring,)  # noqa: F821
+    integer_types = (int, long)  # noqa: F821
+    text_type = unicode  # noqa: F821
+    binary_type = str
+
+
+def py23_bytes(item=None, encoding=None):
+    if item is None:
+        return b""
+    if hasattr(item, "__bytes__"):
+        return item.__bytes__()
+    else:
+        if encoding:
+            return bytes(item, encoding)
+        else:
+            return bytes(item)
+
+
+def py23_chr(item):
+    if PY2:
+        return chr(item)
+    else:
+        return bytes([item])