Nucypher
/
pyUmbral
mirror of https://github.com/nucypher/pyUmbral.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fix key names in encrypt/decrypt_original/decrypt_reencrypted

pull/270/head
Bogdan Opanchuk 2021-06-02 18:50:54 -07:00
parent 6a1bc0ce14
commit 16def46564
8 changed files with 21 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.rst
View File

@ -147,7 +147,7 @@ and then decrypts the re-encrypted ciphertext.
from umbral import decrypt_reencrypted
bob_cleartext = pre.decrypt_reencrypted(decrypting_sk=bobs_secret_key,
bob_cleartext = pre.decrypt_reencrypted(receiving_sk=bobs_secret_key,
delegating_pk=alices_public_key,
capsule=capsule,
cfrags=cfrags,

2
docs/examples/umbral_simple_api.py
View File

@ -103,7 +103,7 @@ cfrags = [cfrag.verify(capsule,
# ------------------------------------
# Finally, Bob decrypts the re-encrypted ciphertext using his key.
bob_cleartext = decrypt_reencrypted(decrypting_sk=bobs_secret_key,
bob_cleartext = decrypt_reencrypted(receiving_sk=bobs_secret_key,
delegating_pk=alices_public_key,
capsule=bob_capsule,
verified_cfrags=cfrags,

6
docs/notebooks/pyUmbral Simple API.ipynb
View File

@ -94,7 +94,7 @@
"from umbral import decrypt_original\n",
"\n",
"\n",
"cleartext = decrypt_original(sk=alices_private_key,\n",
"cleartext = decrypt_original(delegating_sk=alices_private_key,\n",
" capsule=capsule,\n",
" ciphertext=ciphertext)\n",
"print(cleartext)"
@ -144,7 +144,7 @@
"from umbral import GenericError\n",
"\n",
"try:\n",
" fail_decrypted_data = decrypt_original(sk=bobs_private_key,\n",
" fail_decrypted_data = decrypt_original(delegating_sk=bobs_private_key,\n",
" capsule=capsule,\n",
" ciphertext=ciphertext)\n",
"except GenericError:\n",
@ -266,7 +266,7 @@
"source": [
"from umbral import decrypt_reencrypted\n",
"\n",
"bob_cleartext = decrypt_reencrypted(decrypting_sk=bobs_private_key,\n",
"bob_cleartext = decrypt_reencrypted(receiving_sk=bobs_private_key,\n",
" delegating_pk=alices_public_key,\n",
" capsule=capsule,\n",
" verified_cfrags=cfrags,\n",

4
docs/source/using_pyumbral.rst
View File

@ -130,7 +130,7 @@ or re-encrypted for him by Ursula, he will not be able to open it.
.. doctest:: capsule_story
>>> fail = decrypt_original(sk=bobs_secret_key,
>>> fail = decrypt_original(delegating_sk=bobs_secret_key,
... capsule=capsule,
... ciphertext=ciphertext)
Traceback (most recent call last):
@ -196,7 +196,7 @@ Finally, Bob decrypts the re-encrypted ciphertext using his key.
.. doctest:: capsule_story
>>> from umbral import decrypt_reencrypted
>>> cleartext = decrypt_reencrypted(decrypting_sk=bobs_secret_key,
>>> cleartext = decrypt_reencrypted(receiving_sk=bobs_secret_key,
... delegating_pk=alices_public_key,
... capsule=capsule,
... verified_cfrags=cfrags,

2
tests/test_compatibility.py
View File

@ -170,7 +170,7 @@ def _decrypt_reencrypted(umbral, receiving_sk_bytes, delegating_pk_bytes, verify
for cfrag in cfrags]
# Decryption by Bob
plaintext = umbral.decrypt_reencrypted(decrypting_sk=receiving_sk,
plaintext = umbral.decrypt_reencrypted(receiving_sk=receiving_sk,
delegating_pk=delegating_pk,
capsule=capsule,
verified_cfrags=verified_cfrags,

4
tests/test_pre.py
View File

@ -81,7 +81,7 @@ def test_simple_api(num_kfrags, threshold):
cfrags = [reencrypt(capsule, kfrag) for kfrag in kfrags]
# Decryption by Bob
plaintext_reenc = decrypt_reencrypted(decrypting_sk=receiving_sk,
plaintext_reenc = decrypt_reencrypted(receiving_sk=receiving_sk,
delegating_pk=delegating_pk,
capsule=capsule,
verified_cfrags=cfrags[:threshold],
@ -105,7 +105,7 @@ def test_decrypt_unverified_cfrag(verification_keys, bobs_keys, capsule_and_ciph
cfrags = [reencrypt(capsule, kfrag) for kfrag in kfrags]
cfrags[0] = CapsuleFrag.from_bytes(bytes(cfrags[0]))
with pytest.raises(TypeError):
plaintext_reenc = decrypt_reencrypted(decrypting_sk=receiving_sk,
plaintext_reenc = decrypt_reencrypted(receiving_sk=receiving_sk,
delegating_pk=delegating_pk,
capsule=capsule,
verified_cfrags=cfrags,

8
umbral/capsule.py
View File

@ -43,7 +43,7 @@ class Capsule(Serializable):
return bytes(self.point_e) + bytes(self.point_v) + bytes(self.signature)
@classmethod
def from_public_key(cls, pk: PublicKey) -> Tuple['Capsule', CurvePoint]:
def from_public_key(cls, delegating_pk: PublicKey) -> Tuple['Capsule', CurvePoint]:
g = CurvePoint.generator()
priv_r = CurveScalar.random_nonzero()
@ -55,12 +55,12 @@ class Capsule(Serializable):
h = hash_capsule_points(pub_r, pub_u)
s = priv_u + (priv_r * h)
shared_key = pk._point_key * (priv_r + priv_u)
shared_key = delegating_pk._point_key * (priv_r + priv_u)
return cls(point_e=pub_r, point_v=pub_u, signature=s), shared_key
def open_original(self, sk: SecretKey) -> CurvePoint:
return (self.point_e + self.point_v) * sk.secret_scalar()
def open_original(self, delegating_sk: SecretKey) -> CurvePoint:
return (self.point_e + self.point_v) * delegating_sk.secret_scalar()
def open_reencrypted(self,
receiving_sk: SecretKey,

14
umbral/pre.py
View File

@ -8,25 +8,25 @@ from .key_frag import VerifiedKeyFrag, KeyFrag, KeyFragBase
from .signing import Signer
def encrypt(pk: PublicKey, plaintext: bytes) -> Tuple[Capsule, bytes]:
def encrypt(delegating_pk: PublicKey, plaintext: bytes) -> Tuple[Capsule, bytes]:
"""
Generates and encapsulates a symmetric key and uses it to encrypt the given plaintext.
Returns the KEM Capsule and the ciphertext.
"""
capsule, key_seed = Capsule.from_public_key(pk)
capsule, key_seed = Capsule.from_public_key(delegating_pk)
dem = DEM(bytes(key_seed))
ciphertext = dem.encrypt(plaintext, authenticated_data=bytes(capsule))
return capsule, ciphertext
def decrypt_original(sk: SecretKey, capsule: Capsule, ciphertext: bytes) -> bytes:
def decrypt_original(delegating_sk: SecretKey, capsule: Capsule, ciphertext: bytes) -> bytes:
"""
Opens the capsule using the original (Alice's) key used for encryption and gets what's inside.
Opens the capsule using the delegator's key used for encryption and gets what's inside.
We hope that's a symmetric key, which we use to decrypt the ciphertext
and return the resulting cleartext.
"""
key_seed = capsule.open_original(sk)
key_seed = capsule.open_original(delegating_sk)
dem = DEM(bytes(key_seed))
return dem.decrypt(ciphertext, authenticated_data=bytes(capsule))
@ -73,7 +73,7 @@ def reencrypt(capsule: Capsule, kfrag: VerifiedKeyFrag) -> VerifiedCapsuleFrag:
return VerifiedCapsuleFrag(CapsuleFrag.reencrypted(capsule, kfrag.kfrag))
def decrypt_reencrypted(decrypting_sk: SecretKey,
def decrypt_reencrypted(receiving_sk: SecretKey,
delegating_pk: PublicKey,
capsule: Capsule,
verified_cfrags: Sequence[VerifiedCapsuleFrag],
@ -89,6 +89,6 @@ def decrypt_reencrypted(decrypting_sk: SecretKey,
raise TypeError("All CapsuleFrags must be verified before decryption")
cfrags = [vcfrag.cfrag for vcfrag in verified_cfrags]
key_seed = capsule.open_reencrypted(decrypting_sk, delegating_pk, cfrags)
key_seed = capsule.open_reencrypted(receiving_sk, delegating_pk, cfrags)
dem = DEM(bytes(key_seed))
return dem.decrypt(ciphertext, authenticated_data=bytes(capsule))