ethereum / pydevp2p / 48

pending completion

Build # 48

Build Type

push

travis-ci

Committed by

konradkonrad

Commit Message

Fix queue-methods in test

Prior to bbd6aceae MultiplexedSession
had specific methods to read message and packet queues. Since they
are no longer there, I adjusted the tests.

Run Details

1725 of 2085 relevant lines covered (82.73%)

0.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.84

/devp2p/crypto.py

#!/usr/bin/python
CIPHERNAMES = set(('aes-128-ctr',))

import os
import sys
if sys.platform not in ('darwin',):
    import pyelliptic
else:
    # FIX PATH ON OS X ()
    # https://github.com/yann2192/pyelliptic/issues/11
    _openssl_lib_paths = ['/usr/local/Cellar/openssl/']
    for p in _openssl_lib_paths:
        if os.path.exists(p):
            p = os.path.join(p, os.listdir(p)[-1], 'lib')
            os.environ['DYLD_LIBRARY_PATH'] = p
            import pyelliptic
            if CIPHERNAMES.issubset(set(pyelliptic.Cipher.get_all_cipher())):
                break
if 'pyelliptic' not in dir() or not CIPHERNAMES.issubset(set(pyelliptic.Cipher.get_all_cipher())):
    print 'required ciphers %r not available in openssl library' % CIPHERNAMES
    if sys.platform == 'darwin':
        print 'use homebrew or macports to install newer openssl'
        print '> brew install openssl / > sudo port install openssl'
    sys.exit(1)

import bitcoin
from sha3 import sha3_256
from hashlib import sha256
import struct
import random
import devp2p.utils as utils
try:
    from ecdsa_recover import ecdsa_raw_sign, ecdsa_raw_verify, ecdsa_raw_recover
    from ecdsa_recover import ecdsa_sign, ecdsa_verify
except:
    ecdsa_raw_sign = bitcoin.ecdsa_raw_sign
    ecdsa_raw_verify = bitcoin.ecdsa_raw_verify
    ecdsa_raw_recover = bitcoin.ecdsa_raw_recover
    ecdsa_sign = bitcoin.ecdsa_sign
    ecdsa_verify = bitcoin.ecdsa_verify

hmac_sha256 = pyelliptic.hmac_sha256


class ECIESDecryptionError(Exception):
    pass


