def testPairing(self):
trials = 10
trials2 = trials * 3
group = PairingGroup("SS512")
g = group.random(G1)
h = group.random(G1)
i = group.random(G2)
self.assertTrue(group.InitBenchmark())
group.StartBenchmark(["RealTime", "Exp", "Pair"])
for a in range(trials):
j = g * h
k = i**group.random(ZR)
t = (j**group.random(ZR)) / h
n = pair(h, i)
group.EndBenchmark()
msmtDict = group.GetGeneralBenchmarks()
self.assertTrue(isSaneBenchmark(msmtDict))
self.assertTrue(group.InitBenchmark())
group.StartBenchmark(["CpuTime", "Mul", "Pair"])
for a in range(trials2):
j = g * h
k = i**group.random(ZR)
n = pair(h, i)
group.EndBenchmark()
msmtDict = group.GetGeneralBenchmarks()
del group
self.assertTrue(isSaneBenchmark(msmtDict))
def testPairing(self):
trials = 10
trials2 = trials * 3
group = PairingGroup("SS512")
g = group.random(G1)
h = group.random(G1)
i = group.random(G2)
self.assertTrue(group.InitBenchmark())
group.StartBenchmark(["RealTime", "Exp", "Pair"])
for a in range(trials):
j = g * h
k = i ** group.random(ZR)
t = (j ** group.random(ZR)) / h
n = pair(h, i)
group.EndBenchmark()
msmtDict = group.GetGeneralBenchmarks()
self.assertTrue(isSaneBenchmark(msmtDict))
self.assertTrue(group.InitBenchmark())
group.StartBenchmark(["CpuTime", "Mul", "Pair"])
for a in range(trials2):
j = g * h
k = i ** group.random(ZR)
n = pair(h, i)
group.EndBenchmark()
msmtDict = group.GetGeneralBenchmarks()
del group
self.assertTrue(isSaneBenchmark(msmtDict))
def test2():
client = UdpEndPoint()
p = UdpEndPoint()
group_object = PairingGroup('SS512')
key_client = group_object.random(GT)
key_p = group_object.random(GT)
nonce = OpenSSLRand().getRandomBits(128)
server_crypter_a = SymmetricCryptoAbstraction(extractor(key_client))
server_crypter_b = SymmetricCryptoAbstraction(extractor(key_p))
c_package_a = test1(client, p, nonce,
objectToBytes(key_client, group_object),
objectToBytes(key_p, group_object))
print('===========================================================')
print(c_package_a)
key_package_a = server_crypter_a.decrypt(c_package_a)
key_package_a = bytesToObject(key_package_a, group_object)
key_package_b = server_crypter_b.decrypt(key_package_a[3])
key_package_b = bytesToObject(key_package_b, group_object)
print('===========================================================')
i = 1
for thing in key_package_a:
print(str(i) + '.', thing)
i += 1
print('===========================================================')
j = 1
for thing in key_package_b:
print(str(j) + '.', thing)
j += 1
print('===========================================================')
def init(self, kappa):
group = PairingGroup(kappa)
p, g1 = (group.order(), group.random(G1))
x1, x2, y1, y2 = [group.random(ZR) for i in range(4)]
g2 = g1**(x1 / x2)
z = g1**x1
u1 = g1**y1
u2 = g2**y2
setup.GetKeypairs()
def __init__(self, kappa):
group = PairingGroup(kappa)
p, g1 = (group.order(), group.random(G1))
x1, x2, y1, y2 = [group.random(ZR) for i in range(4)]
g2 = g1**(x1 / x2)
z = g1**x1
u1 = g1**y1
u2 = g2**y2
self.pk = PublicKeys(group, p, g1, g2, z, u1, u2)
self.sk = PrivateKeys(x1, x2, y1, y2)
def ibcKeySize():
group = PairingGroup('SS512')
g1 = group.random(G1)
g2 = group.random(G2)
gt = group.random(GT)
logging.info("G1:" + str(g1) + ", length: " +
str(len(Blob(objectToBytes(g1, group)))) + " bytes.")
logging.info("G2:" + str(g2) + ", length: " +
str(len(Blob(objectToBytes(g2, group)))) + " bytes.")
logging.info("GT:" + str(gt) + ", length: " +
str(len(Blob(objectToBytes(gt, group)))) + " bytes.")
def schnorr_NIZK():
# setup
start = time.time()
grp = PairingGroup('MNT224')
ps = PS01(grp)
end = time.time()
print("Setup time elapse: ")
print(end - start)
# keygen
start = time.time()
(pk, sk) = ps.keygen(2)
end = time.time()
print("KeyGen over two attributes time elapse: ")
print(end - start)
# generate a secret
secret = grp.random()
# NIZK Schnorr prover
start = time.time()
na = grp.random()
a = pk['Y1'][0] ** na
# deterministic nb
m = hashlib.sha256()
m.update(grp.serialize(pk['Y1'][0]))
m.update(grp.serialize(a))
m.update(grp.serialize(pk['Y1'][0] ** secret))
m.update(b'userid') # replaced with real values
nb = m.digest()
nb = grp.hash(nb)
# r
r = na + nb * secret
end = time.time()
print("NIZK Schnorr on one attribute Prover time elapse: ")
print(end - start)
# NIZK Schnorr verifier
start = time.time()
m = hashlib.sha256()
m.update(grp.serialize(pk['Y1'][0]))
m.update(grp.serialize(a))
m.update(grp.serialize(pk['Y1'][0] ** secret))
m.update(b'userid') # replaced with real values
nb = m.digest()
nb = grp.hash(nb)
lh = pk['Y1'][0] ** r
rh = a * (pk['Y1'][0] ** secret) ** nb
end = time.time()
print("NIZK Schnorr Verifier time elapse: ")
print(end - start)
if lh == rh:
print('check success')
else:
print('lh:=', lh)
print('rh:=', rh)
def main(argv):
HOST, PORT = "", 8090
party_info = {}
if argv[1] == '-p':
print("Operating as prover...")
prover_sock = socket(AF_INET, SOCK_STREAM)
prover_sock.connect((HOST, PORT))
prover_sock.settimeout(15)
user = '******'
party_info['socket'] = prover_sock
elif argv[1] == '-v':
print("Operating as verifier...")
svr = socket(AF_INET, SOCK_STREAM)
svr.bind((HOST, PORT))
svr.listen(1)
verifier_sock, addr = svr.accept()
print("Connected by ", addr)
user = '******'
party_info['socket'] = verifier_sock
else:
print("ERROR!")
exit(-1)
group = PairingGroup('a.param')
party_info['party'] = user
party_info['setting'] = group
# statement: '(h = g^x) and (j = g^y)'
if (user == 'prover'):
g = group.random(G1)
x, y = group.random(ZR), group.random(ZR)
pk = {'h': g**x, 'g': g, 'j': g**y}
sk = {'x': x, 'y': y}
# pk = {'h':g**x, 'g':g}
# sk = {'x':x, 'y':y}
result = executeIntZKProof(pk, sk, '(h = g^x) and (j = g^y)',
party_info)
print("Results for PROVER =>", result)
elif (user == 'verifier'):
# verifier shouldn't have this information
# pk = {'h':1, 'g':1, 'j':1}
# sk = {'x':1, 'y':1}
pk = {'h': 1, 'g': 1, 'j': 1}
sk = {'x': 1}
result = executeIntZKProof(pk, sk, '(h = g^x) and (j = g^y)',
party_info)
print("Results for VERIFIER =>", result)
def testZKPVoteInLib_moreParameters(self):
groupObj = PairingGroup('BN254')
params = 2
msg = []
attrs = []
attr1 = []
attr2 = []
msg.append("testmessage")
msg.append("female")
attr1.append("testmessage")
attr2.append("male")
attr2.append("female")
attrs.append(attr1)
attrs.append(attr2)
el = ElGamal(params)
agho = AGHOBlind(el)
(pk_EV, sk_EV) = el.keygen()
h = groupObj.random(G2)
(c, o) = el.encrypt(pk_EV, msg)
m = el.decrypt(pk_EV, sk_EV, c, attrs)
(ch, r) = el.ZKPsk(c, pk_EV['g'], sk_EV)
isCorrect = el.ZKPsk_verify(c, msg, pk_EV, ch, r, pk_EV['g'])
assert (isCorrect)
print("ZKPVote Test Result from Library with more parameters:",
isCorrect)
def main():
global group
group = PairingGroup(secparam)
userFuncs2.groupObj = group
builtInFuncs.util = SecretUtil(group, verbose=False)
attrs = ['ONE', 'TWO', 'THREE']
access_policy = '((four or three) and (two or one))'
print("Attributes =>", attrs); print("Policy =>", access_policy)
(mk, pk) = setup()
sk = keygen(pk, mk, attrs)
print("sk :=>", sk)
rand_msg = group.random(GT)
print("msg =>", rand_msg)
ct = encrypt(pk, rand_msg, access_policy)
print("\nCiphertext...\n")
group.debug(ct)
rec_msg = decrypt(pk, sk, ct)
print("\nDecrypt...\n")
print("Rec msg =>", rec_msg)
assert rand_msg == rec_msg, "FAILED Decryption: message is incorrect"
print("Successful Decryption!!!")
def main():
group = PairingGroup('MNT160')
max_attributes = 6
required_overlap = 4
ibe = IBE_SW05_LUC(group)
(master_public_key, master_key) = ibe.setup(max_attributes,
required_overlap)
private_identity = [
'insurance', 'id=2345', 'oncology', 'doctor', 'nurse', 'JHU'
] #private identity
public_identity = [
'insurance', 'id=2345', 'doctor', 'oncology', 'JHU', 'billing', 'misc'
] #public identity for encrypt
(pub_ID_hashed, secret_key) = ibe.extract(master_key, private_identity,
master_public_key,
required_overlap, max_attributes)
msg = group.random(GT)
cipher_text = ibe.encrypt(master_public_key, public_identity, msg,
max_attributes)
decrypted_msg = ibe.decrypt(master_public_key, secret_key, cipher_text,
pub_ID_hashed, required_overlap)
print("msg: ", msg)
print("decrypted_msg: ", decrypted_msg)
assert msg == decrypted_msg, "failed decryption!"
print("Successful Decryption!")
def testIBE_BB04(self):
# initialize the element object so that object references have global scope
groupObj = PairingGroup('MNT224')
ibe = IBE_BB04(groupObj)
(params, mk) = ibe.setup()
# represents public identity
kID = groupObj.random(ZR)
key = ibe.extract(mk, kID)
M = groupObj.random(GT)
cipher = ibe.encrypt(params, kID, M)
m = ibe.decrypt(params, key, cipher)
assert m == M, "FAILED Decryption!"
if debug: print("Successful Decryption!! M => '%s'" % m)
def test_basic(self):
curve = 'SS512'
group = PairingGroup(curve)
g1 = group.random(G1)
g2 = g1
gT = pair(g1, g2)
MM_SS512 = MM_GROUP(G=group, g1=g1, g2=g2, gT=gT)
# Define security parameters
n = 6
d = 2
mscheme = MM(MM_SS512)
ps = BenignPS(mscheme)
D = mscheme.sample(n, d) >> G1
pk, sk = ps.gen(D)
r = mscheme.sample(d)
u = D * r
pi = ps.prove(pk, u, r)
self.assertEqual(True, ps.verify(sk, u, pi), "Should be equal")
r = mscheme.sample(d)
pi2 = ps.peval(pk, u, pi, r)
u = u + D * r
self.assertEqual(True, ps.verify(sk, u, pi2), "Should be equal")
def main():
global group
#group = PairingGroup(secparam)
group = PairingGroup("SS512")
alphabet = ['a', 'b']
dfa = DFA("ab*a", alphabet)
builtinFuncs_dfa.DFAObj = dfa
dfaM = dfa.constructDFA()
(mpk, msk) = setup(alphabet)
Q, S, T, q0, F = dfaM
(blindingFactor0Blinded, skBlinded) = keygen(mpk, msk, Q, T, F)
w = dfa.getSymbols("abbba")
M = group.random(GT)
print("M :", M)
ct = encrypt(mpk, w, M)
(transformOutputList, l, Ti, transformOutputListForLoop) = transform(skBlinded, ct, dfaM)
origM = decout(dfaM, transformOutputList, blindingFactor0Blinded, l, Ti, transformOutputListForLoop)
print("rec M :", origM)
assert M == origM, "failed decryption"
print("SUCCESSFUL DECRYPTION!!!")
def main():
# instantiate a bilinear pairing map
# pairing_group = PairingGroup('MNT224')
pairing_group = PairingGroup("SS512")
print("start")
# AC17 CP-ABE under DLIN (2-linear)
cpabe = BSW07(pairing_group, 2)
# run the set up
(pk, msk) = cpabe.setup()
# generate a key
attr_list = ['ONE', 'TWO', 'THREE']
key = cpabe.keygen(pk, msk, attr_list)
# choose a random message
msg = pairing_group.random(GT)
print(msg)
# generate a ciphertext
policy_str = '((ONE and THREE) and (TWO OR FOUR))'
ctxt = cpabe.encrypt(pk, msg, policy_str)
print(ctxt)
# decryption
rec_msg = cpabe.decrypt(pk, ctxt, key)
print(rec_msg)
if debug:
if rec_msg == msg:
print ("Successful decryption.")
else:
print ("Decryption failed.")
def main():
global group
group = PairingGroup("SS512")
alphabet = {'a', 'b'}
dfa = DFA("ab*a", alphabet)
dfaM = dfa.constructDFA()
fe = FE_DFA(group, dfa)
(mpk, msk) = fe.setup(alphabet)
if debug: print("mpk :=>", mpk, "\n\n")
sk = fe.keygen(mpk, msk, dfaM)
if debug: print("sk :=>", sk)
w = dfa.getSymbols("abba")
w1 = dfa.getSymbols("aba")
M = group.random(GT)
ct = fe.encrypt(mpk, w, M)
# Explicitly override the string with another valid string
ct[1] = w1
print w1 == w
origM = fe.decrypt(sk, ct)
assert M == origM, "failed decryption!"
if debug: print("Successful Decryption!!!!!")
def main():
global group
group = PairingGroup(secparam)
userFuncs2.groupObj = group
builtInFuncs.util = SecretUtil(group, verbose=False)
attrs = ['ONE', 'TWO', 'THREE']
access_policy = '((four or three) and (two or one))'
print("Attributes =>", attrs)
print("Policy =>", access_policy)
(mk, pk) = setup()
sk = keygen(pk, mk, attrs)
print("sk :=>", sk)
rand_msg = group.random(GT)
print("msg =>", rand_msg)
ct = encrypt(pk, rand_msg, access_policy)
print("\nCiphertext...\n")
group.debug(ct)
rec_msg = decrypt(pk, sk, ct)
print("\nDecrypt...\n")
print("Rec msg =>", rec_msg)
assert rand_msg == rec_msg, "FAILED Decryption: message is incorrect"
print("Successful Decryption!!!")
def main():
global group
group = PairingGroup('SS512')
attrs = ['ONE', 'TWO', 'THREE']
access_policy = '((four or three) and (two or one))'
#print("Attributes =>", attrs); print("Policy =>", access_policy)
(mk, pk) = setup()
sk = keygen(pk, mk, attrs)
#print("sk :=>", sk)
rand_msg = group.random(GT)
print("msg =>", rand_msg)
ct = encrypt(pk, rand_msg, access_policy)
#print("\n\nCiphertext...\n")
group.debug(ct)
rec_msg = decrypt(pk, sk, ct)
#print("\n\nDecrypt...\n")
print("Rec msg =>", rec_msg)
assert rand_msg == rec_msg, "FAILED Decryption: message is incorrect"
print("Successful Decryption!!!")
def main(num=5):
pol = generatePolicy(num)
attr_list = generateAttrList(num)
#Get the eliptic curve with the bilinear mapping feature needed.
groupObj = PairingGroup('SS512')
cpabe = RW13(groupObj)
(msk, pk) = cpabe.setup()
if debug: print('Acces Policy: %s' % pol)
if debug: print('User credential list: %s' % attr_list)
m = groupObj.random(GT)
cpkey = cpabe.keygen(pk, msk, attr_list)
if debug: print("\nSecret key: %s" % attr_list)
if debug:groupObj.debug(cpkey)
cipher = cpabe.encrypt(pk, m, pol)
if debug: print("\nCiphertext...")
if debug:groupObj.debug(cipher)
orig_m = cpabe.decrypt(pk, cpkey, cipher)
assert m == orig_m, 'FAILED Decryption!!!'
if debug: print('Successful Decryption!')
del groupObj
def main():
global group
group = PairingGroup(secparam)
alphabet = ['a', 'b']
dfa = DFA("ab*a", alphabet)
builtinFuncs_dfa.DFAObj = dfa
dfaM = dfa.constructDFA()
(mpk, msk) = setup(alphabet)
(blindingFactor0Blinded, skBlinded) = keygen(mpk, msk, dfaM)
w = dfa.getSymbols("abba")
M = group.random(GT)
print("M :", M)
ct = encrypt(mpk, w, M)
transformOutputList = transform(skBlinded, ct)
origM = decout(skBlinded, ct, transformOutputList, blindingFactor0Blinded, blindingFactorKendList1Blinded)
print("rec M :", origM)
assert M == origM, "failed decryption"
print("SUCCESSFUL DECRYPTION!!!")
def main():
#Get the eliptic curve with the bilinear mapping feature needed.
groupObj = PairingGroup('SS512')
cpabe = CPabe09(groupObj)
(msk, pk) = cpabe.setup()
pol = '((ONE or THREE) and (TWO or FOUR))'
attr_list = ['THREE', 'ONE', 'TWO']
if debug: print('Acces Policy: %s' % pol)
if debug: print('User credential list: %s' % attr_list)
m = groupObj.random(GT)
print('message:%s' % m)
# individual's secret key (cpkey) is generated for each individual by AA using the individual's attribute list (attr_list)
cpkey = cpabe.keygen(pk, msk, attr_list)
if debug: print("\nSecret key: %s" % attr_list)
if debug: groupObj.debug(cpkey)
cipher = cpabe.encrypt(pk, m, pol)
if debug: print("\nCiphertext...")
if debug: groupObj.debug(cipher)
orig_m = cpabe.decrypt(pk, cpkey, cipher)
assert m == orig_m, 'FAILED Decryption!!!'
if debug: print('Successful Decryption!')
del groupObj
def testDabe(self):
groupObj = PairingGroup('SS512')
dabe = Dabe(groupObj)
GP = dabe.setup()
#Setup an authority
auth_attrs = ['ONE', 'TWO', 'THREE', 'FOUR']
(SK, PK) = dabe.authsetup(GP, auth_attrs)
if debug: print("Authority SK")
if debug: print(SK)
#Setup a user and give him some keys
gid, K = "bob", {}
usr_attrs = ['THREE', 'ONE', 'TWO']
for i in usr_attrs:
dabe.keygen(GP, SK, i, gid, K)
if debug: print('User credential list: %s' % usr_attrs)
if debug: print("\nSecret key:")
if debug: groupObj.debug(K)
#Encrypt a random element in GT
m = groupObj.random(GT)
policy = '((one or three) and (TWO or FOUR))'
if debug: print('Acces Policy: %s' % policy)
CT = dabe.encrypt(PK, GP, m, policy)
if debug: print("\nCiphertext...")
if debug: groupObj.debug(CT)
orig_m = dabe.decrypt(GP, K, CT)
assert m == orig_m, 'FAILED Decryption!!!'
if debug: print('Successful Decryption!')
def test_basic(self):
# create a MM_GROUP on Curve MNT159
curve = 'MNT159'
group = PairingGroup(curve)
g1 = group.random(G1)
g2 = group.random(G2)
gT = pair(g1, g2)
MM_SS512 = MM_GROUP(G=group, g1=g1, g2=g2, gT=gT)
# Define security parameters
k = 2
D3_2_MDDH = DK_MDDH(k, MM_SS512)
mscheme = MM(MM_SS512)
scheme = FFHR19(mscheme, k, D3_2_MDDH)
pk, sk = scheme.keygen()
msg = mscheme.sample(1, gtype=G1)
c = scheme.encrypt(pk, msg)
m = scheme.decrypt(pk, sk, c)
self.assertEqual(m, msg, "Should be equal")
c2 = scheme.rand(pk, c)
m = scheme.decrypt(pk, sk, c2)
self.assertEqual(m, msg, "Should be after rand too")
def main():
groupObj = PairingGroup('SS512')
cpabe = CPabe_BSW07(groupObj)
attrs = ['ONE', 'TWO', 'THREE']
access_policy = '((four or three) and (three or one))'
if debug:
print("Attributes =>", attrs); print("Policy =>", access_policy)
(pk, mk) = cpabe.setup()
sk = cpabe.keygen(pk, mk, attrs)
print("sk :=>", sk)
rand_msg = groupObj.random(GT)
if debug: print("msg =>", rand_msg)
ct = cpabe.encrypt(pk, rand_msg, access_policy)
if debug: print("\n\nCiphertext...\n")
groupObj.debug(ct)
rec_msg = cpabe.decrypt(pk, sk, ct)
if debug: print("\n\nDecrypt...\n")
if debug: print("Rec msg =>", rec_msg)
assert rand_msg == rec_msg, "FAILED Decryption: message is incorrect"
if debug: print("Successful Decryption!!!")
def testIBE_BB04(self):
# initialize the element object so that object references have global scope
groupObj = PairingGroup('MNT224')
ibe = IBE_BB04(groupObj)
(params, mk) = ibe.setup()
# represents public identity
kID = groupObj.random(ZR)
key = ibe.extract(mk, kID)
M = groupObj.random(GT)
cipher = ibe.encrypt(params, kID, M)
m = ibe.decrypt(params, key, cipher)
assert m == M, "FAILED Decryption!"
if debug: print("Successful Decryption!! M => '%s'" % m)
def testIBE_SW05_LUC(self):
# initialize the element object so that object references have global scope
groupObj = PairingGroup('SS512')
n = 6
d = 4
ibe = IBE_SW05_LUC(groupObj)
(pk, mk) = ibe.setup(n, d)
if debug:
print("Parameter Setup...")
print("pk =>", pk)
print("mk =>", mk)
w = ['insurance', 'id=2345', 'oncology', 'doctor', 'nurse',
'JHU'] #private identity
wPrime = [
'insurance', 'id=2345', 'doctor', 'oncology', 'JHU', 'billing',
'misc'
] #public identity for encrypt
(w_hashed, sk) = ibe.extract(mk, w, pk, d, n)
M = groupObj.random(GT)
cipher = ibe.encrypt(pk, wPrime, M, n)
m = ibe.decrypt(pk, sk, cipher, w_hashed, d)
assert m == M, "FAILED Decryption: \nrecovered m = %s and original m = %s" % (
m, M)
if debug: print("Successful Decryption!! M => '%s'" % m)
def main():
#Get the eliptic curve with the bilinear mapping feature needed.
groupObj = PairingGroup('SS512')
cpabe = CPabe09(groupObj)
(msk, pk) = cpabe.setup()
pol = '((ONE or THREE) and (TWO or FOUR))'
attr_list = ['THREE', 'ONE', 'TWO']
if debug: print('Acces Policy: %s' % pol)
if debug: print('User credential list: %s' % attr_list)
m = groupObj.random(GT)
cpkey = cpabe.keygen(pk, msk, attr_list)
if debug: print("\nSecret key: %s" % attr_list)
if debug:groupObj.debug(cpkey)
cipher = cpabe.encrypt(pk, m, pol)
if debug: print("\nCiphertext...")
if debug:groupObj.debug(cipher)
orig_m = cpabe.decrypt(pk, cpkey, cipher)
assert m == orig_m, 'FAILED Decryption!!!'
if debug: print('Successful Decryption!')
del groupObj
def testCPabe_BSW07(self):
groupObj = PairingGroup('SS512')
cpabe = CPabe_BSW07(groupObj)
attrs = ['ONE', 'TWO', 'THREE']
access_policy = '((four or three) and (three or one))'
if debug:
print("Attributes =>", attrs)
print("Policy =>", access_policy)
(pk, mk) = cpabe.setup()
sk = cpabe.keygen(pk, mk, attrs)
rand_msg = groupObj.random(GT)
if debug: print("msg =>", rand_msg)
ct = cpabe.encrypt(pk, rand_msg, access_policy)
if debug: print("\n\nCiphertext...\n")
groupObj.debug(ct)
rec_msg = cpabe.decrypt(pk, sk, ct)
if debug: print("\n\nDecrypt...\n")
if debug: print("Rec msg =>", rec_msg)
assert rand_msg == rec_msg, "FAILED Decryption: message is incorrect"
if debug: print("Successful Decryption!!!")
def basicTest2():
'''Month-based attributes are used'''
print("RUN basicTest2")
groupObj = PairingGroup('SS512')
tbpre = TBPRE(groupObj)
attributes = ["ONE", "TWO", "THREE", "FOUR"]
MK, PK, s, H = tbpre.setup(attributes)
users = {} # public
alice = {'id': 'alice'}
alice['sku'], users[alice['id']] = tbpre.registerUser(PK, H)
year = {'year': "2014", 'month': '2'}
for attr in attributes[0:-1]:
tbpre.keygen(MK, PK, H, s, alice, users[alice['id']], attr, year)
k = groupObj.random(GT)
policy = [['ONE', 'THREE'],
['TWO', 'FOUR']] # [['ONE' and 'THREE'] or ['TWO' and 'FOUR']]
currentDate = {'year': "2014", 'month': "2", 'day': "15"}
CT = tbpre.encrypt(PK, policy, k)
CTt = tbpre.reencrypt(PK, H, s, CT, currentDate)
PT = tbpre.decrypt(CTt, alice)
assert k == PT, 'FAILED DECRYPTION!'
print('SUCCESSFUL DECRYPTION')
def main():
global group
group = PairingGroup("SS512")
alphabet = ['a', 'b']
dfa = DFA("ab*a", alphabet)
builtinFuncs_dfa.DFAObj = dfa
dfaM = dfa.constructDFA()
(mpk, msk) = setup(alphabet)
Q, S, T, q0, F = dfaM
(blindingFactor0Blinded, skBlinded) = keygen(mpk, msk, Q, T, F)
w = dfa.getSymbols("abbba")
M = group.random(GT)
print("M :", M)
ct = encrypt(mpk, w, M)
(transformOutputList, Ti) = transform(skBlinded, ct, dfaM)
origM = decout(transformOutputList, blindingFactor0Blinded, Ti, dfaM)
print("rec M :", origM)
assert M == origM, "failed decryption"
print("SUCCESSFUL DECRYPTION!!!")
def main():
global group
group = PairingGroup("SS512")
max_attributes = 6
required_overlap = 4
#(master_public_key, master_key) = setup(max_attributes, required_overlap)
(master_public_key, master_key) = setup(max_attributes)
private_identity = [
'insurance', 'id=2345', 'oncology', 'doctor', 'nurse', 'JHU'
] #private identity
public_identity = [
'insurance', 'id=2345', 'doctor', 'oncology', 'JHU', 'billing', 'misc'
] #public identity for encrypt
(blindingFactor0Blinded,
skBlinded) = extract(master_key, private_identity, master_public_key,
required_overlap, max_attributes)
msg = group.random(GT)
cipher_text = encrypt(master_public_key, public_identity, msg,
max_attributes)
#decrypted_msg = decrypt(master_public_key, secret_key, cipher_text, required_overlap)
(transformOutputList, SKeys, SLen) = transform(master_public_key,
skBlinded, cipher_text,
required_overlap)
decrypted_msg = decout(master_public_key, required_overlap,
transformOutputList, blindingFactor0Blinded, SKeys,
SLen)
print("msg: ", msg)
print("decrypted_msg: ", decrypted_msg)
assert msg == decrypted_msg, "failed decryption!"
print("Successful Decryption!")
def test():
# Just testing
G = PairingGroup('SS512')
IDS = OkamotoEph(G)
g = G.random(G1, 2)
sk = G.random(ZR, 2)
pk = g[0]**sk[0] * g[1]**sk[1]
p = {'sk': sk, 'g': g}
v = {'pk': pk, 'g': g}
v.update(IDS.commit(p))
p.update(IDS.challenge(v))
v.update(IDS.answer(p))
print(IDS.verify(v))
def main():
groupObj = PairingGroup('SS512')
cpabe = TrapAC(groupObj)
attrs = ['ONE', 'TWO', 'THREE']
access_policy = '((four AND two) OR (three AND one))'
valid_attr = ['ONE', 'THREE'] # attribute in period time
if debug:
print("Attributes =>", attrs)
print("Policy =>", access_policy)
(pk, mk) = cpabe.setup()
sk = cpabe.keygen(pk, mk, attrs)
# print("sk :=>", sk)
rand_msg = groupObj.random(GT)
if debug: print("msg =>", rand_msg)
ct = cpabe.encrypt(pk, rand_msg, access_policy)
if debug: print("\n\nCiphertext...\n")
groupObj.debug(ct)
rect = cpabe.proxy_decrypt(pk, sk, ct, valid_attr)
if debug: print("\n\nproxy_decrypt...\n")
rec_msg = cpabe.decrypt(pk, sk, rect)
if debug: print("\n\nDecrypt...\n")
if debug: print("Rec msg =>", rec_msg)
assert rand_msg == rec_msg, "FAILED Decryption: message is incorrect"
if debug: print("Successful Decryption!!!")
def main():
global group
group = PairingGroup("SS512")
attrs = ["ONE", "TWO", "THREE"]
access_policy = "((four or three) and (two or one))"
# print("Attributes =>", attrs); print("Policy =>", access_policy)
(mk, pk) = setup()
sk = keygen(pk, mk, attrs)
# print("sk :=>", sk)
rand_msg = group.random(GT)
print("msg =>", rand_msg)
ct = encrypt(pk, rand_msg, access_policy)
# print("\n\nCiphertext...\n")
group.debug(ct)
rec_msg = decrypt(pk, sk, ct)
# print("\n\nDecrypt...\n")
print("Rec msg =>", rec_msg)
assert rand_msg == rec_msg, "FAILED Decryption: message is incorrect"
print("Successful Decryption!!!")
def main():
groupObj = PairingGroup('SS512')
dabe = Dabe(groupObj)
GP = dabe.setup()
#Setup an authority
auth_attrs= ['ONE', 'TWO', 'THREE', 'FOUR']
(SK, PK) = dabe.authsetup(GP, auth_attrs)
if debug: print("Authority SK")
if debug: print(SK)
#Setup a user and give him some keys
gid, K = "bob", {}
usr_attrs = ['THREE', 'ONE', 'TWO']
for i in usr_attrs: dabe.keygen(GP, SK, i, gid, K)
if debug: print('User credential list: %s' % usr_attrs)
if debug: print("\nSecret key:")
if debug: groupObj.debug(K)
#Encrypt a random element in GT
m = groupObj.random(GT)
policy = '((one or three) and (TWO or FOUR))'
if debug: print('Acces Policy: %s' % policy)
CT = dabe.encrypt(PK, GP, m, policy)
if debug: print("\nCiphertext...")
if debug: groupObj.debug(CT)
orig_m = dabe.decrypt(GP, K, CT)
assert m == orig_m, 'FAILED Decryption!!!'
if debug: print('Successful Decryption!')
def basicTest():
print("RUN basicTest")
groupObj = PairingGroup('SS512')
maabe = MAABE(groupObj)
GPP, GMK = maabe.setup()
users = {} # public user data
authorities = {}
authorityAttributes = ["ONE", "TWO", "THREE", "FOUR"]
authority1 = "authority1"
maabe.setupAuthority(GPP, authority1, authorityAttributes, authorities)
alice = {'id': 'alice', 'authoritySecretKeys': {}, 'keys': None}
alice['keys'], users[alice['id']] = maabe.registerUser(GPP)
for attr in authorityAttributes[0:-1]:
maabe.keygen(GPP, authorities[authority1], attr, users[alice['id']],
alice['authoritySecretKeys'])
k = groupObj.random(GT)
policy_str = '((ONE or THREE) and (TWO or FOUR))'
CT = maabe.encrypt(GPP, policy_str, k, authorities[authority1])
PT = maabe.decrypt(GPP, CT, alice)
# print "k", k
# print "PT", PT
assert k == PT, 'FAILED DECRYPTION!'
print('SUCCESSFUL DECRYPTION')
def main():
global benchmarkResult, options
options=parse_args()
# SS512 : a symmertic curve with a 512-bit base field
# MNT159 : an asymmetric curve with a 159-bit based field
groupObj = PairingGroup ('SS512')
generator = groupObj.random(G1)
# for optimization
assert generator.initPP(), "failed to init pre-computation table"
# initialize key server and user objects
ks = KS (groupObj, generator)
user = User (groupObj, generator)
# set up key server
pk=ks.setup()
if options.output_file is not None:
rf=open(options.output_file, "w")
else:
rf=sys.stdout
rf.write ("#KB\tN.KS\tN.kss\tD1\tD2\tHash\tSE\tGroup\tKS\tTo.\tTo.(CR)\tTo.(SE)\n")
sys.stderr.write ("Run experiment...\n")
if options.file_size > 0:
file_size=[options.file_size]
for fsize in file_size:
# generate sample file
create_file (sample_file, fsize)
benchmarkResult={}
for count in range (0,options.trials, 1):
# compute a hash for a file
h=user.computeHash(sample_file)
# generate tag and decryption key
t_F, dk_F = user.generate_key_and_tag(pk, h, ks)
# encrypt a file
C1,C2,C3=user.encrypt (t_F,pk,sample_file,h)
delay_Hash=round(benchmarkResult['Hash']*1000/options.trials,2)
delay_SE=round(benchmarkResult['SE']*1000/options.trials,2)
delay_Group=round(benchmarkResult['Group']*1000/options.trials,2)
delay_KS=round(benchmarkResult['KS']*1000/options.trials,2)
delay_total=round(delay_Hash+delay_SE+delay_Group+delay_KS,2)
delay_total_cr=round(delay_Hash+delay_Group+delay_KS,2)
delay_total_SE=delay_SE
rf.write("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11}\n".format(\
int(fsize/1024), options.num_of_KS, options.num_of_kss, options.KS_delay1, options.KS_delay2,\
delay_Hash, delay_SE, delay_Group, delay_KS,delay_total,delay_total_cr,delay_total_SE))
rf.close()
def benchmark():
groupObj1 = PairingGroup('MNT224')
groupObj2 = PairingGroup('MNT224')
ekpabe = EKPabe(groupObj1)
kpabe = KPabe(groupObj2)
t1_s = 0
t1_k = 0
t1_e = 0
t1_d = 0
t2_s = 0
t2_k = 0
t2_e = 0
t2_d = 0
attributes = ['ONE', 'TWO', 'THREE', 'FOUR']
policy = 'THREE and (ONE or TWO)'
msg1 = b"Some Random Message"
msg2 = groupObj2.random(GT)
for b in range(4):
start = clock()
(epk, emk) = ekpabe.setup(attributes)
t1_s += clock() - start
start = clock()
(pk, mk) = kpabe.setup()
t2_s += clock() - start
start = clock()
emykey = ekpabe.keygen(epk, emk, policy)
t1_k += clock() - start
start = clock()
mykey = kpabe.keygen(pk, mk, policy)
t2_k += clock() - start
for i in range(50):
start = clock()
eciphertext = ekpabe.encrypt(epk, msg1, attributes)
t1_e += clock() - start
start = clock()
ciphertext = kpabe.encrypt(pk, msg2, attributes)
t2_e += clock() - start
start = clock()
erec_msg = ekpabe.decrypt(eciphertext, emykey)
t1_d += clock() - start
start = clock()
rec_msg = kpabe.decrypt(ciphertext, mykey)
t2_d += clock() - start
assert msg1 == erec_msg
assert msg2 == rec_msg
print("yct14 s=%s k=%s e=%s d=%s" % (t1_s, t1_k, t1_e, t1_d))
print("lsw08 s=%s k=%s e=%s d=%s" % (t2_s, t2_k, t2_e, t2_d))
def test(number_of_attr, split_attributes):
group = PairingGroup('SS512')
msg = group.random(GT)
g1, g2 = group.random(G1), group.random(G2)
alpha, a = group.random(), group.random()
cpabe = CPabe09(group)
(master_secret_key, master_public_key) = cpabe.setup(g1, g2, alpha, a)
attr_list = ['ATTR' + str(n) for n in range(number_of_attr)]
policy = '(' + ' and '.join(attr_list[:split_attributes]) + \
') and (' + ' or '.join(attr_list[split_attributes:]) + ')'
secret_key = cpabe.keygen(master_public_key, master_secret_key, attr_list)
cypher_text = cpabe.encrypt(master_public_key, msg, policy)
decrypted_msg = cpabe.decrypt(master_public_key, secret_key, cypher_text)
def MsgTestAESCBCSeperate(self, msg):
groupObj = PairingGroup('SS512')
ran = groupObj.random(GT)
a = AuthenticatedCryptoAbstraction(sha1(ran))
ct = a.encrypt(msg)
b = AuthenticatedCryptoAbstraction(sha1(ran))
dmsg = b.decrypt(ct)
assert msg == dmsg, 'o: =>%s\nm: =>%s' % (msg, dmsg)
def main(argv):
HOST, PORT = "", 8090
party_info = {}
if argv[1] == '-p':
print("Operating as prover...")
prover_sock = socket(AF_INET, SOCK_STREAM)
prover_sock.connect((HOST, PORT))
prover_sock.settimeout(15)
user = '******'
party_info['socket'] = prover_sock
elif argv[1] == '-v':
print("Operating as verifier...")
svr = socket(AF_INET, SOCK_STREAM)
svr.bind((HOST, PORT))
svr.listen(1)
verifier_sock, addr = svr.accept()
print("Connected by ", addr)
user = '******'
party_info['socket'] = verifier_sock
else:
print("ERROR!")
exit(-1)
group = PairingGroup('a.param')
party_info['party'] = user
party_info['setting'] = group
# statement: '(h = g^x) and (j = g^y)'
if(user == 'prover'):
g = group.random(G1)
x,y = group.random(ZR), group.random(ZR)
pk = {'h':g ** x, 'g':g, 'j':g**y}
sk = {'x':x, 'y':y}
# pk = {'h':g**x, 'g':g}
# sk = {'x':x, 'y':y}
result = executeIntZKProof(pk, sk, '(h = g^x) and (j = g^y)', party_info)
print("Results for PROVER =>", result)
elif(user == 'verifier'):
# verifier shouldn't have this information
# pk = {'h':1, 'g':1, 'j':1}
# sk = {'x':1, 'y':1}
pk = {'h':1, 'g':1, 'j':1}
sk = {'x':1}
result = executeIntZKProof(pk, sk, '(h = g^x) and (j = g^y)', party_info)
print("Results for VERIFIER =>", result)
class Context:
def __init__(self):
self.group = PairingGroup('MNT159')
self.g1 = self.group.random(G1)
self.g2 = self.group.random(G2)
self.gt = pair(self.g1, self.g2)
def testPairingGroup(self):
groupobj = PairingGroup('SS512')
p=groupobj.random()
data={'p':p,'String':"foo",'list':[p,{},1,1.7, b'dfa',]}
x=objectToBytes(data,groupobj)
data2=bytesToObject(x,groupobj)
self.assertEqual(data,data2)
def MsgTestAESCBCSeperate(self,msg):
groupObj = PairingGroup('SS512')
ran = groupObj.random(GT)
a = AuthenticatedCryptoAbstraction(sha1(ran))
ct = a.encrypt(msg)
b = AuthenticatedCryptoAbstraction(sha1(ran))
dmsg = b.decrypt(ct);
assert msg == dmsg , 'o: =>%s\nm: =>%s' % (msg, dmsg)
def tes():
group = PairingGroup('SS512')
g, gp = group.random(G1), group.random(G2)
alpha, beta = group.random(ZR), group.random(ZR)
# initialize pre-processing for generators
print g,gp
g.initPP()
gp.initPP()
print gp
print g
e_gg_alpha = pair(g, gp ** alpha)
e_gg_alpha2 = pair(g,gp) ** alpha
if e_gg_alpha == e_gg_alpha2:
print 'true'
else:
print 'false'
class AttributeAuthority:
'''
The attribtue authority class that encapsulates the master key used to generate
the single public key and user private keys
'''
def __init__(self):
self.groupObj = PairingGroup('SS512') # MNT224, SS512, MNT159, SS1024
self.cpabe = CPabe_BSW07(self.groupObj)
(self.public, self.master) = self.cpabe.setup()
# later functionality would include a thread that periodically updates the keys when needed
def set(self, master, public):
self.master = master
self.public = public
def getValues(self):
return (self.master, self.public)
def generateUserKey(self, attributes):
return self.cpabe.keygen(self.public, self.master, attributes)
def getPublicKey(self):
return self.public
def encrypt(self, plaintext, policy):
#return self.cpabe.encrypt(self.public, plaintext, policy)
key = self.groupObj.random(GT)
c1 = self.cpabe.encrypt(self.public, key, policy)
# instantiate a symmetric enc scheme from this key
cipher = AuthenticatedCryptoAbstraction(sha1(key))
c2 = cipher.encrypt(plaintext)
return { 'c1':c1, 'c2':c2 }
def decrypt(self, sKey, ciphertext):
#return self.cpabe.decrypt(self.public, sKey, ciphertext)
c1, c2 = ciphertext['c1'], ciphertext['c2']
success = True
# TODO: we need to supress the print statement that comes out of this guy, to avoid unnecessary events
try:
key = self.cpabe.decrypt(self.public, sKey, c1)
if (key == False):
success = False
except:
success = False
# Try to perform the encryption if we were able to recover the key
plaintext = None
if (success == True):
cipher = AuthenticatedCryptoAbstraction(sha1(key))
plaintext = cipher.decrypt(c2)
return (success, plaintext)
def main():
group = PairingGroup('MNT224', secparam=1024)
ibe = IBE_Chen12_z(group)
(master_public_key, master_secret_key) = ibe.setup()
ID = '*****@*****.**'
private_key = ibe.extract(master_secret_key, ID)
msg = group.random(GT)
cipher_text = ibe.encrypt(master_public_key, ID, msg)
decryptedMSG = ibe.decrypt(master_public_key, private_key, cipher_text)
print (decryptedMSG==msg)
def CPABE():
group = PairingGroup('SS512')
cpabe = CPabe_BSW07(group)
(pk,mk) = cpabe.setup()
policy = 'ID1 or ID2 or ID3'
asl =['ID1']
msg = group.random(GT)
ct = cpabe.encrypt(pk,msg,policy)
sk = cpabe.keygen(pk,mk,asl)
plaintext = cpabe.decrypt(pk,sk,ct)
print plaintext
print msg
def main():
group = PairingGroup('MNT224')
waters_hash = Waters(group)
ibe = IBE_N04_z(group)
(master_public_key, master_key) = ibe.setup()
ID = "*****@*****.**"
secret_key = ibe.extract(master_key, ID)
msg = group.random(GT)
cipher_text = ibe.encrypt(master_public_key, ID, msg)
decrypted_msg = ibe.decrypt(master_public_key, secret_key, cipher_text)
assert msg == decrypted_msg, "invalid decryption"
if debug: print("Successful Decryption!")
def testInterleave(self):
trials = 10
trials2 = trials * 3
group1 = PairingGroup("MNT224")
group2 = PairingGroup("MNT224")
g = group1.random(G1)
h = group1.random(G1)
i = group1.random(G2)
self.assertTrue(group1.InitBenchmark())
self.assertTrue(group2.InitBenchmark())
group1.StartBenchmark(["RealTime", "Exp", "Pair", "Div", "Mul"])
for a in range(trials):
j = g * h
k = i ** group1.random(ZR)
t = (j ** group1.random(ZR)) / h
n = pair(h, i)
group1.EndBenchmark()
msmtDict = group1.GetGeneralBenchmarks()
del group1, group2
self.assertTrue(isSaneBenchmark(msmtDict))
def main():
#group = PairingGroup('MNT159', secparam=1024)
G = PairingGroup('SS512')
ibe = IBE_BB04_m(G)
(master_public_key, master_secret_key) = ibe.setup()
ID = '*****@*****.**'
private_key = ibe.extract(master_secret_key, ID)
msg = G.random(GT)
cipher_text = ibe.encrypt(master_public_key, ID, msg)
decryptedMSG = ibe.decrypt(master_public_key, private_key, cipher_text)
print (decryptedMSG==msg)
def main():
global group
group = PairingGroup(secparam)
gpk = setup()
(msk, pk) = authsetup(gpk, ['ONE', 'TWO', 'THREE', 'FOUR'])
sk = keygen(gpk, msk, "*****@*****.**", ['ONE', 'TWO', 'THREE'])
M = group.random(GT)
ct = encrypt(pk, gpk, M, '((four or three) and (two or one))')
M2 = decrypt(sk, ct)
#'''
print(M)
print("\n\n\n")
print(M2)
def keygen(pk, msk, S):
group = PairingGroup('SS512')
attributes = [unicode(a) for a in S]
z = group.random()
r = group.random()
alpha = msk['alpha']
K0 = ((pk['g'] ** alpha) * (pk['w'] ** r)) ** (1/z)
K1 = pk['g'] ** (r/z)
K_x_2, K_x_3 = {},{}
for attr in attributes:
ri = group.random()
K_x_2[attr] = pk['g'] ** (ri/z)
K_x_2[attr] = objectToBytes(K_x_2[attr], group)
K_x_3[attr] = ((((pk['u'] ** group.hash(unicode(attr),ZR))) * pk['h']) ** (ri/z)) * (pk['v'] ** (-r/z))
K_x_3[attr] = objectToBytes(K_x_3[attr], group)
ik = {'S':S,
'K0':objectToBytes(K0, group),
'K1':objectToBytes(K1, group),
'Ki2':K_x_2,
'Ki3':K_x_3}
sk = objectToBytes(z, group)
return {'ik':ik, 'sk':sk}
def testCommitment_GS08(self):
groupObj = PairingGroup('SS512')
cm = Commitment_GS08(groupObj)
pk = cm.setup()
if debug:
print("Public parameters...")
print("pk =>", pk)
m = groupObj.random(G1)
if debug: print("Committing to =>", m)
(c, d) = cm.commit(pk, m)
assert cm.decommit(pk, c, d, m), "FAILED to decommit"
if debug: print("Successful and Verified decommitment!!!")
def pre_enc(P, pk=None, pool=None):
group = PairingGroup('SS512')
if pk is None:
pk = getPK(stsConfig['TS_ip'],stsConfig['api_getPK'])
if type(pk['g']) == type(''):
pk = dictToObject(pk_dict=pk, group=group)
if pool is None or not pool.has_key('s') or not pool.has_key('key') or not pool.has_key('C0'):
pool = {'components':[]}
s = group.random()
pool['s'] = s
pool['key'] = pk['eggalpha'] ** s
pool['C0'] = pk['g'] ** s
for j in range(P):
component = {}
component['lambda_prime_j'] = group.random()
component['t_j'] = group.random()
component['x_j'] = group.random()
component['C_j_1'] = (pk['w'] ** component['lambda_prime_j']) * (pk['v'] ** component['t_j'])
component['C_j_2'] = ((pk['u'] ** component['x_j']) * pk['h']) ** (-component['t_j'])
component['C_j_3'] = pk['g'] ** component['t_j']
pool['components'].append(component)
return pool
def main():
group = PairingGroup('MNT160')
max_attributes = 6
required_overlap = 4
ibe = IBE_SW05_LUC(group)
(master_public_key, master_key) = ibe.setup(max_attributes, required_overlap)
private_identity = ['insurance', 'id=2345', 'oncology', 'doctor', 'nurse', 'JHU'] #private identity
public_identity = ['insurance', 'id=2345', 'doctor', 'oncology', 'JHU', 'billing', 'misc'] #public identity for encrypt
(pub_ID_hashed, secret_key) = ibe.extract(master_key, private_identity, master_public_key, required_overlap, max_attributes)
msg = group.random(GT)
cipher_text = ibe.encrypt(master_public_key, public_identity, msg, max_attributes)
decrypted_msg = ibe.decrypt(master_public_key, secret_key, cipher_text, pub_ID_hashed, required_overlap)
print("msg: ", msg)
print("decrypted_msg: ", decrypted_msg)
assert msg == decrypted_msg, "failed decryption!"
print("Successful Decryption!")
def main():
global group
group = PairingGroup("SS512")
(mpk, mk) = setup(5, 32)
(pkBlinded, blindingFactor0Blinded, skBlinded) = keygen(mpk, mk, "test")
M = group.random(GT)
print(M)
print("\n\n\n")
ct = encrypt(mpk, pkBlinded, M)
transformOutputList = transform(pkBlinded, skBlinded, ct)
M2 = decout(pkBlinded, skBlinded, ct, transformOutputList, blindingFactor0Blinded)
print(M2)
if (M == M2):
print("it worked")
def testIBE_CKRS(self):
groupObj = PairingGroup('SS512')
ibe = IBE_CKRS(groupObj)
(mpk, msk) = ibe.setup()
# represents public identity
ID = "*****@*****.**"
sk = ibe.extract(mpk, msk, ID)
M = groupObj.random(GT)
ct = ibe.encrypt(mpk, ID, M)
m = ibe.decrypt(mpk, sk, ct)
if debug: print('m =>', m)
assert m == M, "FAILED Decryption!"
if debug: print("Successful Decryption!!! m => '%s'" % m)
def main():
global group
group = PairingGroup(secparam)
(mpk, msk) = setup(5, 32)
(blindingFactord0Blinded, skBlinded) = extract(mpk, msk, "test")
M = group.random(GT)
print(M)
print("\n\n\n")
ct = encrypt(mpk, M, "test")
transformOutputList = transform(skBlinded, ct)
M2 = decout(skBlinded, ct, transformOutputList, blindingFactord0Blinded)
print(M2)
if M == M2:
print("it worked")