How to use the umbral.pre.generate_kfrags function in umbral

signer = Signer(signing_privkey)

    # Key Generation (Bob)
    receiving_privkey = UmbralPrivateKey.gen_key(params=params)
    receiving_pubkey = receiving_privkey.get_pubkey()

    # Encryption by an unnamed data source
    plain_data = b'peace at dawn'
    ciphertext, capsule = pre.encrypt(delegating_pubkey, plain_data)

    # Decryption by Alice
    cleartext = pre.decrypt(ciphertext, capsule, delegating_privkey)
    assert cleartext == plain_data

    # Split Re-Encryption Key Generation (aka Delegation)
    kfrags = pre.generate_kfrags(delegating_privkey, receiving_pubkey, M, N, signer)


    # Capsule preparation (necessary before re-encryotion and activation)
    capsule.set_correctness_keys(delegating=delegating_pubkey,
                                 receiving=receiving_pubkey,
                                 verifying=signing_pubkey)

    # Bob requests re-encryption to some set of M ursulas
    cfrags = list()
    for kfrag in kfrags[:M]:
        # Ursula checks that the received kfrag is valid
        assert kfrag.verify(signing_pubkey, delegating_pubkey, receiving_pubkey, params)

        # Re-encryption by an Ursula
        cfrag = pre.reencrypt(kfrag, capsule)

set_default_curve()
params = default_params()
curve = params.curve

# We create also some Umbral objects for later
delegating_privkey = UmbralPrivateKey.gen_key(params=params)
receiving_privkey = UmbralPrivateKey.gen_key(params=params)
signing_privkey = UmbralPrivateKey.gen_key(params=params)

verifying_key = signing_privkey.get_pubkey()
delegating_key = delegating_privkey.get_pubkey()
receiving_key = receiving_privkey.get_pubkey()

signer = Signer(signing_privkey)

kfrags = pre.generate_kfrags(delegating_privkey=delegating_privkey,
                             receiving_pubkey=receiving_key,
                             threshold=6,
                             N=10,
                             signer=signer,
                             )

plain_data = b'peace at dawn'

ciphertext, capsule = pre.encrypt(delegating_key, plain_data)

capsule.set_correctness_keys(delegating=delegating_key,
                             receiving=receiving_key,
                             verifying=verifying_key)

cfrag = pre.reencrypt(kfrags[0], capsule)
points = [capsule.point_e, cfrag.point_e1, cfrag.proof.point_e2,

def test_single_frag_reencryption_performance(benchmark, m: int, n: int) -> None:

    delegating_privkey, signer, receiving_pubkey, ciphertext, capsule = __standard_encryption_api()
    kfrags = pre.generate_kfrags(delegating_privkey, receiving_pubkey, m, n, signer)
    one_kfrag, *remaining_kfrags = kfrags
    args, kwargs = tuple(), {"kfrag": one_kfrag, "capsule": capsule},

    print("\nBenchmarking {} with the same fragment({M} of {N}) repeatedly...".format("pre.reencrypt", M=m, N=n))
    benchmark.pedantic(pre.reencrypt, args=args, kwargs=kwargs, iterations=20, rounds=100)
    assert True  # ensure function finishes and succeeds.

def __produce_kfrags_and_capsule(m: int, n: int) -> Tuple[List[KFrag], Capsule]:

    delegating_privkey = keys.UmbralPrivateKey.gen_key(params=PARAMS)
    delegating_pubkey = delegating_privkey.get_pubkey()

    signing_privkey = keys.UmbralPrivateKey.gen_key(params=PARAMS)
    signer = Signer(signing_privkey)

    receiving_privkey = keys.UmbralPrivateKey.gen_key(params=PARAMS)
    receiving_pubkey = receiving_privkey.get_pubkey()

    plain_data = os.urandom(32)
    ciphertext, capsule = pre.encrypt(delegating_pubkey, plain_data)

    kfrags = pre.generate_kfrags(delegating_privkey, receiving_pubkey, m, n, signer)

    capsule.set_correctness_keys(delegating=delegating_pubkey,
                                 receiving=receiving_pubkey,
                                 verifying=signing_privkey.get_pubkey())

    return kfrags, capsule

def test_kfrags_signed_without_correctness_keys(alices_keys, bobs_keys, capsule):
    delegating_privkey, signing_privkey = alices_keys
    delegating_pubkey = delegating_privkey.get_pubkey()
    verifying_key = signing_privkey.get_pubkey()

    receiving_privkey, receiving_pubkey = bobs_keys

    kfrags = pre.generate_kfrags(delegating_privkey=delegating_privkey,
                                 signer=Signer(signing_privkey),
                                 receiving_pubkey=receiving_pubkey,
                                 threshold=6,
                                 N=10,
                                 sign_delegating_key=False,
                                 sign_receiving_key=False)

    for kfrag in kfrags:
        # You can verify the KFrag specifying only the verifying key
        assert kfrag.verify(signing_pubkey=verifying_key)

        # ... or if it is set in the capsule, using the capsule
        capsule.set_correctness_keys(verifying=verifying_key)
        assert kfrag.verify_for_capsule(capsule)

        # It should even work when other keys are set in the capsule

def test_wrong_N_M_in_split_rekey(N, M, alices_keys, bobs_keys):
    delegating_privkey, signing_privkey = alices_keys
    signer = Signer(signing_privkey)
    _receiving_privkey, receiving_pubkey = bobs_keys

    with pytest.raises(ValueError):
        _kfrags = pre.generate_kfrags(delegating_privkey=delegating_privkey,
                                      signer=signer,
                                      receiving_pubkey=receiving_pubkey,
                                      threshold=M,
                                      N=N)

fail_decrypted_data = pre.decrypt(ciphertext=ciphertext,
                                      capsule=bob_capsule,
                                      decrypting_key=bobs_private_key)
except pre.UmbralDecryptionError:
    print("Decryption failed! Bob doesn't has access granted yet.")

#8
# Alice grants access to Bob by generating kfrags 
# -----------------------------------------------
# When Alice wants to grant Bob access to open her encrypted messages, 
# she creates *threshold split re-encryption keys*, or *"kfrags"*, 
# which are next sent to N proxies or *Ursulas*. 
# She uses her private key, and Bob's public key, and she sets a minimum 
# threshold of 10, for 20 total shares

kfrags = pre.generate_kfrags(delegating_privkey=alices_private_key,
                             signer=alices_signer,
                             receiving_pubkey=bobs_public_key,
                             threshold=10,
                             N=20)

#9
# Ursulas perform re-encryption
# ------------------------------
# Bob asks several Ursulas to re-encrypt the capsule so he can open it. 
# Each Ursula performs re-encryption on the capsule using the `kfrag` 
# provided by Alice, obtaining this way a "capsule fragment", or `cfrag`.
# Let's mock a network or transport layer by sampling `threshold` random `kfrags`,
# one for each required Ursula.

import random