class ECCx(pyelliptic.ECC):

    """
    Modified to work with raw_pubkey format used in RLPx
    and binding default curve and cipher
    """
    ecies_ciphername = 'aes-128-ctr'
    curve = 'secp256k1'
    ecies_encrypt_overhead_length = 113

    def __init__(self, raw_pubkey=None, raw_privkey=None):
        if raw_privkey:
            assert not raw_pubkey
            raw_pubkey = privtopub(raw_privkey)
        if raw_pubkey:
            assert len(raw_pubkey) == 64
            _, pubkey_x, pubkey_y, _ = self._decode_pubkey(raw_pubkey)
        else:
            pubkey_x, pubkey_y = None, None
        while True:
            pyelliptic.ECC.__init__(self, pubkey_x=pubkey_x, pubkey_y=pubkey_y,
                                    raw_privkey=raw_privkey, curve=self.curve)
            try:
                if self.raw_privkey:
                    bitcoin.get_privkey_format(self.raw_privkey)  # failed for some keys
                valid_priv_key = True
            except AssertionError:
                valid_priv_key = False
            if len(self.raw_pubkey) == 64 and valid_priv_key:
                break
            elif raw_privkey or raw_pubkey:
                raise Exception('invalid priv or pubkey')

        assert len(self.raw_pubkey) == 64

    @property
    def raw_pubkey(self):
        return self.pubkey_x + self.pubkey_y

    @classmethod
    def _decode_pubkey(cls, raw_pubkey):
        assert len(raw_pubkey) == 64
        pubkey_x = raw_pubkey[:32]
        pubkey_y = raw_pubkey[32:]
        return cls.curve, pubkey_x, pubkey_y, 64

    def get_ecdh_key(self, raw_pubkey):
        "Compute public key with the local private key and returns a 256bits shared key"
        _, pubkey_x, pubkey_y, _ = self._decode_pubkey(raw_pubkey)
        key = self.raw_get_ecdh_key(pubkey_x, pubkey_y)
        assert len(key) == 32
        return key

    @property
    def raw_privkey(self):
        return self.privkey

    def is_valid_key(self, raw_pubkey, raw_privkey=None):
        try:
            assert len(raw_pubkey) == 64
            failed = bool(self.raw_check_key(raw_privkey, raw_pubkey[:32], raw_pubkey[32:]))
        except (AssertionError, Exception):
            failed = True
        return not failed

    @classmethod
    def ecies_encrypt(cls, data, raw_pubkey):
        """
        ECIES Encrypt, where P = recipient public key is:
        1) generate r = random value
        2) generate shared-secret = kdf( ecdhAgree(r, P) )
        3) generate R = rG [same op as generating a public key]
        4) send 0x04 || R || AsymmetricEncrypt(shared-secret, plaintext) || tag


        currently used by go:
        ECIES_AES128_SHA256 = &ECIESParams{
            Hash: sha256.New,
            hashAlgo: crypto.SHA256,
            Cipher: aes.NewCipher,
            BlockSize: aes.BlockSize,
            KeyLen: 16,
            }

        """
        # 1) generate r = random value
        ephem = ECCx()

        # 2) generate shared-secret = kdf( ecdhAgree(r, P) )
        key_material = ephem.raw_get_ecdh_key(pubkey_x=raw_pubkey[:32], pubkey_y=raw_pubkey[32:])
        assert len(key_material) == 32
        key = eciesKDF(key_material, 32)
        assert len(key) == 32
        key_enc, key_mac = key[:16], key[16:]

        key_mac = sha256(key_mac).digest()  # !!!
        assert len(key_mac) == 32
        # 3) generate R = rG [same op as generating a public key]
        ephem_pubkey = ephem.raw_pubkey

        # encrypt
        iv = pyelliptic.Cipher.gen_IV(cls.ecies_ciphername)
        assert len(iv) == 16
        ctx = pyelliptic.Cipher(key_enc, iv, 1, cls.ecies_ciphername)
        ciphertext = ctx.ciphering(data)
        assert len(ciphertext) == len(data)

        # 4) send 0x04 || R || AsymmetricEncrypt(shared-secret, plaintext) || tag
        msg = chr(0x04) + ephem_pubkey + iv + ciphertext

        # the MAC of a message (called the tag) as per SEC 1, 3.5.
        tag = hmac_sha256(key_mac, msg[1 + 64:])
        assert len(tag) == 32
        msg += tag

        assert len(msg) == 1 + 64 + 16 + 32 + len(data) == 113 + len(data)
        assert len(msg) - cls.ecies_encrypt_overhead_length == len(data)
        return msg

    def ecies_decrypt(self, data):
        """
        Decrypt data with ECIES method using the local private key

        ECIES Decrypt (performed by recipient):
        1) generate shared-secret = kdf( ecdhAgree(myPrivKey, msg[1:65]) )
        2) verify tag
        3) decrypt

        ecdhAgree(r, recipientPublic) == ecdhAgree(recipientPrivate, R)
        [where R = r*G, and recipientPublic = recipientPrivate*G]

        """
        if data[0] != chr(0x04):
            raise ECIESDecryptionError("wrong ecies header")

        #  1) generate shared-secret = kdf( ecdhAgree(myPrivKey, msg[1:65]) )
        _shared = data[1:1 + 64]
        # FIXME, check that _shared_pub is a valid one (on curve)

        key_material = self.raw_get_ecdh_key(pubkey_x=_shared[:32], pubkey_y=_shared[32:])
        assert len(key_material) == 32
        key = eciesKDF(key_material, 32)
        assert len(key) == 32
        key_enc, key_mac = key[:16], key[16:]

        key_mac = sha256(key_mac).digest()
        assert len(key_mac) == 32

        tag = data[-32:]
        assert len(tag) == 32

        # 2) verify tag
        if not pyelliptic.equals(hmac_sha256(key_mac, data[1 + 64:- 32]), tag):
            raise ECIESDecryptionError("Fail to verify data")

        # 3) decrypt
        blocksize = pyelliptic.OpenSSL.get_cipher(self.ecies_ciphername).get_blocksize()
        iv = data[1 + 64:1 + 64 + blocksize]
        assert len(iv) == 16
        ciphertext = data[1 + 64 + blocksize:- 32]
        assert 1 + len(_shared) + len(iv) + len(ciphertext) + len(tag) == len(data)
        ctx = pyelliptic.Cipher(key_enc, iv, 0, self.ecies_ciphername)
        return ctx.ciphering(ciphertext)

    encrypt = ecies_encrypt
    decrypt = ecies_decrypt

    def sign(self, data):
        """
        pyelliptic.ECC.sign is DER-encoded
        https://bitcoin.stackexchange.com/questions/12554
        """
        signature = ecdsa_sign(data, self.raw_privkey)
        assert len(signature) == 65
        return signature

    def verify(self, signature, message):
        assert len(signature) == 65
        return ecdsa_verify(self.raw_pubkey, signature, message)


