def web3_sha3(self, value, encoding='hex'): logger.info('web3_sha3') if encoding == 'hex': value = decode_hex(value) else: value = force_bytes(value) return encode_32bytes(keccak_256(value).digest())
def __init__(self): import sha3 self.PrivateKey = getRandom(512) self.PublicKey = [0]*512 for i in range(0, 512): self.PublicKey[i] = bytes_to_int(sha3.keccak_256(int_to_bytes32(self.PrivateKey[i])).digest())
def to_addr(self,sk_hex): # sk_hex instead of pubhex # ed25519ll, a low-level ctypes wrapper for Ed25519 digital signatures by # Daniel Holth <*****@*****.**> - http://bitbucket.org/dholth/ed25519ll/ try: from ed25519ll.djbec import scalarmult,edwards,encodepoint,B except: from mmgen.ed25519 import scalarmult,edwards,encodepoint,B # Source and license for scalarmultbase function: # https://github.com/bigreddmachine/MoneroPy/blob/master/moneropy/crypto/ed25519.py # Copyright (c) 2014-2016, The Monero Project # All rights reserved. def scalarmultbase(e): if e == 0: return [0, 1] Q = scalarmult(B, e//2) Q = edwards(Q, Q) if e & 1: Q = edwards(Q, B) return Q def hex2int_le(hexstr): return int(hexstr.decode('hex')[::-1].encode('hex'),16) vk_hex = self.to_viewkey(sk_hex) pk_str = encodepoint(scalarmultbase(hex2int_le(sk_hex))) pvk_str = encodepoint(scalarmultbase(hex2int_le(vk_hex))) addr_p1 = g.proto.addr_ver_num['monero'][0].decode('hex') + pk_str + pvk_str import sha3 return CoinAddr(self.b58enc(addr_p1 + sha3.keccak_256(addr_p1).digest()[:4]))
def MLSAG_Test(m=4, n=3): import random xk = [] indices = [] pub_keys = [] #Generate Private Keys for i in range(0, m): xk = xk + [getRandom()] indices = indices + [random.randrange(0, n)] #Generate Mix-in Public Keys for i in range(0, m*(n-1)): P = multiply(G1, getRandom()) pub_keys = pub_keys + [P] msg = b"MLSAGTest" hasher = sha3.keccak_256() hasher.update(msg) msgHash = int_to_bytes32(bytes_to_int(hasher.digest())) mlsag_signature = MLSAG.Sign_GenRandom(m, msgHash, xk, indices, pub_keys) mlsag_signature.Print() if (mlsag_signature.Verify()): print("MLSAG Verification Success!") else: print("MLSAG Verification Failure!")
def Verify(self): #Check input parameter lengths m = self.m if (m == 0): return False if (len(self.pub_keys) % m != 0): return False n = len(self.pub_keys) // m if (n == 0): return False if (len(self.signature) != (m*n+1)): return False #Initialize c1 hasher (total length of array + message hash) hasher = sha3.keccak_256() hasher.update(int_to_bytes32(2*m+1)) hasher.update(self.msgHash) #Calculate Rings for i in range(0, m): #Get c1 ck = self.signature[0] #Calculate (n-1) ring segments for j in range(0, n-1): index = m*j+i ck = MSAG.CalculateRingSegment(self.msgHash, ck, self.signature[index+1], self.pub_keys[index]) #Calculate last ring segment index = m*(n-1)+i point = MSAG.CalculateRingSegment_NoHash(ck, self.signature[index+1], self.pub_keys[index]) #Update c1 hash hasher.update(int_to_bytes32(point[0].n)) hasher.update(int_to_bytes32(point[1].n)) #Check if ring is closed ck = bytes_to_int(hasher.digest()) return (self.signature[0] == ck)
def verify_addr(cls,addr,hex_width,return_dict=False): def b58dec(addr_str): from mmgen.util import baseconv l = len(addr_str) a = ''.join([baseconv.tohex(addr_str[i*11:i*11+11],'b58',pad=16) for i in range(l//11)]) b = baseconv.tohex(addr_str[-(l%11):],'b58',pad=10) return a + b from mmgen.util import is_b58_str assert is_b58_str(addr),'Not valid base-58 string' assert len(addr) == cls.addr_width,'Incorrect width' ret = b58dec(addr) try: assert not g.use_internal_keccak_module from sha3 import keccak_256 except: from mmgen.keccak import keccak_256 chk = keccak_256(bytes.fromhex(ret)[:-4]).hexdigest()[:8] assert chk == ret[-8:],'{}: incorrect checksum. Correct value: {}'.format(ret[-8:],chk) return { 'hex': ret, 'format': 'monero' } if return_dict else True
def LinkableRingHashFunction(msgHash, left, right): hasher = sha3.keccak_256() hasher.update(msgHash) hasher.update(int_to_bytes32(left[0].n)) hasher.update(int_to_bytes32(left[1].n)) hasher.update(int_to_bytes32(right[0].n)) hasher.update(int_to_bytes32(right[1].n)) return bytes_to_int(hasher.digest())
def sha3(data: bytes) -> bytes: """ Raises: RuntimeError: If Keccak lib initialization failed, or if the function failed to compute the hash. TypeError: This function does not accept unicode objects, they must be encoded prior to usage. """ return keccak_256(data).digest()
def hash_to_point(p): hasher = sha3.keccak_256() hasher.update(int_to_bytes32(p[0].n)) hasher.update(int_to_bytes32(p[1].n)) x = bytes_to_int(hasher.digest()) % Pcurve onCurve = False while(not onCurve): y_squared = (pow(x, 3, Pcurve) + 3) % Pcurve y = pow(y_squared, (Pcurve+1)//4, Pcurve) onCurve = (pow(y,2,Pcurve) == y_squared) if(not(onCurve)): x = x + 1 return (FQ(x), FQ(y))
def brute_prototype(function, dict_file, max_args=3, exhaustive=False): logging.info('Now processing function %s' % function.encode('hex')) argtypes = ['bool', 'address', 'bytes', 'string'] if exhaustive: argtypes += ['int%s' % x for x in xrange(8, 257, 8)] argtypes += ['uint%s' % x for x in xrange(8, 257, 8)] argtypes += ['bytes%s' % x for x in xrange(1, 33)] else: argtypes += ['bytes8', 'bytes16', 'bytes32', 'uint256', 'int256'] with open(dict_file, 'r') as names: counter = 0 for name in names: if counter % 1000 == 0: logging.debug('Processed %s names' % counter) for argnum in xrange(max_args + 1): for signature in itertools.product(argtypes, repeat=argnum): prototype = '%s(%s)' % (name.strip(), ','.join(signature)) if sha3.keccak_256(prototype).digest()[:4] == function: logging.warning('FOUND function %s prototype: %s' % (function.encode('hex'), prototype)) return prototype counter += 1
def newid_encode_by_public_key(public_key, chain_id): """ generate newid by public key :param str public_key: The public key of newid :param int chain_id: The blockchain ID :rtype: str :return: The encoded newid """ if public_key.startswith('0x'): public_key = public_key[2:] if len(public_key) < 64: public_key = '0' * (64 - len(public_key)) + public_key k = keccak_256() k.update(bytearray.fromhex(public_key)) data = k.hexdigest() hex_chainID = hex(chain_id)[2:][-8:] if (len(hex_chainID) % 2) == 1: hex_chainID = '0' + hex_chainID num_sum = hex_chainID + data data = base58.b58encode_check(b'\0' + binascii.a2b_hex(num_sum)) newid = PREFIX + 'ID' + data.decode() return newid
def insert(node, db, is_leaf): if len(node) == 17: for hash in node[:16]: if not hash: continue exist = db.get(hash) assert exist, "Child hash is not inserted" node = copy.copy(node) if len(node) == 2: node[0] = nibbles_to_bytes(node[0], is_leaf) node_rlp = rlp.encode(node) k = sha3.keccak_256() k.update(node_rlp) node_hash = k.digest() assert len( k.hexdigest()) == 64, "Invalid hash length for %s" % node_hash.hexdigest() exist = db.get(node_hash) assert not exist or exist == node_rlp, "Conflict insertion on %s(%s-%s)" %\ (node_hash.hex(), exist.hex(), node_rlp.hex()) db.put(node_hash, node_rlp) return node_hash
def parse_addr(self,addr): from .baseconv import baseconv,is_b58_str def b58dec(addr_str): l = len(addr_str) a = b''.join([baseconv.tobytes(addr_str[i*11:i*11+11],'b58',pad=8) for i in range(l//11)]) b = baseconv.tobytes(addr_str[-(l%11):],'b58',pad=5) return a + b ret = b58dec(addr) try: assert not g.use_internal_keccak_module from sha3 import keccak_256 except: from .keccak import keccak_256 chk = keccak_256(ret[:-4]).digest()[:4] assert ret[-4:] == chk, f'{ret[-4:].hex()}: incorrect checksum. Correct value: {chk.hex()}' return self.parse_addr_bytes(ret)
def validateFeedback( address, id, date, created_at, comment, feedback_address, latitude, longitude, current_latitude, current_longitude, source, feedback_image, ): fields = [ id, date, created_at, bytes.fromhex(keccak_256(comment.encode("utf-8")).hexdigest()), bytes.fromhex( keccak_256(feedback_address.encode("utf-8")).hexdigest()), bytes.fromhex(keccak_256(latitude.encode("utf-8")).hexdigest()), bytes.fromhex(keccak_256(longitude.encode("utf-8")).hexdigest()), bytes.fromhex( keccak_256(current_latitude.encode("utf-8")).hexdigest()), bytes.fromhex( keccak_256(current_longitude.encode("utf-8")).hexdigest()), bytes.fromhex(keccak_256(source.encode("utf-8")).hexdigest()), bytes.fromhex(keccak_256(feedback_image.encode("utf-8")).hexdigest()), ] feedback = getFeedback(address, id) for i in range(len(fields)): if feedback[i] != fields[i]: return False return True
def sign(private_key: str, message: Optional[str] = None, message_hash: Optional[str] = None) -> str: """ Sign XinFin message data by private key. :param private_key: XinFin private key. :type private_key: str. :param message: Message data, default to ``None``. :type message: str. :param message_hash: Message data hash, default to ``None``. :type message_hash: str. :return: str -- XinFin signed message or signature. >>> from pyxdc.signature import sign >>> sign(private_key="4235d9ffc246d488d527177b654e7dd5c02f5c5abc2e2054038d6825224a24de", message="meherett") "74ad07a84b87fa3efa2f0e825506fb8bbee41021ca77a30e8ffa2bd66d47d99917d4a0587185e78a051a9cb80ebf65c7d62dbeedb7f9a029f961d70b52a10dc001" >>> sign(private_key="4235d9ffc246d488d527177b654e7dd5c02f5c5abc2e2054038d6825224a24de", message_hash="4bbbfd0c33fea618f4a9aa75c02fe76e50fa59798af021bc34f7856f3259c685") "74ad07a84b87fa3efa2f0e825506fb8bbee41021ca77a30e8ffa2bd66d47d99917d4a0587185e78a051a9cb80ebf65c7d62dbeedb7f9a029f961d70b52a10dc001" """ if message: message_bytes = curried.to_bytes(primitive=None, hexstr=None, text=message) msg_length = str(len(message_bytes)).encode('utf-8') joined = b'\x19' + b'E' + b'thereum Signed Message:\n' + msg_length + message_bytes keccak_256_message = keccak_256() keccak_256_message.update(joined) message_hash = keccak_256_message.digest() elif message_hash: message_hash = unhexlify(message_hash) else: raise ValueError("Message data or hash is required to sign.") return ecdsa_raw_sign(msg_hash=message_hash, private_key_bytes=unhexlify(private_key)).hex()
def submit_data_to_logger(self, data): try: # calculate hash locally hashes = [] padded_data = list(data) for x in range( int(self.__page_size / self.__bytes_of_word) - len(data)): # padding zero to page size padded_data.append(bytes(self.__bytes_of_word)) for x in range(int(self.__page_size / self.__bytes_of_word)): k = sha3.keccak_256() # padding zero to word size padded_data[x] += b'0' * (self.__bytes_of_word - len(padded_data[x])) k.update(padded_data[x]) hashes.append(bytes.fromhex(k.hexdigest())) root = self.__calculate_root_from_hashes(hashes) (exists, index) = self.__get_index_from_root(root, self.__page_log_2_size) if exists: return (index, root) # submit data if is the first time nonce = self.__w3.eth.getTransactionCount(self.__user, "pending") txn = self.__logger.functions.calculateMerkleRootFromData( self.__page_log_2_size, data).buildTransaction({ "nonce": nonce, "from": self.__user }) return self.__send_txn_to_logger(txn, True) except ValueError as e: print("calculateMerkleRoot REVERT transaction: " + str(e))
def check_point_update(checkpoint_path, checkpoints, path, ts, current_pos, checkpoint_timediff): with checkpoint_lock: if path not in checkpoints: checkpoints[path] = { 'last_ts': ts, 'last_pos': current_pos, 'history': [] } # Time to make a checkpoint. print(ts - checkpoints[path]['last_ts']) if ts - checkpoints[path]['last_ts'] > checkpoint_timediff: print('making checkpoint') last_pos = checkpoints[path]['last_pos'] with open(path, 'rb') as logfile: logfile.seek(last_pos) total = current_pos - last_pos _hash = sha3.keccak_256() while total > 0: bufsize = 1024 if math.floor(total / 1024) else total _hash.update(logfile.read(bufsize)) total -= bufsize checkpoints[path]['history'].append({ 'hash': _hash.hexdigest(), 'from_date': checkpoints[path]['last_ts'].isoformat(), 'to_date': ts.isoformat(), 'from_pos': last_pos, 'to_pos': current_pos, 'root_hash': None }) checkpoints[path]['last_pos'] = current_pos checkpoints[path]['last_ts'] = ts save_checkpoints(checkpoint_path, checkpoints)
def ed25519_generate_key_pair_from_secret(secret): """ Generate a new key pair. Args: secret (:class:`string`): A secret that serves as a seed Returns: A tuple of (private_key, public_key) encoded in base58. """ # if you want to do this correctly, use a key derivation function! if not isinstance(secret, bytes): secret = secret.encode() hash_bytes = sha3.keccak_256(secret).digest() sk = Ed25519SigningKeyFromHash.generate(hash_bytes=hash_bytes) # Private key private_value_base58 = sk.encode(encoding='base58') # Public key public_value_compressed_base58 = sk.get_verifying_key().encode( encoding='base58') return private_value_base58, public_value_compressed_base58
def abi_to_func_hashes(abi): func_hashes = {} abi = json.loads(abi) for fn in abi: if 'name' not in fn: continue if fn['type'] != 'function': continue fn_sig = fn['name'] fn_sig += '(' for in_param in fn['inputs']: fn_sig += in_param['type'] fn_sig += ',' if fn_sig[-1] == ',': fn_sig = fn_sig[:-1] + ')' else: fn_sig = fn_sig + ')' k = sha3.keccak_256() k.update(fn_sig.encode()) hash = k.hexdigest()[:8] func_hashes[fn['name']] = hash return func_hashes
def _parse_abi(abi: str, func_name2quota: Dict[str, int]) -> Dict[str, ABI]: """解析ABI到函数签名.""" result: Dict[str, ABI] = {} for func_def in json.loads(abi): if func_def['type'] not in ('function', 'constructor'): # 比如 event continue func_name = func_def.get('name', '') return_types = ','.join(i['type'] for i in func_def.get('outputs', [])) mutable = func_def['stateMutability'] not in ('view', 'pure', 'constant') param_types = ','.join(i['type'] for i in func_def['inputs']) sig = f'{func_name}({param_types})' func_addr = '0x' + sha3.keccak_256(sig.encode()).hexdigest()[:8] t = ABI(func_name, func_addr, param_types, return_types, mutable, func_name2quota.get(func_name, DEFAULT_QUOTA)) # 重载函数只支持第一个名字的自动映射, 其他都要使用方法地址. if func_name not in result: result[func_name] = t if func_name != '': # 跳过构造函数 result[func_addr] = t return result
def ecrecover(self, block_identifier): block = self.getBlock(block_identifier) extra = block.proofOfAuthorityData[0:32] sign = block.proofOfAuthorityData[32:] raw_data = [ bytes.fromhex(remove_0x_prefix(block.parentHash.hex())), bytes.fromhex(remove_0x_prefix(block.miner)), bytes.fromhex(remove_0x_prefix(block.stateRoot.hex())), bytes.fromhex(remove_0x_prefix(block.transactionsRoot.hex())), bytes.fromhex(remove_0x_prefix(block.receiptsRoot.hex())), bytes.fromhex(remove_0x_prefix(block.logsBloom.hex())), block.number, block.gasLimit, block.gasUsed, block.timestamp, extra, bytes.fromhex(remove_0x_prefix(block.nonce)) ] message_hash = sha3.keccak_256(rlp.encode(raw_data)).digest() hash_bytes = HexBytes(message_hash) signature_bytes = HexBytes(sign) signature_bytes_standard = to_standard_signature_bytes(signature_bytes) signature_obj = self.account._keys.Signature( signature_bytes=signature_bytes_standard) return remove_0x_prefix( signature_obj.recover_public_key_from_msg_hash( hash_bytes).to_hex())
def signMessage(msg: Union[str, Dict], key=None): """Sign the message using an Ethereum private key. This method signs the message for the user authentication mechanism Args: msg: message to be signed private_key: the key can be an app key or a user key used to sign the message Returns: string: a signed message """ k = sha3.keccak_256() if isinstance(msg, str): encoded_message = msg.encode('utf-8') else: encoded_message = (json.dumps(msg)).encode("utf-8") k.update(encoded_message) message_hash = k.hexdigest() if key is not None: signed_message = Account.signHash(message_hash, key) sig_hx = signed_message.signature.hex() return str(sig_hx.replace("0x", "")) else: return " "
def hash_header(header, height): if header is None: return '0' * 64 if header.get('prev_block_hash') is None: header['prev_block_hash'] = '00' * 32 header2 = bfh(serialize_header(header, (not is_postfork(height)))) s = sha3.keccak_256() nonce = int(hash_encode(header2[132:140]), 16) mixhash = hash_encode(header2[141:173]) header_hash_hex = header2[:108] + bytes(32) s.update(header_hash_hex) header_hash = swap(s.hexdigest()) go_wrapper_url = "https://progpow.bitcoininterest.io/" \ "?header_hash={0}" \ "&nonce={1}" \ "&mix_hash={2}".format(header_hash, nonce, mixhash) r = r_ses.get(go_wrapper_url) block_hash = r.json().get('digest') return block_hash
def Sign_CompactPin(m, msgHash, xk, indices, Pin, random): assert(len(xk) == m) assert(len(indices) == m) assert( (len(Pin) % m ) == 0) n = (len(Pin) // m) + 1 assert( len(random) == m*n ) #Initialize Output Arrays Pout = [0]*(m*n) signature = [0]*(m*n+1) #Initialize c1 hasher (total length of array + message hash) hasher = sha3.keccak_256() hasher.update(int_to_bytes32(2*m+1)) hasher.update(msgHash) #Calulate 1st half of all rings (for c1 calculation) for i in range(0, m): #Make sure index is mod n indices[i] = indices[i] % n #Store public key for known private key Pout[m*indices[i]+i] = multiply(G1, xk[i]) if (indices[i] == (n-1)): point = MSAG.StartRing_NoHash(random[m*indices[i]+i]) else: ck = MSAG.StartRing(msgHash, random[m*indices[i]+i]) for j in range((indices[i]+1)%n,(n-1)): #Calculate array index for easy reference index = m*j+i #Extract input public key if (j > indices[i]): point = Pin[index - m] else: point = Pin[index] #Store public key in output Pout[index] = point #Calculate ring segment ck = MSAG.CalculateRingSegment(msgHash, ck, random[index], point) #Store s value signature[index+1] = random[index] #Calculate last ring segment before c1 index = m*(n-1) + i #Extract Public Key point = Pin[index-m] Pout[index] = point point = MSAG.CalculateRingSegment_NoHash(ck, random[index], point) #Store s value signature[index+1] = random[index] #Store update c1 hash hasher.update(int_to_bytes32(point[0].n)) hasher.update(int_to_bytes32(point[1].n)) #Store c1 signature[0] = bytes_to_int(hasher.digest()) #Calculate 2nd half of each ring for i in range(0, m): #Fetch c1 ck = signature[0] #Calculate remaining ring segments for j in range(0, indices[i]): index = m*j+i #Extract public key point = Pin[index] Pout[index] = point #Calculate Ring Segment ck = MSAG.CalculateRingSegment(msgHash, ck, random[index], point) #Store s value signature[index+1] = random[index] #Close Ring index = m*indices[i] + i signature[index+1] = MSAG.CompleteRing(random[index], ck, xk[i]) return MSAG(msgHash, m, Pout, signature)
#!/usr/bin/python3 from secrets import token_bytes from coincurve import PublicKey from sha3 import keccak_256 with open('keys.txt') as fp: key = fp.readline() # Debug print("readed key: ", key) encoded_key = key.encode() print("encoded_key: ", encoded_key.decode()) striped_key = encoded_key.strip() print("striped_key: ", striped_key.strip()) cnt = 1 while key: # private_key = keccak_256(token_bytes(32)).digest() public_key = PublicKey.from_valid_secret(striped_key).format( compressed=False)[1:] addr = keccak_256(public_key).digest()[-20:] print('private_key:', striped_key.hex()) print('eth addr: 0x' + addr.hex()) key = fp.readline() cnt += 1
def sha3_256(x): return _sha3.keccak_256(x).digest() except:
def save_to_mew(priv_keys, n=1 << 18, p=1, r=8, dklen=32): try: passwd = getpass('Enter the password for saving (utf-8): ').encode( 'utf-8') passwd2 = getpass('Enter the password again (utf-8): ').encode('utf-8') if passwd != passwd2: raise KeytreeError("mismatching passwords") for priv_key in priv_keys: addr = get_eth_addr(priv_key.get_verifying_key()) priv_key = priv_key.to_string() with open("mew-{}.json".format(addr), "w") as f: iv = os.urandom(16) salt = os.urandom(16) m = 128 * r * (n + p + 2) dk = hashlib.scrypt(passwd, salt=salt, n=n, r=r, p=p, dklen=dklen, maxmem=m) obj = AES.new(dk[:dklen >> 1], mode=AES.MODE_CTR, counter=Counter.new(128, initial_value=int.from_bytes( iv, 'big'))) enc_pk = obj.encrypt(priv_key) # generate MAC h = keccak_256() h.update(dk[len(dk) >> 1:]) h.update(enc_pk) mac = h.digest() crypto = { 'ciphertext': enc_pk.hex(), 'cipherparams': { 'iv': iv.hex() }, 'cipher': 'aes-128-ctr', 'kdf': 'scrypt', 'kdfparams': { 'dklen': dklen, 'salt': salt.hex(), 'n': n, 'r': r, 'p': p }, 'mac': mac.hex() } json.dump( { 'version': 3, 'id': str(uuid4()), 'address': addr, 'Crypto': crypto }, f) except FileNotFoundError: raise KeytreeError("failed while saving")
def address(self): keccak_256 = sha3.keccak_256() keccak_256.update(self.verified_key.to_string()) address = keccak_256.hexdigest()[24:] return checksum_encode(address)
def make_4byte_signature(text_signature): from .encoding import force_bytes return keccak_256(force_bytes(text_signature)).digest()[:4]
def hash(self, message: bytes): keccak = sha3.keccak_256() keccak.update(message) return keccak.hexdigest()
def keccak256(data): hasher = sha3.keccak_256() hasher.update(data) return hasher.digest()
def to_addr(self,pubhex): assert type(pubhex) == PubKey import sha3 return CoinAddr(sha3.keccak_256(pubhex[2:].decode('hex')).digest()[12:].encode('hex'))
def to_viewkey(self,sk_hex): assert len(sk_hex) == 64,'{}: incorrect privkey length'.format(len(sk_hex)) import sha3 return MoneroViewKey(g.proto.preprocess_key(sha3.keccak_256(sk_hex.decode('hex')).hexdigest(),None))
from sha3 import keccak_256 from jsonschema import ( validate, ValidationError, ) # sanity check we are using the right sha3 function assert keccak_256(b'').hexdigest() == 'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470', keccak_256(b'').hexdigest() # NOQA def make_4byte_signature(text_signature): from .encoding import force_bytes return keccak_256(force_bytes(text_signature)).digest()[:4] ARGUMENT_SCHEMA = { 'type': 'object', 'properties': { 'name': { 'type': 'string', }, 'type': { 'type': 'string', }, }, 'required': ['name', 'type'], }
def test_201503110346PYTHON_PUSH24(self): """ Testcase taken from https://github.com/ethereum/tests File: 201503110346PYTHON_PUSH24.json sha256sum: 0f512fa3c9cf0e24e246ca46e8e072745df14f1cdfc8fcf6d201aba5e55f7932 Code: """ def solve(val): return self._solve(constraints, val) constraints = ConstraintSet() blocknumber = constraints.new_bitvec(256, name='blocknumber') constraints.add(blocknumber == 300) timestamp = constraints.new_bitvec(256, name='timestamp') constraints.add(timestamp == 2) difficulty = constraints.new_bitvec(256, name='difficulty') constraints.add(difficulty == 115792089237316195423570985008687907853269984665640564039457584007913129639935) coinbase = constraints.new_bitvec(256, name='coinbase') constraints.add(coinbase == 244687034288125203496486448490407391986876152250) gaslimit = constraints.new_bitvec(256, name='gaslimit') constraints.add(gaslimit == 1000000) world = evm.EVMWorld(constraints, blocknumber=blocknumber, timestamp=timestamp, difficulty=difficulty, coinbase=coinbase, gaslimit=gaslimit) acc_addr = 0xf572e5295c57f15886f9b263e2f6d2d6c7b5ec6 acc_code = unhexlify('7745414245403745f31387900a8d55') acc_balance = constraints.new_bitvec(256, name='balance_0xf572e5295c57f15886f9b263e2f6d2d6c7b5ec6') constraints.add(acc_balance == 1000000000000000000) acc_nonce = constraints.new_bitvec(256, name='nonce_0xf572e5295c57f15886f9b263e2f6d2d6c7b5ec6') constraints.add(acc_nonce == 0) world.create_account(address=acc_addr, balance=acc_balance, code=acc_code, nonce=acc_nonce) address = 0xf572e5295c57f15886f9b263e2f6d2d6c7b5ec6 caller = 0xcd1722f3947def4cf144679da39c4c32bdc35681 price = constraints.new_bitvec(256, name='price') constraints.add(price == 100000000000000) value = constraints.new_bitvec(256, name='value') constraints.add(value == 1000000000000000000) gas = constraints.new_bitvec(256, name='gas') constraints.add(gas == 10000) data = '' # open a fake tx, no funds send world._open_transaction('CALL', address, price, data, caller, value, gas=gas) # This variable might seem redundant in some tests - don't forget it is auto generated # and there are cases in which we need it ;) result, returndata = self._test_run(world) # World sanity checks - those should not change, right? self.assertEqual(solve(world.block_number()), 300) self.assertEqual(solve(world.block_gaslimit()), 1000000) self.assertEqual(solve(world.block_timestamp()), 2) self.assertEqual(solve(world.block_difficulty()), 115792089237316195423570985008687907853269984665640564039457584007913129639935) self.assertEqual(solve(world.block_coinbase()), 0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba) # Add post checks for account 0xf572e5295c57f15886f9b263e2f6d2d6c7b5ec6 # check nonce, balance, code self.assertEqual(solve(world.get_nonce(0xf572e5295c57f15886f9b263e2f6d2d6c7b5ec6)), 0) self.assertEqual(solve(world.get_balance(0xf572e5295c57f15886f9b263e2f6d2d6c7b5ec6)), 1000000000000000000) self.assertEqual(world.get_code(0xf572e5295c57f15886f9b263e2f6d2d6c7b5ec6), unhexlify('7745414245403745f31387900a8d55')) # check outs self.assertEqual(returndata, unhexlify('')) # check logs logs = [Log(unhexlify('{:040x}'.format(l.address)), l.topics, solve(l.memlog)) for l in world.logs] data = rlp.encode(logs) self.assertEqual(sha3.keccak_256(data).hexdigest(), '1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347') # test used gas self.assertEqual(solve(world.current_vm.gas), 9997)
def sha3(seed): return keccak_256(seed).digest()
hasher = hashlib.new('ripemd160') hasher.update(r) r = hasher.digest() return '1' + encode58_check(r, version=0) priv = SigningKey.generate(curve=SECP256k1) pub = b'\x04' + priv.get_verifying_key().to_string() print('Private:', priv.to_string().hex()) print('Private58:', encode58_check(priv.to_string(), 128)) print('Public:', pub.hex()) print('Address:', getAddress(pub)) print('----------------------------------------------') keccak = sha3.keccak_256() priv = SigningKey.generate(curve=SECP256k1) pub = priv.get_verifying_key().to_string() keccak.update(pub) address = keccak.hexdigest()[24:] print("Private key:", priv.to_string().hex()) print("Public key: ", pub.hex()) print("Address: 0x" + address) #priv = SigningKey.generate(curve=SECP256k1) #pub = priv.get_verifying_key() #print(priv.to_string()) #print(pub.to_string())
def sign_message(self, message): msg = '0x' + keccak_256(message.encode('utf-8')).hexdigest() msg = '\x19Ethereum Signed Message:\n%d%s' % (len(msg), msg) msg = bytearray(msg.encode('utf-8')) return self.sign_digest(bytearray( keccak_256(msg).digest())).eth_signature_format()
datasetLocationEnvvar = 'IEXEC_INPUT_FILES_FOLDER' datasetFilenameEnvvar = 'IEXEC_DATASET_FILENAME' if __name__ == '__main__': # Seed using the arguments → still not deterministic event with arguments random.seed(" ".join(sys.argv), random.random()) # OPTIONAL: reseed using dataset to reseed the random → still not deterministic even with a dataset try: root = os.environ.get(datasetLocationEnvvar, inFolder), file = os.environ.get(datasetFilenameEnvvar), if file: with open('{root}{file}'.format(root=root, file=file), 'r') as file: random.seed(file.read(), random.random()) except FileNotFoundError: pass # Generate random value and write it to the callback file callback = '{:064x}'.format(random.getrandbits(256)) with open(callbackFilePath, 'w') as callbackFile: callbackFile.write('0x{}'.format(callback)) # Generate the determinism file for verification and write it to the determinism file determinism = sha3.keccak_256() determinism.update(bytes.fromhex(callback)) with open(determinismFilePath, 'w') as determinismFile: determinismFile.write('0x{}'.format(determinism.hexdigest()))
def create_method_id(sig): return keccak_256(sig.encode()).hexdigest()[:8] class Token(MMGenObject): # ERC20
import binascii import ecdsa import sha3 from Crypto.Cipher import AES from getTrueRandom import generateTrueRandom privateKey = generateTrueRandom(32) print "Private key is:" + binascii.hexlify(privateKey) signingObj = ecdsa.SigningKey.from_string(privateKey, curve=ecdsa.SECP256k1) publicKeyObj = signingObj.verifying_key publicKeyString = binascii.hexlify(publicKeyObj.to_string()) print "Public key is:" + publicKeyString keccakObj = sha3.keccak_256() keccakObj.update(publicKeyObj.to_string()) publicAdress64 = keccakObj.hexdigest() publicAdressFinal = "0x" + publicAdress64[-40:] print "Public ETH adress is: " + publicAdressFinal
def _do_op_call(self, msg): r = sha3.keccak_256(bytes(msg)).digest() assert len(r) == self.DIGEST_LENGTH return r
def eth_to_address(prefix, subkey): hasher = sha3.keccak_256() hasher.update(subkey.sec(True)[1:]) return hexlify(hasher.digest()[-20:]).decode()
def identityCreation(): print art print "\nIdentity Creation Script - Block SSL\n" keybaseCheck() ans1 = raw_input("Do you own a Keybase.io account? [Y]es [N]o, default: [Y]\n") if ans1 == "Y" or ans1 == "y" or ans1 == "" or ans1 == " ": os.system("keybase version") #check for keybase version print "Checking for Updates...\n" os.system("echo 3 | keybase update check >/dev/null 2>&1") #check for keybase updates without terminal output os.system("keybase login") #login to keybase through terminal else: os.system("keybase version") print "Checking for Updates...\n" os.system('echo 3 | keybase update check >/dev/null 2>&1') os.system("keybase signup") #signup to keybase through terminal keccak = sha3.keccak_256() ex = raw_input("Do you already own an Ethereum address that you want to use? [Y]es [N]o, default: [Y]") if ex == "Y" or ex == "y" or ex == "" or ex == " ": gen_priv = raw_input("Which is your private key? (in hexadecimal format)\n") #Private Key of the owner gen_priv = BitcoinPrivateKey(gen_priv) print "Saving to Generation_Private.pem file..." open("Generation_Private.pem", "w").write(gen_priv.to_pem()) #Saving to file print "Generating \"Generation\" Public Key..." gen_pub = gen_priv.get_verifying_key() #Generate the "Generation" public key from gen_priv print "Saving to Generation_Public.pem file..." open("Generation_Public.pem", "w").write(gen_pub.to_pem()) #Saving to file print "Public/Private key pair creation:" print "Warning: This is a pseudo-random generation." print "Warning: If you want complete randomness consider other ways of Public/Private key pair generation." gen_pub = gen_pub.to_string() keccak.update(gen_pub) gen_address = keccak.hexdigest()[24:] open("Gen_Address.txt", "w").write("0x" + gen_address) else: print "Public/Private key pair creation:" print "Warning: This is a pseudo-random generation." print "Warning: If you want complete randomness consider other ways of Public/Private key pair generation.\n" print "Generating \"Generation\" Private Key..." gen_priv = SigningKey.generate(curve=SECP256k1) #Generate the "Generation" private key print "Saving to Generation_Private.pem file..." open("Generation_Private.pem", "w").write(gen_priv.to_pem()) #Saving to file print "Generating \"Generation\" Public Key..." gen_pub = gen_priv.get_verifying_key() #Generate the "Generation" public key from gen_priv print "Saving to Generation_Public.pem file..." open("Generation_Public.pem", "w").write(gen_pub.to_pem()) #Saving to file gen_pub = gen_pub.to_string() keccak.update(gen_pub) gen_address = keccak.hexdigest()[24:] open("Gen_Address.txt", "w").write("0x" + gen_address) print "Generating \"Certificate\" Private Key..." cert_priv = SigningKey.generate(curve=SECP256k1) #Generate the "Certificate" private key print "Saving to Certificate_Private.pem file..." open("Certificate_Private.pem", "w").write(cert_priv.to_pem()) #Saving to file print "Generating \"Certificate\" Public Key..." cert_pub = cert_priv.get_verifying_key() #Generate the "Certificate" public key from cert_priv print "Saving to Certificate_Public.pem file..." open("Certificate_Public.pem", "w").write(cert_pub.to_pem()) #Saving to file cert_pub = cert_pub.to_string() keccak.update(cert_pub) cert_address = keccak.hexdigest()[24:] open("Cert_Address.txt", "w").write("0x" + cert_address) print "Generating \"Revocation\" Private Key..." rev_priv = SigningKey.generate(curve=SECP256k1) #Generate the "Revocation" private key print "Saving to Revocation_Private.pem file..." open("Revocation_Private.pem", "w").write(rev_priv.to_pem()) #Saving to file print "Generating \"Revocation\" Public Key..." rev_pub = rev_priv.get_verifying_key() #Generate the "Revocation" public key from rev_priv print "Saving to Revocation_Public.pem file..." open("Revocation_Public.pem", "w").write(rev_pub.to_pem()) #Saving to file rev_pub = rev_pub.to_string() keccak.update(rev_pub) rev_address = keccak.hexdigest()[24:] open("Rev_Address.txt", "w").write("0x" + rev_address) print "\nYour addresses are:" print "\nGeneration Address: 0x" + gen_address print "\nCertificate Address: 0x" + cert_address print "\nRevocation Address: 0x" + rev_address os.system("echo 3 | keybase currency add --force " + cert_address + " >/dev/null 2>&1") #add cert address to keybase account - (todo) print "\nCertificate address added to your keybase.io account.\n" print "\nPlease load your Generation and Revocation addresses with some ether." print "\nWarning: Please keep your Revocation address secret!" ans = raw_input("Do you want to encrypt your private key files? [Y]es [N]o, default: [Y]") if ans == "Y" or ans == "y" or ans == "" or ans == " ": password = getpass.getpass("Give a strong password: "******"Generation_Private.pem") os.remove("Generation_Private.pem") encrypt_file(key, "Certificate_Private.pem") os.remove("Certificate_Private.pem") encrypt_file(key, "Revocation_Private.pem") os.remove("Revocation_Private.pem") sys.exit() else: sys.exit()
def get_eth_addr(pk): pub_key = pk.to_string() m = keccak_256() m.update(pub_key) return m.hexdigest()[24:]
def hash_of_point(p): hasher = sha3.keccak_256() hasher.update(int_to_bytes32(p[0].n)) hasher.update(int_to_bytes32(p[1].n)) x = bytes_to_int(hasher.digest()) return x
def auth_view(request): """ This view handle all authentication-related logic """ response_data = {} if request.method == 'GET': # Obtain authentication information - `is_authenticated`, `username`, `nonce` response_data.update( {'is_authenticated': request.user.is_authenticated}) if request.user.is_authenticated: response_data.update({'username': request.user.username}) else: nonce = ''.join( random.choice(settings.AUTH_NONCE_CHOICES) for _ in range(settings.AUTH_NONCE_LENGTH)) response_data.update({'nonce': nonce}) request.session['login_nonce'] = nonce elif request.method == 'POST': if settings.DEBUG: # pragma: no cover # Allow username/password auth in debug mode if 'username' in request.data and 'password' in request.data: username = request.data['username'] password = request.data['password'] user = get_object_or_404(User, username=username) if user.check_password(password): login(request, user, backend="django.contrib.auth.backends.ModelBackend") response_data.update( {'is_authenticated': request.user.is_authenticated}) response_data.update({'username': request.user.username}) return Response(data=response_data, status=status.HTTP_200_OK) # Authenticate user by signed `nonce` == `user_signature` and verify against `user_address` login_nonce = request.session.pop('login_nonce', None) if not login_nonce: return Response( data={ "login_nonce": "Session id doesn't have a `login_nonce`" }, status=status.HTTP_400_BAD_REQUEST, ) else: user_address = request.data.get('user_address') if not user_address: return Response( data={ "user_address": "Request doesn't have a `user_address`" }, status=status.HTTP_400_BAD_REQUEST, ) user_signature = request.data.get('user_signature') if not user_signature: return Response( data={ "user_signature": "Request doesn't have a `user_signature`" }, status=status.HTTP_400_BAD_REQUEST, ) # Start the sign-up process seed = "\x19Ethereum Signed Message:\n" + str( len(login_nonce)) + login_nonce buffered_hashed_msg = ethereum.utils.sha3(seed) vrs = utils.sig_to_vrs(user_signature) recovered_addr = '0x' + sha3.keccak_256( ethereum.utils.ecrecover_to_pub(buffered_hashed_msg, * vrs)).hexdigest()[24:] if not recovered_addr == user_address: return Response( data={ "user_signature": "User signature doesn't match `user_address`" }, status=status.HTTP_400_BAD_REQUEST, ) user, created = User.objects.get_or_create( username=recovered_addr, ) login(request, user, backend="django.contrib.auth.backends.ModelBackend") response_data.update( {'is_authenticated': request.user.is_authenticated}) response_data.update({'username': request.user.username}) response_data.update({'created': created}) return Response(data=response_data, status=status.HTTP_200_OK)
def hash_of_int(i): hasher = sha3.keccak_256(int_to_bytes32(i)) x = bytes_to_int(hasher.digest()) return x
def public_key_to_ethereum_address(public_key): public_key = Bip32Keys.to_uncompressed_public_key(public_key)[2:] # drop pub key version byte k = sha3.keccak_256() k.update(decode_hex(public_key)[0]) hash = k.hexdigest() return hash[24:]
#coding:utf-8 import sha3 import binascii from ecdsa import SigningKey, SECP256k1 priv = SigningKey.generate(curve=SECP256k1) #生成私钥 pub = priv.get_verifying_key() #生成公钥 keccak = sha3.keccak_256() keccak.update( pub.to_string()) #keccak_256哈希运算 address = "0x" + keccak.hexdigest()[24:] priv_key = binascii.hexlify( priv.to_string()) pub_key = binascii.hexlify( pub.to_string()) print("Private key: " + priv_key.decode() ) print("Public key: " + pub_key.decode() ) print("Address: " + address) print "#############################" _openssl_pub_key = "04d061e9c5891f579fd548cfd22ff29f5c642714cc7e7a9215f0071ef5a5723f691757b28e31be71f09f24673eed52348e58d53bcfd26f4d96ec6bf1489eab429d" _pub_key = _openssl_pub_key[2:] _pub_hex = binascii.unhexlify(_pub_key) keccak = sha3.keccak_256() keccak.update(_pub_hex) address = "0x" + keccak.hexdigest()[24:]
def generateID(self): k = keccak_256() k.update(unhexlify(self.question_id[2:]) + bytes(self.block_id)) self.event_id = "0x" + k.hexdigest()
def RingHashFunction(msgHash, point): hasher = sha3.keccak_256() hasher.update(msgHash) hasher.update(int_to_bytes32(point[0].n)) hasher.update(int_to_bytes32(point[1].n)) return bytes_to_int(hasher.digest())