tremove function H256 - electrum - Electrum Bitcoin wallet
HTML git clone https://git.parazyd.org/electrum
DIR Log
DIR Files
DIR Refs
DIR Submodules
---
DIR commit f6763b60846442433ce8ec08f45b88239f56b354
DIR parent 762dea6593779e25c12419998e5290aed5dbe656
HTML Author: SomberNight <somber.night@protonmail.com>
Date: Mon, 28 May 2018 13:03:30 +0200
remove function H256
Diffstat:
M lib/lnbase.py | 26 +++++++++++++-------------
1 file changed, 13 insertions(+), 13 deletions(-)
---
DIR diff --git a/lib/lnbase.py b/lib/lnbase.py
t@@ -30,6 +30,7 @@ from .bitcoin import (deserialize_privkey, rev_hex, int_to_hex,
from . import bitcoin
from . import ecc
from . import crypto
+from .crypto import sha256
from . import constants
from . import transaction
from .util import PrintError, bh2u, print_error, bfh, profiler, xor_bytes
t@@ -185,22 +186,21 @@ def gen_msg(msg_type, **kwargs):
data += param
return data
-def H256(data):
- return hashlib.sha256(data).digest()
class HandshakeState(object):
prologue = b"lightning"
protocol_name = b"Noise_XK_secp256k1_ChaChaPoly_SHA256"
handshake_version = b"\x00"
+
def __init__(self, responder_pub):
self.responder_pub = responder_pub
- self.h = H256(self.protocol_name)
+ self.h = sha256(self.protocol_name)
self.ck = self.h
self.update(self.prologue)
self.update(self.responder_pub)
def update(self, data):
- self.h = H256(self.h + data)
+ self.h = sha256(self.h + data)
return self.h
def get_nonce_bytes(n):
t@@ -240,7 +240,7 @@ def get_bolt8_hkdf(salt, ikm):
def get_ecdh(priv: bytes, pub: bytes) -> bytes:
pt = ecc.ECPubkey(pub) * string_to_number(priv)
- return H256(pt.get_public_key_bytes())
+ return sha256(pt.get_public_key_bytes())
def act1_initiator_message(hs, my_privkey):
#Get a new ephemeral key
t@@ -289,7 +289,7 @@ def aiosafe(f):
return f2
def get_obscured_ctn(ctn, local, remote):
- mask = int.from_bytes(H256(local + remote)[-6:], 'big')
+ mask = int.from_bytes(sha256(local + remote)[-6:], 'big')
return ctn ^ mask
def secret_to_pubkey(secret):
t@@ -297,19 +297,19 @@ def secret_to_pubkey(secret):
return point_to_ser(SECP256k1.generator * secret)
def derive_pubkey(basepoint, per_commitment_point):
- p = ecc.ECPubkey(basepoint) + ecc.generator() * ecc.string_to_number(bitcoin.sha256(per_commitment_point + basepoint))
+ p = ecc.ECPubkey(basepoint) + ecc.generator() * ecc.string_to_number(sha256(per_commitment_point + basepoint))
return p.get_public_key_bytes()
def derive_privkey(secret, per_commitment_point):
assert type(secret) is int
basepoint = point_to_ser(SECP256k1.generator * secret)
- basepoint = secret + ecc.string_to_number(bitcoin.sha256(per_commitment_point + basepoint))
+ basepoint = secret + ecc.string_to_number(sha256(per_commitment_point + basepoint))
basepoint %= SECP256k1.order
return basepoint
def derive_blinded_pubkey(basepoint, per_commitment_point):
- k1 = ecc.ECPubkey(basepoint) * ecc.string_to_number(bitcoin.sha256(basepoint + per_commitment_point))
- k2 = ecc.ECPubkey(per_commitment_point) * ecc.string_to_number(bitcoin.sha256(per_commitment_point + basepoint))
+ k1 = ecc.ECPubkey(basepoint) * ecc.string_to_number(sha256(basepoint + per_commitment_point))
+ k2 = ecc.ECPubkey(per_commitment_point) * ecc.string_to_number(sha256(per_commitment_point + basepoint))
return (k1 + k2).get_public_key_bytes()
def shachain_derive(element, toIndex):
t@@ -323,7 +323,7 @@ def get_per_commitment_secret_from_seed(seed: bytes, i: int, bits: int = 48) ->
mask = 1 << bitindex
if i & mask:
per_commitment_secret[bitindex // 8] ^= 1 << (bitindex % 8)
- per_commitment_secret = bytearray(bitcoin.sha256(per_commitment_secret))
+ per_commitment_secret = bytearray(sha256(per_commitment_secret))
bajts = bytes(per_commitment_secret)
return bajts
t@@ -1652,7 +1652,7 @@ def get_shared_secrets_along_route(payment_path_pubkeys: Sequence[bytes],
for i in range(0, num_hops):
hop_shared_secrets[i] = get_ecdh(ephemeral_key, payment_path_pubkeys[i])
ephemeral_pubkey = ecc.ECPrivkey(ephemeral_key).get_public_key_bytes()
- blinding_factor = H256(ephemeral_pubkey + hop_shared_secrets[i])
+ blinding_factor = sha256(ephemeral_pubkey + hop_shared_secrets[i])
blinding_factor_int = int.from_bytes(blinding_factor, byteorder="big")
ephemeral_key_int = int.from_bytes(ephemeral_key, byteorder="big")
ephemeral_key_int = ephemeral_key_int * blinding_factor_int % SECP256k1.order
t@@ -1733,7 +1733,7 @@ def process_onion_packet(onion_packet: OnionPacket, associated_data: bytes,
next_hops_data = xor_bytes(padded_header, stream_bytes)
# calc next ephemeral key
- blinding_factor = H256(onion_packet.public_key + shared_secret)
+ blinding_factor = sha256(onion_packet.public_key + shared_secret)
blinding_factor_int = int.from_bytes(blinding_factor, byteorder="big")
next_public_key_int = ecc.ECPubkey(onion_packet.public_key) * blinding_factor_int
next_public_key = next_public_key_int.get_public_key_bytes()