def lzpad32(x):
    return '\x00' * (32 - len(x)) + x


def _encode_sig(v, r, s):
    assert isinstance(v, (int, long))
    assert v in (27, 28)
    vb, rb, sb = chr(v - 27), bitcoin.encode(r, 256), bitcoin.encode(s, 256)
    return lzpad32(rb) + lzpad32(sb) + vb


def _decode_sig(sig):
    return ord(sig[64]) + 27, bitcoin.decode(sig[0:32], 256), bitcoin.decode(sig[32:64], 256)


def ecdsa_verify(pubkey, signature, message):
    assert len(signature) == 65
    assert len(pubkey) == 64
    return ecdsa_raw_verify(message, _decode_sig(signature), pubkey)
verify = ecdsa_verify


def ecdsa_sign(message, privkey):
    s = _encode_sig(*ecdsa_raw_sign(message, privkey))
    return s

sign = ecdsa_sign


def ecdsa_recover(message, signature):
    assert len(signature) == 65
    pub = ecdsa_raw_recover(message, _decode_sig(signature))
    assert pub, 'pubkey could not be recovered'
    pub = bitcoin.encode_pubkey(pub, 'bin_electrum')
    assert len(pub) == 64
    return pub
recover = ecdsa_recover


def sha3(seed):
    return sha3_256(seed).digest()


def mk_privkey(seed):
    return sha3(seed)


def privtopub(raw_privkey):
    raw_pubkey = bitcoin.encode_pubkey(bitcoin.privtopub(raw_privkey), 'bin_electrum')
    assert len(raw_pubkey) == 64
    return raw_pubkey


def encrypt(data, raw_pubkey):
    """
    Encrypt data with ECIES method using the public key of the recipient.
    """
    assert len(raw_pubkey) == 64, 'invalid pubkey of len {}'.format(len(raw_pubkey))
    return ECCx.encrypt(data, raw_pubkey)


def eciesKDF(key_material, key_len):
    """
    interop w/go ecies implementation

    for sha3, blocksize is 136 bytes
    for sha256, blocksize is 64 bytes

    NIST SP 800-56a Concatenation Key Derivation Function (see section 5.8.1).
    """
    s1 = ""
    key = ""
    hash_blocksize = 64
    reps = ((key_len + 7) * 8) / (hash_blocksize * 8)
    counter = 0
    while counter <= reps:
        counter += 1
        ctx = sha256()
        ctx.update(struct.pack('>I', counter))
        ctx.update(key_material)
        ctx.update(s1)
        key += ctx.digest()
    return key[:key_len]

