-
Notifications
You must be signed in to change notification settings - Fork 1
/
KAC_Tree_Layer.py
121 lines (104 loc) · 3.75 KB
/
KAC_Tree_Layer.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
from kac_tree import KAC_Tree
from binary_tree import Node as HashTree
from charm.toolbox.symcrypto import SymmetricCryptoAbstraction
import pickle, itertools
class KAC_Tree_Layer:
def __init__(self, n, m, l, groupObj='SS512'):
# 0 is the lowest security level
self.multi_layers = [KAC_Tree(n, m, groupObj) for i in xrange(l+1)]
def setup(self):
return [i.setup() for i in self.multi_layers]
def keygen(self, param):
param_iter = iter(param)
return [i.keygen(param_iter.next()) for i in self.multi_layers]
def encrypt(self, pk, param):
pk_iter = iter(pk)
param_iter = iter(param)
# return
self.ct = [i.encrypt(pk_iter.next(), param_iter.next()) for i in self.multi_layers]
self.encrypted_leaves = []
unencrypted_leaves = []
for kac_layer in self.multi_layers:
unencrypted_leaves.append(list(kac_layer.generate_keys()))
# sym_key = pickle.dumps(unencrypted_leaves[3][2])
# plain = pickle.dumps(unencrypted_leaves[2][2])
# cipher = SymmetricCryptoAbstraction(sym_key).encrypt(plain)
# print unencrypted_leaves[2][2].data
# print pickle.loads(SymmetricCryptoAbstraction(sym_key).decrypt(cipher)).data
for i in xrange(1,len(unencrypted_leaves)):
self.encrypted_leaves.append([None])
for j in xrange(1, len(unencrypted_leaves[i])):
sym_key = unencrypted_leaves[i][j].data
plain = pickle.dumps(unencrypted_leaves[i-1][j])
self.encrypted_leaves[i-1].append(SymmetricCryptoAbstraction(sym_key).encrypt(plain))
# decryption_plain = []
# for i in xrange(len(self.encrypted_leaves)):
# for j in xrange(1, len(self.encrypted_leaves[i])):
# # print i,j
# sym_key = unencrypted_leaves[i+1][j].data
# # print i, j, sym_key
# cipher = self.encrypted_leaves[i][j]
# decryption_plain.append(pickle.loads(SymmetricCryptoAbstraction(sym_key).decrypt(cipher)))
return self.encrypted_leaves, unencrypted_leaves
# for i in decryption_plain:
# print i.min_val
def aggregate(self, msk, param, min_val, max_val, l):
# l is top layer
return self.multi_layers[l].aggregate(msk[l], param[l], min_val, max_val)
def derive_keys(self, aggregate_key, param, min_val, max_val, l, encrypted_leaves):
# inclusive of layer 0
top_layer = list(self.multi_layers[l].derive_keys(aggregate_key, param, min_val, max_val))
yield top_layer
for i in reversed(xrange(l)):
cipher_iter = iter(encrypted_leaves[i])
next_layer = []
# skip 0th frame
cipher_iter.next()
for plain in top_layer:
# print 'lol', len(top_layer)
sym_key = plain.data
# print i, sym_key
cipher = cipher_iter.next()
next_layer.append(pickle.loads(SymmetricCryptoAbstraction(sym_key).decrypt(cipher)))
top_layer = next_layer
yield top_layer
def main():
start_frame = 1
end_frame = 25
l = 3
test = KAC_Tree_Layer(32, 4, 5)
param = test.setup()
key = test.keygen(param)
pk = [k['pk'] for k in key]
cipher, unencrypted_leaves = test.encrypt(pk, param)
msk = [k['msk'] for k in key]
aggregate_key = test.aggregate(msk, param, start_frame, end_frame, l)
y = test.derive_keys(aggregate_key, param[l], start_frame, end_frame, l, cipher)
# for i in y:
# for j in i:
# print j.min_val, j.data
verify_results(y, start_frame, end_frame, l, test, unencrypted_leaves)
# t = [1, 2, 3]
# s = t
# t = []
# print s
# print t
def verify_results(calculated, start, end, l, kac, plain):
# inclusive of layer l and layer 0
j=0
for i in reversed(xrange(l+1)):
p = itertools.islice(plain[i], start, end)
sort_keys = sorted(calculated.next(), key=lambda HashTree: HashTree.min_val)
for frame_key in sort_keys:
j+=1
if (frame_key.data!=p.next().data):
print 'false'
else:
print 'true'
print j
if __name__ == "__main__":
main()
# test.encrypt(pk, param)
# test.encrypt(pk, param)
# for i in pk2:
# print i