def test_encrypt_decrypt(self):
public, private = generate_keypair(128, 8)
for _ in range(10):
plaintext = random.randint(0, 100000)
ciphertext = encrypt(public, 8, plaintext)
deciphered = decrypt(public, private, 8, ciphertext)
self.assertEqual(deciphered, plaintext)
def test_payload_lift_drop_once(self):
plaintext_space = 5
public, private = generate_keypair(128, plaintext_space)
data = Payload(1337, public, plaintext_space, plaintext_space)
encrypted = data.lift_by(1)
decrypted = encrypted.drop_by(1, private)
self.assertEqual(decrypted.payload, 1337)
def test_payload_lift_drop_once(self):
plaintext_space = 5
public, private = generate_keypair(128, plaintext_space)
data = Payload(1337, public, plaintext_space, plaintext_space)
encrypted = data.lift_by(1)
decrypted = encrypted.drop_by(1, private)
self.assertEqual(decrypted.payload, 1337)
def test_homomorphic_payload_add(self):
pspace = 10
public, private = generate_keypair(128, pspace)
a = Payload(12851, public, pspace, pspace).lift_once()
b = Payload(21585, public, pspace, pspace).lift_once()
c = homomorphic_add(a, b).get_plaintext(private)
self.assertEqual(c.payload, 12851 + 21585)
def test_homomorphic_payload_add(self):
pspace = 10
public, private = generate_keypair(128, pspace)
a = Payload(12851, public, pspace, pspace).lift_once()
b = Payload(21585, public, pspace, pspace).lift_once()
c = homomorphic_add(a, b).get_plaintext(private)
self.assertEqual(c.payload, 12851 + 21585)
def test_basic_encrypted(self):
lambda_ = 80
total_levels = 5
total_usable_buckets = 1 << total_levels
blocks_per_bucket = lambda_
total_blocks = total_usable_buckets * (blocks_per_bucket / 5)
chunks_per_block = 10
eviction_period = -1
root_plain_space = 3
public, private = damgard_jurik.generate_keypair(128, root_plain_space)
server_wrapper = EncServerWrapper(total_levels, blocks_per_bucket,
chunks_per_block, root_plain_space,
public, private)
client = Client(total_levels, total_blocks, blocks_per_bucket,
chunks_per_block, eviction_period, server_wrapper)
chunks = range(10)
chunks.reverse()
client.access(1, Operations.WRITE, chunks)
data = client.access(1, Operations.READ)
self.assertEqual(data, chunks)
client.access(13, Operations.WRITE, [189, 224, 1, 2, 3, 4, 5, 6, 7, 8])
self.assertEqual(client.access(13, Operations.READ),
[189, 224, 1, 2, 3, 4, 5, 6, 7, 8])
self.assertEqual(client.access(1, Operations.READ), chunks)
def test_encrypt_decrypt(self):
public, private = generate_keypair(128, 8)
for _ in range(10):
plaintext = random.randint(0, 100000)
ciphertext = encrypt(public, 8, plaintext)
deciphered = decrypt(public, private, 8, ciphertext)
self.assertEqual(deciphered, plaintext)
def test_homomorphic_operation(self):
public, private = generate_keypair(128, 8)
e12851 = encrypt(public, 8, 12851)
e21585 = encrypt(public, 8, 21585)
e34436 = e12851 * e21585
self.assertEquals(34436, decrypt(public,
private, 8, e34436))
def test_stress_encrypted(self):
lambda_ = 20
total_levels = 3
total_usable_buckets = 1 << total_levels
blocks_per_bucket = lambda_
total_blocks = total_usable_buckets * (blocks_per_bucket / 5)
chunks_per_block = 3
eviction_period = 20
root_plain_space = 1
public, private = damgard_jurik.generate_keypair(128, root_plain_space)
server_wrapper = EncServerWrapper(total_levels, blocks_per_bucket,
chunks_per_block, root_plain_space,
public, private)
client = Client(total_levels, total_blocks, blocks_per_bucket,
chunks_per_block, eviction_period, server_wrapper)
datas = [range(3) for _ in range(total_blocks)]
for i in range(len(datas)):
random.shuffle(datas[i])
client.access(i, Operations.WRITE, datas[i])
self.assertEqual(client.access(i, Operations.READ), datas[i])
for iteration in range(30):
piece = random.randint(0, total_blocks - 1)
self.assertEqual(client.access(piece, Operations.READ),
datas[piece])
random.shuffle(datas[piece])
client.access(piece, Operations.WRITE, datas[piece])
def test_homomorphic_scalar_multiply_zero(self):
base_level = 3
onion_level = 4
public, private = generate_keypair(128, onion_level)
hidden = Payload(444, public, base_level,
base_level).lift_by(onion_level)
selector = Payload(0, public, onion_level + base_level,
onion_level + base_level).lift_by(1)
res = homomorphic_scalar_multiply(hidden, selector)
self.assertEqual(res.get_plaintext(private).payload, 0)
def test_homomorphic_scalar_multiply_zero(self):
base_level = 3
onion_level = 4
public, private = generate_keypair(128, onion_level)
hidden = Payload(444, public, base_level,
base_level).lift_by(onion_level)
selector = Payload(0, public, onion_level + base_level,
onion_level + base_level).lift_by(1)
res = homomorphic_scalar_multiply(hidden, selector)
self.assertEqual(res.get_plaintext(private).payload, 0)
def test_payload_lift_drop_multiple_times(self):
pspace = 5
public, private = generate_keypair(128, pspace)
for _ in range(4):
num = random.randint(0, 100000)
data = Payload(num, public, pspace, pspace)
self.assertEqual(data.current_space, pspace)
self.assertEqual(data.plaintext_space, pspace)
by = random.randint(0, 10)
encrypted = data.lift_by(by)
self.assertEqual(encrypted.current_space, pspace + by)
self.assertEqual(encrypted.plaintext_space, pspace)
decrypted = encrypted.drop_by(by, private)
self.assertEqual(decrypted.current_space, pspace)
self.assertEqual(decrypted.plaintext_space, pspace)
self.assertEqual(decrypted.payload, num)
def test_payload_lift_drop_multiple_times(self):
pspace = 5
public, private = generate_keypair(128, pspace)
for _ in range(4):
num = random.randint(0, 100000)
data = Payload(num, public, pspace, pspace)
self.assertEqual(data.current_space, pspace)
self.assertEqual(data.plaintext_space, pspace)
by = random.randint(0, 10)
encrypted = data.lift_by(by)
self.assertEqual(encrypted.current_space, pspace + by)
self.assertEqual(encrypted.plaintext_space, pspace)
decrypted = encrypted.drop_by(by, private)
self.assertEqual(decrypted.current_space, pspace)
self.assertEqual(decrypted.plaintext_space, pspace)
self.assertEqual(decrypted.payload, num)
def test_homomorphic_select(self):
base_level = 2
onion_layers = 6
public, private = generate_keypair(128, base_level)
max_onion_layers = onion_layers + base_level
nums = [6969, 333, 1337, 3512]
for i in range(len(nums)):
enc = [Payload(x, public, base_level,
base_level).lift_by(onion_layers)
for x in nums]
select = [0] * len(nums)
select[i] = 1
selector = []
for j in range(len(nums)):
selector.append(Payload(select[j], public,
max_onion_layers,
max_onion_layers).lift_once())
res = homomorphic_select(enc, selector)
self.assertEqual(res.get_plaintext(private).payload, nums[i])
def test_encrypt_decrypt():
log_ns = range(8, 11 + 1)
ss = range(1, 6)
repetitions = 10
data = {}
for log_n in log_ns:
public, private = damgard_jurik.generate_keypair(2 ** log_n, 1)
for s in ss:
plaintext = random.getrandbits(public.bits) % public.n
ciphertext = damgard_jurik.encrypt(public, s, plaintext)
t = Timer(lambda: damgard_jurik.encrypt(public, s, plaintext))
to_encrypt = t.timeit(number=repetitions) / repetitions
t = Timer(lambda: damgard_jurik.decrypt(public, private, s, ciphertext))
to_decrypt = t.timeit(number=repetitions) / repetitions
data[(log_n, s)] = (to_encrypt, to_decrypt)
print data
return data
def test_homomorphic_select(self):
base_level = 2
onion_layers = 6
public, private = generate_keypair(128, base_level)
max_onion_layers = onion_layers + base_level
nums = [6969, 333, 1337, 3512]
for i in range(len(nums)):
enc = [
Payload(x, public, base_level,
base_level).lift_by(onion_layers) for x in nums
]
select = [0] * len(nums)
select[i] = 1
selector = []
for j in range(len(nums)):
selector.append(
Payload(select[j], public, max_onion_layers,
max_onion_layers).lift_once())
res = homomorphic_select(enc, selector)
self.assertEqual(res.get_plaintext(private).payload, nums[i])
def test_homomorphic_operation(self):
public, private = generate_keypair(128, 8)
e12851 = encrypt(public, 8, 12851)
e21585 = encrypt(public, 8, 21585)
e34436 = e12851 * e21585
self.assertEquals(34436, decrypt(public, private, 8, e34436))