def test_signature_aggregation(backend, msg, privkeys, domain):
bls.use(backend)
sigs = [bls.sign(msg, k, domain=domain) for k in privkeys]
pubs = [bls.privtopub(k) for k in privkeys]
aggsig = bls.aggregate_signatures(sigs)
aggpub = bls.aggregate_pubkeys(pubs)
assert bls.verify(msg, aggpub, aggsig, domain=domain)
def test_validate(backend):
bls.use(backend)
msg = b"\x32" * 32
privkey = 42
pubkey = bls.sk_to_pk(privkey)
sig = bls.sign(privkey, msg)
bls.validate(msg, sig, pubkey)
def run_with(_cls, inputs: SignatureData, _config: Optional[Eth2Config]) -> bool:
# BLS override
bls.use(MilagroBackend)
return bls.fast_aggregate_verify(
inputs["message"], inputs["signature"], *inputs["pubkeys"]
)
def run_with(
_cls, inputs: SequenceOfBLSSignature, _config: Optional[Eth2Config]
) -> BLSSignature:
# BLS override
bls.use(MilagroBackend)
return bls.aggregate(*inputs)
def test_bls_core_succeed(backend, privkey):
bls.use(backend)
domain = 0
msg = str(privkey).encode('utf-8')
sig = bls.sign(msg, privkey, domain=domain)
pub = bls.privtopub(privkey)
assert bls.verify(msg, pub, sig, domain=domain)
def test_invalid_private_key(backend, privkey, domain):
bls.use(backend)
msg = str(privkey).encode("utf-8")
with pytest.raises(ValueError):
bls.privtopub(privkey)
with pytest.raises(ValueError):
bls.sign(msg, privkey, domain=domain)
def run_with(
_cls, inputs: SignatureData, _config: Optional[Eth2Config]
) -> BLSSignature:
# BLS override
bls.use(MilagroBackend)
return bls.sign(inputs["privkey"], inputs["message"])
def test_verify_empty_signatures(backend, domain):
# Want EMPTY_SIGNATURE to fail in Trinity
bls.use(backend)
def validate():
bls.validate(b"\x11" * 32, EMPTY_PUBKEY, EMPTY_SIGNATURE, domain)
def validate_multiple_1():
bls.validate_multiple(pubkeys=(),
message_hashes=(),
signature=EMPTY_SIGNATURE,
domain=domain)
def validate_multiple_2():
bls.validate_multiple(
pubkeys=(EMPTY_PUBKEY, EMPTY_PUBKEY),
message_hashes=(b"\x11" * 32, b"\x12" * 32),
signature=EMPTY_SIGNATURE,
domain=domain,
)
if backend == NoOpBackend:
validate()
validate_multiple_1()
validate_multiple_2()
else:
with pytest.raises(ValidationError):
validate()
with pytest.raises(ValidationError):
validate_multiple_1()
with pytest.raises(ValidationError):
validate_multiple_2()
def _select_bls_backend(bls_setting: BLSSetting) -> None:
if bls_setting == BLSSetting.DISABLED:
bls.use_noop_backend()
elif bls_setting == BLSSetting.ENABLED:
bls.use(MilagroBackend)
elif bls_setting == BLSSetting.OPTIONAL:
# do not verify BLS to save time
bls.use_noop_backend()
def _select_bls_backend(bls_setting: BLSSetting) -> None:
if bls_setting == BLSSetting.Disabled:
bls.use_noop_backend()
elif bls_setting == BLSSetting.Enabled:
bls.use(MilagroBackend)
elif bls_setting == BLSSetting.Optional:
# do not verify BLS to save time
bls.use_noop_backend()
def test_validate_invalid(backend):
bls.use(backend)
msg = b"\x32" * 32
privkey = 42
pubkey = bls.sk_to_pk(privkey)
sig = b"\x42" * 96
with pytest.raises(SignatureError):
bls.validate(msg, sig, pubkey)
def test_validate_multiple(backend):
bls.use(backend)
msg = b"\x32" * 32
privkey_0 = 42
privkey_1 = 4242
pubkey_0 = bls.sk_to_pk(privkey_0)
pubkey_1 = bls.sk_to_pk(privkey_1)
aggregate_sig = bls.aggregate(bls.sign(privkey_0, msg), bls.sign(privkey_1, msg))
bls.validate(msg, aggregate_sig, pubkey_0, pubkey_1)
def run_with(_cls, inputs: SignatureDescriptor,
_config: Optional[Eth2Config]) -> BLSSignature:
# BLS override
bls.use(MilagroBackend)
return bls.sign(
cast(Hash32, inputs["message_hash"]),
int(inputs["privkey"]),
cast(Domain, (inputs["domain"])),
)
def test_validate_multiple_one_invalid(backend):
bls.use(backend)
msg = b"\x32" * 32
privkey_0 = 42
privkey_1 = 4242
privkey_other = 424242
pubkey_0 = bls.sk_to_pk(privkey_0)
pubkey_1 = bls.sk_to_pk(privkey_1)
aggregate_sig = bls.aggregate(
bls.sign(privkey_0, msg), bls.sign(privkey_other, msg)
)
with pytest.raises(SignatureError):
bls.validate(msg, aggregate_sig, pubkey_0, pubkey_1)
def test_sanity(backend):
bls.use(backend)
msg_0 = b"\x32" * 32
domain = 123
# Test: Verify the basic sign/verify process
privkey_0 = 5566
sig_0 = bls.sign(msg_0, privkey_0, domain)
assert_signature(sig_0)
pubkey_0 = bls.privtopub(privkey_0)
assert_pubkey(pubkey_0)
assert bls.verify(msg_0, pubkey_0, sig_0, domain)
privkey_1 = 5567
sig_1 = bls.sign(msg_0, privkey_1, domain)
pubkey_1 = bls.privtopub(privkey_1)
assert bls.verify(msg_0, pubkey_1, sig_1, domain)
# Test: Verify signatures are correctly aggregated
aggregated_signature = bls.aggregate_signatures([sig_0, sig_1])
assert_signature(aggregated_signature)
# Test: Verify pubkeys are correctly aggregated
aggregated_pubkey = bls.aggregate_pubkeys([pubkey_0, pubkey_1])
assert_pubkey(aggregated_pubkey)
# Test: Verify with `aggregated_signature` and `aggregated_pubkey`
assert bls.verify(msg_0, aggregated_pubkey, aggregated_signature, domain)
# Test: `verify_multiple`
msg_1 = b"x22" * 32
privkey_2 = 55688
sig_2 = bls.sign(msg_1, privkey_2, domain)
assert_signature(sig_2)
pubkey_2 = bls.privtopub(privkey_2)
assert_pubkey(pubkey_2)
sig_1_2 = bls.aggregate_signatures([sig_1, sig_2])
assert bls.verify_multiple(
pubkeys=[pubkey_1, pubkey_2],
message_hashes=[msg_0, msg_1],
signature=sig_1_2,
domain=domain,
)
def test_multi_aggregation(backend, msg_1, msg_2, privkeys_1, privkeys_2,
domain):
bls.use(backend)
sigs_1 = [bls.sign(msg_1, k, domain=domain)
for k in privkeys_1] # signatures to msg_1
pubs_1 = [bls.privtopub(k) for k in privkeys_1]
aggpub_1 = bls.aggregate_pubkeys(pubs_1) # sig_1 to msg_1
sigs_2 = [bls.sign(msg_2, k, domain=domain)
for k in privkeys_2] # signatures to msg_2
pubs_2 = [bls.privtopub(k) for k in privkeys_2]
aggpub_2 = bls.aggregate_pubkeys(pubs_2) # sig_2 to msg_2
message_hashes = [msg_1, msg_2]
pubs = [aggpub_1, aggpub_2]
aggsig = bls.aggregate_signatures(sigs_1 + sigs_2)
assert bls.verify_multiple(pubkeys=pubs,
message_hashes=message_hashes,
signature=aggsig,
domain=domain)
def test_empty_aggregation(backend):
bls.use(backend)
assert bls.aggregate_pubkeys([]) == EMPTY_PUBKEY
assert bls.aggregate_signatures([]) == EMPTY_SIGNATURE
def test_validate_empty(backend):
bls.use(backend)
msg = b"\x32" * 32
sig = b"\x42" * 96
with pytest.raises(SignatureError):
bls.validate(msg, sig)
def run_with(_cls, inputs: SequenceOfBLSSignature,
_config: Eth2Config) -> BLSSignature:
# BLS override
bls.use(MilagroBackend)
return bls.aggregate_signatures(inputs)
def test_aggregate_pubkeys_fixture(config, test_case):
bls.use(PyECCBackend)
processing_call, _, _, _ = handler_to_processing_call_map[
test_case.handler]
assert processing_call(**(test_case.input)) == test_case.output
def mock_bls(mocker, request):
if 'noautofixture' in request.keywords:
bls.use(PyECCBackend)
else:
bls.use_noop_backend()
def run_with(_cls, inputs: int,
_config: Optional[Eth2Config]) -> BLSPubkey:
# BLS override
bls.use(MilagroBackend)
return bls.privtopub(inputs)
def run_with(_cls, inputs: SequenceOfBLSPubkey,
_config: Optional[Eth2Config]) -> BLSPubkey:
# BLS override
bls.use(MilagroBackend)
return bls.aggregate_pubkeys(inputs)