1	#!/usr/bin/python
2	CIPHERNAMES = set(('aes-128-ctr',))	1✔
3
4	import os	1✔
5	import sys	1✔
6	if sys.platform not in ('darwin',):	1✔
7	import pyelliptic	1✔
8	else:
9	# FIX PATH ON OS X ()
10	# https://github.com/yann2192/pyelliptic/issues/11
11	_openssl_lib_paths = ['/usr/local/Cellar/openssl/']	×
12	for p in _openssl_lib_paths:	×
13	if os.path.exists(p):	×
14	p = os.path.join(p, os.listdir(p)[-1], 'lib')	×
15	os.environ['DYLD_LIBRARY_PATH'] = p	×
16	import pyelliptic	×
17	if CIPHERNAMES.issubset(set(pyelliptic.Cipher.get_all_cipher())):	×
18	break	×
19	if 'pyelliptic' not in dir() or not CIPHERNAMES.issubset(set(pyelliptic.Cipher.get_all_cipher())):	1✔
20	print 'required ciphers %r not available in openssl library' % CIPHERNAMES	×
21	if sys.platform == 'darwin':	×
22	print 'use homebrew or macports to install newer openssl'	×
23	print '> brew install openssl / > sudo port install openssl'	×
24	sys.exit(1)	×
25
26	import bitcoin	1✔
27	from sha3 import sha3_256	1✔
28	from hashlib import sha256	1✔
29	import struct	1✔
30	import random	1✔
31	import devp2p.utils as utils	1✔
32	try:	1✔
33	from ecdsa_recover import ecdsa_raw_sign, ecdsa_raw_verify, ecdsa_raw_recover	1✔
34	from ecdsa_recover import ecdsa_sign, ecdsa_verify	×
35	except:	1✔
36	ecdsa_raw_sign = bitcoin.ecdsa_raw_sign	1✔
37	ecdsa_raw_verify = bitcoin.ecdsa_raw_verify	1✔
38	ecdsa_raw_recover = bitcoin.ecdsa_raw_recover	1✔
39	ecdsa_sign = bitcoin.ecdsa_sign	1✔
40	ecdsa_verify = bitcoin.ecdsa_verify	1✔
41
42	hmac_sha256 = pyelliptic.hmac_sha256	1✔
43
44
45	class ECIESDecryptionError(Exception):	1✔
46	pass	1✔
47
48
49	class ECCx(pyelliptic.ECC):	1✔
50
51	"""
52	Modified to work with raw_pubkey format used in RLPx
53	and binding default curve and cipher
54	"""
55	ecies_ciphername = 'aes-128-ctr'	1✔
56	curve = 'secp256k1'	1✔
57	ecies_encrypt_overhead_length = 113	1✔
58
59	def __init__(self, raw_pubkey=None, raw_privkey=None):	1✔
60	if raw_privkey:	1✔
61	assert not raw_pubkey	1✔
62	raw_pubkey = privtopub(raw_privkey)	1✔
63	if raw_pubkey:	1✔
64	assert len(raw_pubkey) == 64	1✔
65	_, pubkey_x, pubkey_y, _ = self._decode_pubkey(raw_pubkey)	1✔
66	else:
67	pubkey_x, pubkey_y = None, None	1✔
68	while True:	1✔
69	pyelliptic.ECC.__init__(self, pubkey_x=pubkey_x, pubkey_y=pubkey_y,	1✔
70	raw_privkey=raw_privkey, curve=self.curve)
71	try:	1✔
72	if self.raw_privkey:	1✔
73	bitcoin.get_privkey_format(self.raw_privkey) # failed for some keys	1✔
74	valid_priv_key = True	1✔
75	except AssertionError:	×
76	valid_priv_key = False	×
77	if len(self.raw_pubkey) == 64 and valid_priv_key:	1✔
78	break	1✔
79	elif raw_privkey or raw_pubkey:	1✔
80	raise Exception('invalid priv or pubkey')	×
81
82	assert len(self.raw_pubkey) == 64	1✔
83
84	@property	1✔
85	def raw_pubkey(self):
86	return self.pubkey_x + self.pubkey_y	1✔
87
88	@classmethod	1✔
89	def _decode_pubkey(cls, raw_pubkey):
90	assert len(raw_pubkey) == 64	1✔
91	pubkey_x = raw_pubkey[:32]	1✔
92	pubkey_y = raw_pubkey[32:]	1✔
93	return cls.curve, pubkey_x, pubkey_y, 64	1✔
94
95	def get_ecdh_key(self, raw_pubkey):	1✔
96	"Compute public key with the local private key and returns a 256bits shared key"
97	_, pubkey_x, pubkey_y, _ = self._decode_pubkey(raw_pubkey)	1✔
98	key = self.raw_get_ecdh_key(pubkey_x, pubkey_y)	1✔
99	assert len(key) == 32	1✔
100	return key	1✔
101
102	@property	1✔
103	def raw_privkey(self):
104	return self.privkey	1✔
105
106	def is_valid_key(self, raw_pubkey, raw_privkey=None):	1✔
107	try:	1✔
108	assert len(raw_pubkey) == 64	1✔
109	failed = bool(self.raw_check_key(raw_privkey, raw_pubkey[:32], raw_pubkey[32:]))	1✔
110	except (AssertionError, Exception):	1✔
111	failed = True	1✔
112	return not failed	1✔
113
114	@classmethod	1✔
115	def ecies_encrypt(cls, data, raw_pubkey):
116	"""
117	ECIES Encrypt, where P = recipient public key is:
118	1) generate r = random value
119	2) generate shared-secret = kdf( ecdhAgree(r, P) )
120	3) generate R = rG [same op as generating a public key]
121	4) send 0x04 \|\| R \|\| AsymmetricEncrypt(shared-secret, plaintext) \|\| tag
122
123
124	currently used by go:
125	ECIES_AES128_SHA256 = &ECIESParams{
126	Hash: sha256.New,
127	hashAlgo: crypto.SHA256,
128	Cipher: aes.NewCipher,
129	BlockSize: aes.BlockSize,
130	KeyLen: 16,
131	}
132
133	"""
134	# 1) generate r = random value
135	ephem = ECCx()	1✔
136
137	# 2) generate shared-secret = kdf( ecdhAgree(r, P) )
138	key_material = ephem.raw_get_ecdh_key(pubkey_x=raw_pubkey[:32], pubkey_y=raw_pubkey[32:])	1✔
139	assert len(key_material) == 32	1✔
140	key = eciesKDF(key_material, 32)	1✔
141	assert len(key) == 32	1✔
142	key_enc, key_mac = key[:16], key[16:]	1✔
143
144	key_mac = sha256(key_mac).digest() # !!!	1✔
145	assert len(key_mac) == 32	1✔
146	# 3) generate R = rG [same op as generating a public key]
147	ephem_pubkey = ephem.raw_pubkey	1✔
148
149	# encrypt
150	iv = pyelliptic.Cipher.gen_IV(cls.ecies_ciphername)	1✔
151	assert len(iv) == 16	1✔
152	ctx = pyelliptic.Cipher(key_enc, iv, 1, cls.ecies_ciphername)	1✔
153	ciphertext = ctx.ciphering(data)	1✔
154	assert len(ciphertext) == len(data)	1✔
155
156	# 4) send 0x04 \|\| R \|\| AsymmetricEncrypt(shared-secret, plaintext) \|\| tag
157	msg = chr(0x04) + ephem_pubkey + iv + ciphertext	1✔
158
159	# the MAC of a message (called the tag) as per SEC 1, 3.5.
160	tag = hmac_sha256(key_mac, msg[1 + 64:])	1✔
161	assert len(tag) == 32	1✔
162	msg += tag	1✔
163
164	assert len(msg) == 1 + 64 + 16 + 32 + len(data) == 113 + len(data)	1✔
165	assert len(msg) - cls.ecies_encrypt_overhead_length == len(data)	1✔
166	return msg	1✔
167
168	def ecies_decrypt(self, data):	1✔
169	"""
170	Decrypt data with ECIES method using the local private key
171
172	ECIES Decrypt (performed by recipient):
173	1) generate shared-secret = kdf( ecdhAgree(myPrivKey, msg[1:65]) )
174	2) verify tag
175	3) decrypt
176
177	ecdhAgree(r, recipientPublic) == ecdhAgree(recipientPrivate, R)
178	[where R = rG, and recipientPublic = recipientPrivateG]
179
180	"""
181	if data[0] != chr(0x04):	1✔
182	raise ECIESDecryptionError("wrong ecies header")	×
183
184	# 1) generate shared-secret = kdf( ecdhAgree(myPrivKey, msg[1:65]) )
185	_shared = data[1:1 + 64]	1✔
186	# FIXME, check that _shared_pub is a valid one (on curve)
187
188	key_material = self.raw_get_ecdh_key(pubkey_x=_shared[:32], pubkey_y=_shared[32:])	1✔
189	assert len(key_material) == 32	1✔
190	key = eciesKDF(key_material, 32)	1✔
191	assert len(key) == 32	1✔
192	key_enc, key_mac = key[:16], key[16:]	1✔
193
194	key_mac = sha256(key_mac).digest()	1✔
195	assert len(key_mac) == 32	1✔
196
197	tag = data[-32:]	1✔
198	assert len(tag) == 32	1✔
199
200	# 2) verify tag
201	if not pyelliptic.equals(hmac_sha256(key_mac, data[1 + 64:- 32]), tag):	1✔
202	raise ECIESDecryptionError("Fail to verify data")	×
203
204	# 3) decrypt
205	blocksize = pyelliptic.OpenSSL.get_cipher(self.ecies_ciphername).get_blocksize()	1✔
206	iv = data[1 + 64:1 + 64 + blocksize]	1✔
207	assert len(iv) == 16	1✔
208	ciphertext = data[1 + 64 + blocksize:- 32]	1✔
209	assert 1 + len(_shared) + len(iv) + len(ciphertext) + len(tag) == len(data)	1✔
210	ctx = pyelliptic.Cipher(key_enc, iv, 0, self.ecies_ciphername)	1✔
211	return ctx.ciphering(ciphertext)	1✔
212
213	encrypt = ecies_encrypt	1✔
214	decrypt = ecies_decrypt	1✔
215
216	def sign(self, data):	1✔
217	"""
218	pyelliptic.ECC.sign is DER-encoded
219	https://bitcoin.stackexchange.com/questions/12554
220	"""
221	signature = ecdsa_sign(data, self.raw_privkey)	1✔
222	assert len(signature) == 65	1✔
223	return signature	1✔
224
225	def verify(self, signature, message):	1✔
226	assert len(signature) == 65	1✔
227	return ecdsa_verify(self.raw_pubkey, signature, message)	1✔
228
229
230	def lzpad32(x):	1✔
231	return '\x00' * (32 - len(x)) + x	1✔
232
233
234	def _encode_sig(v, r, s):	1✔
235	assert isinstance(v, (int, long))	1✔
236	assert v in (27, 28)	1✔
237	vb, rb, sb = chr(v - 27), bitcoin.encode(r, 256), bitcoin.encode(s, 256)	1✔
238	return lzpad32(rb) + lzpad32(sb) + vb	1✔
239
240
241	def _decode_sig(sig):	1✔
242	return ord(sig[64]) + 27, bitcoin.decode(sig[0:32], 256), bitcoin.decode(sig[32:64], 256)	1✔
243
244
245	def ecdsa_verify(pubkey, signature, message):	1✔
246	assert len(signature) == 65	1✔
247	assert len(pubkey) == 64	1✔
248	return ecdsa_raw_verify(message, _decode_sig(signature), pubkey)	1✔
249	verify = ecdsa_verify	1✔
250
251
252	def ecdsa_sign(message, privkey):	1✔
253	s = _encode_sig(*ecdsa_raw_sign(message, privkey))	1✔
254	return s	1✔
255
256	sign = ecdsa_sign	1✔
257
258
259	def ecdsa_recover(message, signature):	1✔
260	assert len(signature) == 65	1✔
261	pub = ecdsa_raw_recover(message, _decode_sig(signature))	1✔
262	assert pub, 'pubkey could not be recovered'	1✔
263	pub = bitcoin.encode_pubkey(pub, 'bin_electrum')	1✔
264	assert len(pub) == 64	1✔
265	return pub	1✔
266	recover = ecdsa_recover	1✔
267
268
269	def sha3(seed):	1✔
270	return sha3_256(seed).digest()	1✔
271
272
273	def mk_privkey(seed):	1✔
274	return sha3(seed)	1✔
275
276
277	def privtopub(raw_privkey):	1✔
278	raw_pubkey = bitcoin.encode_pubkey(bitcoin.privtopub(raw_privkey), 'bin_electrum')	1✔
279	assert len(raw_pubkey) == 64	1✔
280	return raw_pubkey	1✔
281
282
283	def encrypt(data, raw_pubkey):	1✔
284	"""
285	Encrypt data with ECIES method using the public key of the recipient.
286	"""
287	assert len(raw_pubkey) == 64, 'invalid pubkey of len {}'.format(len(raw_pubkey))	1✔
288	return ECCx.encrypt(data, raw_pubkey)	1✔
289
290
291	def eciesKDF(key_material, key_len):	1✔
292	"""
293	interop w/go ecies implementation
294
295	for sha3, blocksize is 136 bytes
296	for sha256, blocksize is 64 bytes
297
298	NIST SP 800-56a Concatenation Key Derivation Function (see section 5.8.1).
299	"""
300	s1 = ""	1✔
301	key = ""	1✔
302	hash_blocksize = 64	1✔
303	reps = ((key_len + 7) * 8) / (hash_blocksize * 8)	1✔
304	counter = 0	1✔
305	while counter <= reps:	1✔
306	counter += 1	1✔
307	ctx = sha256()	1✔
308	ctx.update(struct.pack('>I', counter))	1✔
309	ctx.update(key_material)	1✔
310	ctx.update(s1)	1✔
311	key += ctx.digest()	1✔
312	return key[:key_len]	1✔

ethereum / pydevp2p / 48

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous