def unicodify(self): r = [] for s in self.data: o = ord(s) if o <= 7: r.append("u%04x" % o) elif o == 8: r.append("b") elif o == 9: r.append("\t") elif o == 10: r.append("\n") elif o == 11: r.append("u%04x" % o) elif o == 12: r.append("f") elif o == 13: r.append("\r") elif 13 < o < 32: r.append("u%04x" % o) else: r.append(s) return compat_bytes("".join(r), "utf-8")
def deriveDigest(self, chain): chain_params = self.getChainParams(chain) # Chain ID self.chainid = chain_params["chain_id"] # Do not serialize signatures sigs = self.data["signatures"] self.data["signatures"] = [] # Get message to sign # bytes(self) will give the wire formatted data according to # GrapheneObject and the data given in __init__() # from beowulf.beowulfd import Beowulfd # tx_hex = Beowulfd().get_transaction_hex(self.json()) # print("Server:", unhexlify(tx_hex[0:-2])) # print("Client:", compat_bytes(self)) # self.message = unhexlify(self.chainid + tx_hex[0:-2]) self.message = unhexlify(self.chainid) + compat_bytes(self) self.digest = hashlib.sha256(self.message).digest() # restore signatures self.data["signatures"] = sigs
def __bytes__(self): # padding amount = round(float(self.amount) * 10**self.precision) asset_name = self.asset + "\x00" * (9 - len(self.asset)) return (struct.pack("<q", amount) + struct.pack("<I", self.precision) + compat_bytes(asset_name, "ascii"))
def deriveChecksum(self, s): """ Derive the checksum """ checksum = hashlib.sha256(compat_bytes(s, "ascii")).hexdigest() return checksum[:4]
def derive_checksum(s): checksum = hashlib.sha512(compat_bytes(s, "ascii")).hexdigest() return checksum
def __bytes__(self): return compat_bytes(self.instance) # only yield instance
def __bytes__(self): """ Returns the raw public key (has length 33)""" return compat_bytes(self._pk)
def _unpad(s, BS): count = int(struct.unpack('B', compat_bytes(s[-1], 'ascii'))[0]) if compat_bytes(s[-count::], 'ascii') == count * struct.pack('B', count): return s[:-count] return s
def isempty(self): if not self.data: return True return not bool(compat_bytes(self.data))
def __bytes__(self): return compat_bytes(self.length) + b"".join( [compat_bytes(a) for a in self.data])
def __bytes__(self): # FIXME constraint data to self.length d = unhexlify(compat_bytes(self.data, 'utf-8')) return varint(len(d)) + d
def __bytes__(self): """Returns bytes representation.""" d = bytes(unhexlify(compat_bytes(self.data, 'ascii'))) return varint(len(d)) + d
def get_private_key_str(self): a = compat_bytes(self.account + self.role + self.password, 'utf8') s = hashlib.sha256(a).digest() return hexlify(s).decode('ascii')
def __bytes__(self): """ Returns the raw private key """ return compat_bytes(self._wif)
def __bytes__(self): decimals = int(str(self.data['decimals'])) asset_name = str( self.data['name']) + "\x00" * (9 - len(str(self.data['name']))) return struct.pack("<I", decimals) + compat_bytes(asset_name, "ascii")
def __bytes__(self): return varint(self.type_id) + compat_bytes(self.data)
def __bytes__(self): return compat_bytes(Id(self.opId)) + compat_bytes(self.op)
def __bytes__(self): b = b"" b += varint(len(self.data)) for e in self.data: b += compat_bytes(e[0]) + compat_bytes(e[1]) return b
def compressedPubkey(self, pk): order = pk.curve.generator.order() p = pk.pubkey.point x_str = ecdsa.util.number_to_string(p.x(), order) return compat_bytes(compat_chr(2 + (p.y() & 1)), 'ascii') + x_str
def __bytes__(self): return compat_bytes(self.data)
def sign(self, wifkeys, chain=None): """ Sign the transaction with the provided private keys. :param list wifkeys: Array of wif keys :param str chain: identifier for the chain :param tx_hex: identifier for the chain """ if not chain: raise ValueError("Chain needs to be provided!") self.deriveDigest(chain) # Get Unique private keys self.privkeys = [] [ self.privkeys.append(item) for item in wifkeys if item not in self.privkeys ] # Sign the message with every private key given! sigs = [] for wif in self.privkeys: p = compat_bytes(PrivateKey(wif)) i = 0 if USE_SECP256K1: 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, self.digest, privkey.private_key, secp256k1.ffi.NULL, ndata) assert signed == 1 signature, i = privkey.ecdsa_recoverable_serialize(sig) if self._is_canonical(signature): i += 4 # compressed i += 27 # compact break else: cnt = 0 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( self.digest + struct.pack("d", time.time( )) # use the local time to randomize the signature ).digest()) # Sign message # sigder = sk.sign_digest(self.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()) # This line allows us to convert a 2.7 byte array(which is just binary) to an array of byte values. # We can then use the elements in sigder as integers, as in the following two lines. sigder = array.array('B', sigder) # Make sure signature is canonical! # lenR = sigder[3] lenS = sigder[5 + lenR] if lenR is 32 and lenS is 32: # Derive the recovery parameter # i = self.recoverPubkeyParameter( self.digest, signature, sk.get_verifying_key()) i += 4 # compressed i += 27 # compact break # pack signature # sigstr = struct.pack("<B", i) sigstr += signature sigs.append(Signature(sigstr)) self.data["signatures"] = Array(sigs) return self
def __bytes__(self): """ Returns the raw content of the ``Base58CheckEncoded`` address """ if self._address is None: return compat_bytes(self.derivesha512address()) else: return compat_bytes(self._address)