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)