def recover_sender(self):
if self.v:
if self.r >= N or self.s >= P or self.v < 27 or self.v > 28 \
or self.r == 0 or self.s == 0:
raise InvalidSignature()
rlpdata = rlp.encode(self, self.__class__.exclude(['v', 'r', 's']))
rawhash = sha3(rlpdata)
pk = PublicKey(flags=ALL_FLAGS)
try:
pk.public_key = pk.ecdsa_recover(
rawhash,
pk.ecdsa_recoverable_deserialize(
zpad(
"".join(
chr(c)
for c in int_to_32bytearray(self.r)), 32) +
zpad(
"".join(
chr(c)
for c in int_to_32bytearray(self.s)), 32),
self.v - 27),
raw=True)
pub = pk.serialize(compressed=False)
except Exception:
raise InvalidSignature()
if pub[1:] == "\x00" * 32:
raise InvalidSignature()
pub = encode_pubkey(pub, 'bin')
return sha3(pub[1:])[-20:]
def recover_sender(self):
if self.v:
if self.r >= N or self.s >= P or self.v < 27 or self.v > 28 \
or self.r == 0 or self.s == 0:
raise InvalidSignature()
rlpdata = rlp.encode(self, self.__class__.exclude(['v', 'r', 's']))
rawhash = sha3(rlpdata)
pub = ecdsa_raw_recover(rawhash, (self.v, self.r, self.s))
if pub is False or pub == (0, 0):
raise InvalidSignature()
pub = encode_pubkey(pub, 'bin')
return sha3(pub[1:])[-20:]
def recover_sender(self):
if self.v:
if self.r >= N or self.s >= P or self.v < 27 or self.v > 28 \
or self.r == 0 or self.s == 0:
raise InvalidSignature()
rlpdata = rlp.encode(self, self.__class__.exclude(['v', 'r', 's']))
rawhash = sha3(rlpdata)
pub = ecdsa_recover_raw(rawhash, (self.v, self.r, self.s))
if pub is False or pub == (0, 0):
raise InvalidSignature()
pub = encode_pubkey(pub, 'bin')
return sha3(pub[1:])[-20:]
def sign(self, privkey):
"""Sign this with a private key"""
if self.v:
raise InvalidSignature("already signed")
if privkey in (0, '', '\x00' * 32):
raise InvalidSignature("Zero privkey cannot sign")
rawhash = sha3(
rlp.encode(self, self.__class__.exclude(['v', 'r', 's'])))
if len(privkey) == 64:
privkey = encode_privkey(privkey, 'bin')
pk = PrivateKey(privkey, raw=True)
signature = pk.ecdsa_recoverable_serialize(
pk.ecdsa_sign_recoverable(rawhash, raw=True))
signature = signature[0] + chr(signature[1])
self.v = ord(signature[64]) + 27
self.r = big_endian_to_int(signature[0:32])
self.s = big_endian_to_int(signature[32:64])
self._sender = None
return self
def __init__(self,
height,
round,
block,
signing_lockset,
round_lockset=None,
v=0,
r=0,
s=0):
"""
if round == 0 the signing_lockset also proves,
that proposal is eligible and we need not round_lockset
"""
assert isinstance(block, (Block, TransientBlock))
assert isinstance(signing_lockset, LockSet)
assert round_lockset is None or isinstance(round_lockset, LockSet)
assert round >= 0
assert height > 0
if round > 0 and not round_lockset:
raise InvalidProposalError('R>0 needs a round lockset')
if round == 0 and round_lockset:
raise InvalidProposalError('R0 must not have a round lockset')
self.height = height
self.round = round
self.block = block
self.signing_lockset = signing_lockset
self.round_lockset = round_lockset or LockSet(0)
super(BlockProposal,
self).__init__(height, round, block, signing_lockset,
self.round_lockset, v, r, s)
if block.header.number != self.height:
raise InvalidProposalError(
'lockset.height / block.number mismatch')
if self.round_lockset and height != self.round_lockset.height:
raise InvalidProposalError('height mismatch')
if not (round > 0 or self.lockset.has_quorum):
raise InvalidProposalError(
'R0 lockset == signing lockset needs quorum')
if not (round > 0 or self.lockset.height == block.header.number - 1):
raise InvalidProposalError(
'R0 round lockset must be from previous height')
if not (round == 0 or round == self.lockset.round + 1):
raise InvalidProposalError(
'Rn round lockset must be from previous round')
if not self.signing_lockset.has_quorum:
raise InvalidProposalError('signing lockset needs quorum')
if not (self.signing_lockset.height == self.height - 1):
raise InvalidProposalError('signing lockset height mismatch')
if self.round_lockset and not round_lockset.has_noquorum:
raise InvalidProposalError(
'at R>0 can only propose if there is a NoQuorum for R-1')
self.rawhash = sha3(
rlp.encode(self, self.__class__.exclude(['v', 'r', 's'])))
if self.v: # validate sender == block.coinbase
assert self.sender
def hash(self):
"signatures are non deterministic"
if self.sender is None:
raise MissingSignatureError()
class HashSerializable(rlp.Serializable):
fields = [(field, sedes) for field, sedes in self.fields
if field not in ('v', 'r', 's')] + [('_sender', binary)]
_sedes = None
return sha3(rlp.encode(self, HashSerializable))
def sign(self, privkey):
"""Sign this with a private key"""
if self.v:
raise InvalidSignature("already signed")
if privkey in (0, '', '\x00' * 32):
raise InvalidSignature("Zero privkey cannot sign")
rawhash = sha3(rlp.encode(self, self.__class__.exclude(['v', 'r', 's'])))
self.v, self.r, self.s = ecdsa_raw_sign(rawhash, privkey)
self._sender = None
return self
def sign(self, privkey):
"""Sign this with a private key"""
if self.v:
raise InvalidSignature("already signed")
if privkey in (0, '', '\x00' * 32):
raise InvalidSignature("Zero privkey cannot sign")
rawhash = sha3(rlp.encode(self, self.__class__.exclude(['v', 'r', 's'])))
self.v, self.r, self.s = ecdsa_sign_raw(rawhash, privkey)
self._sender = None
return self
def sender(self):
# double check unmutable
assert self.rawhash == sha3(rlp.encode(self, self.__class__.exclude(['v', 'r', 's'])))
s = super(BlockProposal, self).sender
if not s:
raise InvalidProposalError('signature missing')
assert len(s) == 20
assert len(self.block.header.coinbase) == 20
if s != self.block.header.coinbase:
raise InvalidProposalError('signature does not match coinbase')
return s
def sender(self):
# double check unmutable
s = super(BlockProposal, self).sender
if not s:
raise InvalidProposalError('signature missing')
assert self.rawhash
assert self.v
_rawhash = sha3(rlp.encode(self, self.__class__.exclude(['v', 'r', 's'])))
assert self.rawhash == _rawhash
assert len(s) == 20
assert len(self.block.header.coinbase) == 20
if s != self.block.header.coinbase:
raise InvalidProposalError('signature does not match coinbase')
return s
def __init__(self, height, round, block, signing_lockset,
round_lockset=None, v=0, r=0, s=0):
"""
if round == 0 the signing_lockset also proves,
that proposal is eligible and we need not round_lockset
"""
assert isinstance(block, (Block, TransientBlock))
assert isinstance(signing_lockset, LockSet)
assert round_lockset is None or isinstance(round_lockset, LockSet)
assert round >= 0
assert height > 0
if round > 0 and not round_lockset:
raise InvalidProposalError('R>0 needs a round lockset')
if round == 0 and round_lockset:
raise InvalidProposalError('R0 must not have a round lockset')
self.height = height
self.round = round
self.block = block
self.signing_lockset = signing_lockset
self.round_lockset = round_lockset or LockSet(0)
super(BlockProposal, self).__init__(height, round, block, signing_lockset,
self.round_lockset, v, r, s)
if block.header.number != self.height:
raise InvalidProposalError('lockset.height / block.number mismatch')
if self.round_lockset and height != self.round_lockset.height:
raise InvalidProposalError('height mismatch')
if not (round > 0 or self.lockset.has_quorum):
raise InvalidProposalError('R0 lockset == signing lockset needs quorum')
if not (round > 0 or self.lockset.height == block.header.number - 1):
raise InvalidProposalError('R0 round lockset must be from previous height')
if not (round == 0 or round == self.lockset.round + 1):
raise InvalidProposalError('Rn round lockset must be from previous round')
if not self.signing_lockset.has_quorum:
raise InvalidProposalError('signing lockset needs quorum')
if not (self.signing_lockset.height == self.height - 1):
raise InvalidProposalError('signing lockset height mismatch')
if self.round_lockset and not round_lockset.has_noquorum:
raise InvalidProposalError('at R>0 can only propose if there is a NoQuorum for R-1')
self.rawhash = sha3(rlp.encode(self, self.__class__.exclude(['v', 'r', 's'])))
if self.v: # validate sender == block.coinbase
assert self.sender
def hash(self):
"""The binary block hash
This is equivalent to ``header.hash``.
"""
return sha3(rlp.encode(self.header))
def hash(self):
return sha3(rlp.encode(self))
def hash(self):
return sha3(rlp.encode(self))
def hash(self):
"""The binary block hash
This is equivalent to ``header.hash``.
"""
return sha3(rlp.encode(self.header))