Unifying Capsule and ReconstructedCapsule into a single Capsule class.

tests/test_umbral.py

@@ -1,9 +1,13 @@
 import pytest
 
 from umbral import umbral, keys
-
+import random
 
 # (N,threshold)
+from umbral.umbral import Capsule
+from umbral.point import Point
+from umbral.bignum import BigNum
+
 parameters = [
     (1, 1),
     (6, 1),
@@ -56,6 +60,22 @@ def test_simple_api(N, threshold):
     assert reenc_dec_data == plain_data
 
 
+def test_bad_capsule_fails_reencryption():
+    pre = umbral.PRE()
+
+    priv_key_alice = keys.UmbralPrivateKey.gen_key(pre.params)
+    pub_key_alice = priv_key_alice.get_pub_key(pre.params)
+
+    k_frags, _unused_vkeys = pre.split_rekey(priv_key_alice, pub_key_alice, 1, 2)
+
+    bollocks_capsule = Capsule(point_eph_e=Point.gen_rand(curve=pre.params.curve),
+                               point_eph_v=Point.gen_rand(curve=pre.params.curve),
+                               bn_sig=BigNum.gen_rand(curve=pre.params.curve))
+
+    with pytest.raises(Capsule.NotValid):
+        pre.reencrypt(k_frags[0], bollocks_capsule)
+
+
 @pytest.mark.parametrize("N,threshold", parameters)
 def test_m_of_n(N, threshold):
     pre = umbral.PRE(umbral.UmbralParameters())
@@ -64,25 +84,26 @@ def test_m_of_n(N, threshold):
     priv_bob = pre.gen_priv()
     pub_bob = pre.priv2pub(priv_bob)
 
-    sym_key, capsule_alice = pre._encapsulate(pub_alice)
 
+    sym_key, capsule = pre._encapsulate(pub_alice)
     kfrags, vkeys = pre.split_rekey(priv_alice, pub_bob, threshold, N)
 
     for kfrag in kfrags:
         assert kfrag.verify(pub_alice, pub_bob, pre.params)
         assert kfrag.is_consistent(vkeys, pre.params)
 
     for kfrag in kfrags[:threshold]:
-        cfrag = pre.reencrypt(kfrag, capsule_alice)
-        capsule_alice.attach_cfrag(cfrag)
-        ch = pre.challenge(kfrag, capsule_alice, cfrag)
-        assert pre.check_challenge(capsule_alice, cfrag, ch, pub_alice, pub_bob)
+        cfrag = pre.reencrypt(kfrag, capsule)
+        capsule.attach_cfrag(cfrag)
+        ch = pre.challenge(kfrag, capsule, cfrag)
+        assert pre.check_challenge(capsule, cfrag, ch, pub_alice, pub_bob)
 
-    capsule_bob = capsule_alice.reconstruct()
+    # assert capsule.is_openable_by_bob()  # TODO: Is it possible to check here if >= m cFrags have been attached?
+    capsule.open(pub_bob, priv_bob, pub_alice)
 
-    sym_key_2 = pre._decapsulate_reencrypted(pub_bob, priv_bob, pub_alice, capsule_bob, capsule_alice)
 
-    assert sym_key_2 == sym_key
+    sym_key_2 = pre._decapsulate_reencrypted(pub_bob, priv_bob, pub_alice, capsule)
+    assert sym_key == capsule.contents
 
 
 def test_kfrag_serialization():
@@ -140,15 +161,11 @@ def test_capsule_serialization():
     capsule_bytes = capsule.to_bytes()
 
     # A Capsule can be represented as the 98 total bytes of two Points (33 each) and a BigNum (32).
-    # TODO: Do we want to include the cfrags as well?  See #20.
     assert len(capsule_bytes) == 33 + 33 + 32 == 98
 
     new_capsule = umbral.Capsule.from_bytes(capsule_bytes,
                                             umbral.UmbralParameters().curve)
-    assert new_capsule.point_eph_e == capsule.point_eph_e
-    assert new_capsule.point_eph_v == capsule.point_eph_v
-    assert new_capsule.bn_sig == capsule.bn_sig
-
+    assert new_capsule.original_components() == capsule.original_components()
 
 def test_reconstructed_capsule_serialization():
     pre = umbral.PRE(umbral.UmbralParameters())
@@ -163,18 +180,18 @@ def test_reconstructed_capsule_serialization():
 
     capsule.attach_cfrag(cfrag)
 
-    rec_capsule = capsule.reconstruct()
-    rec_capsule_bytes = rec_capsule.to_bytes()
+    capsule._reconstruct()
+    rec_capsule_bytes = capsule.to_bytes(reconstructed_components=True)
 
     # A reconstructed Capsule is three points, representable as 33 bytes each.
     assert len(rec_capsule_bytes) == 99
 
-    new_rec_capsule = umbral.ReconstructedCapsule.from_bytes(
+    new_rec_capsule = umbral.Capsule.from_bytes(
                                 rec_capsule_bytes,
-                                umbral.UmbralParameters().curve)
-    assert new_rec_capsule.point_eph_e_prime == rec_capsule.point_eph_e_prime
-    assert new_rec_capsule.point_eph_v_prime == rec_capsule.point_eph_v_prime
-    assert new_rec_capsule.point_eph_ni == rec_capsule.point_eph_ni
+                                umbral.UmbralParameters().curve, is_reconstructed=True)
+    assert new_rec_capsule._point_eph_e_prime == capsule._point_eph_e_prime
+    assert new_rec_capsule._point_eph_v_prime == capsule._point_eph_v_prime
+    assert new_rec_capsule._point_noninteractive == capsule._point_noninteractive
 
 
 def test_challenge_response_serialization():

umbral/point.py

@@ -96,7 +96,7 @@ def to_affine(self):
         return (backend._bn_to_int(affine_x), backend._bn_to_int(affine_y))
 
     @classmethod
-    def from_bytes(self, data, curve):
+    def from_bytes(cls, data, curve):
         """
         Returns a Point object from the given byte data on the curve provided.
         """
@@ -125,7 +125,7 @@ def from_bytes(self, data, curve):
                 )
                 backend.openssl_assert(res == 1)
 
-            return Point(ec_point, curve_nid, affine_x.group)
+            return cls(ec_point, curve_nid, affine_x.group)
 
         # Handle uncompressed point
         elif data[0] == 4:
@@ -176,7 +176,7 @@ def get_generator_from_curve(cls, curve):
         generator = backend._lib.EC_GROUP_get0_generator(group)
         backend.openssl_assert(generator != backend._ffi.NULL)
 
-        return Point(generator, curve_nid, group)
+        return cls(generator, curve_nid, group)
 
     @classmethod
     def get_order_from_curve(cls, curve):