charm-crypto-framework 0.61.1__cp313-cp313-macosx_10_13_universal2.whl

charm/schemes/abenc/abenc_maabe_yj14.py

@@ -0,0 +1,297 @@
+'''
+**Multi-Authority ABE for Cloud Storage (YJ14)**
+
+*Authors:* Kan Yang, Xiaohua Jia
+
+| **Title:** "Expressive, Efficient, and Revocable Data Access Control for Multi-Authority Cloud Storage"
+| **Published in:** IEEE Transactions on Parallel and Distributed Systems, Volume 25, Issue 7, 2014
+| **Available from:** http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=6620875
+| **Notes:** Supports expressive access policies with efficient revocation
+
+.. rubric:: Scheme Properties
+
+* **Type:** ciphertext-policy attribute-based encryption (public key)
+* **Setting:** Pairing groups
+* **Assumption:** Decisional Bilinear Diffie-Hellman
+
+.. rubric:: Implementation
+
+:Authors: artjomb
+:Date: 07/2014
+'''
+
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,GT,pair
+from charm.toolbox.secretutil import SecretUtil
+from charm.toolbox.ABEncMultiAuth import ABEncMultiAuth
+
+class MAABE(object):
+    def __init__(self, groupObj):
+        self.util = SecretUtil(groupObj, verbose=False)  #Create Secret Sharing Scheme
+        self.group = groupObj    #:Prime order group
+    
+    def setup(self):
+        '''Global Setup (executed by CA)'''
+        #:In global setup, a bilinear group G of prime order p is chosen
+        #:The global public parameters, GP and p, and a generator g of G. A random oracle H maps global identities GID to elements of G
+    
+        #:group contains 
+        #:the prime order p is contained somewhere within the group object
+        g = self.group.random(G1)
+        #: The oracle that maps global identities GID onto elements of G
+        #:H = lambda str: g** group.hash(str)
+        H = lambda x: self.group.hash(x, G1)
+        a = self.group.random()
+        b = self.group.random()
+        g_a = g ** a
+        g_b = g ** b
+        GPP = {'g': g, 'g_a': g_a, 'g_b': g_b, 'H': H}
+        GMK = {'a': a, 'b': b}
+        
+        return (GPP, GMK)
+    
+    def registerUser(self, GPP):
+        '''Generate user keys (executed by the user).'''
+        g = GPP['g']
+        ugsk1 = self.group.random()
+        ugsk2 = self.group.random()
+        ugpk1 = g ** ugsk1
+        ugpk2 = g ** ugsk2
+        
+        return ((ugpk1, ugsk2), { 'pk': ugpk2, 'sk': ugsk1 }) # (private, public)
+    
+    def setupAuthority(self, GPP, authorityid, attributes, authorities):
+        '''Generate attribute authority keys (executed by attribute authority)'''
+        if authorityid not in authorities:
+            alpha = self.group.random()
+            beta = self.group.random()
+            gamma = self.group.random()
+            SK = {'alpha': alpha, 'beta': beta, 'gamma': gamma}
+            PK = {
+                'e_alpha': pair(GPP['g'], GPP['g']) ** alpha, 
+                'g_beta': GPP['g'] ** beta, 
+                'g_beta_inv': GPP['g'] ** ~beta
+            }
+            authAttrs = {}
+            authorities[authorityid] = (SK, PK, authAttrs)
+        else:
+            SK, PK, authAttrs = authorities[authorityid]
+        for attrib in attributes:
+            if attrib in authAttrs:
+                continue
+            versionKey = self.group.random() # random or really 'choose' ?
+            h = GPP['H'](attrib)
+            pk = h ** versionKey
+            authAttrs[attrib] = {
+                'VK': versionKey, #secret
+                'PK1': pk, #public
+                'PK2': pk ** SK['gamma'] #public
+            }
+        return (SK, PK, authAttrs)
+     
+    def keygen(self, GPP, authority, attribute, userObj, USK = None):
+        '''Generate user keys for a specific attribute (executed on attribute authority)'''
+        if 't' not in userObj:
+            userObj['t'] = self.group.random() #private to AA
+        t = userObj['t']
+        
+        ASK, APK, authAttrs = authority
+        u = userObj
+        if USK is None:
+            USK = {}
+        if 'K' not in USK or 'KS' not in USK or 'AK' not in USK:
+            USK['K'] = \
+                (GPP['g'] ** ASK['alpha']) * \
+                (GPP['g_a'] ** u['sk']) * \
+                (GPP['g_b'] ** t)
+            USK['KS'] = GPP['g'] ** t
+            USK['AK'] = {}
+        AK = (u['pk'] ** (t * ASK['beta'])) * \
+            ((authAttrs[attribute]['PK1'] ** ASK['beta']) ** (u['sk'] + ASK['gamma']))
+        USK['AK'][attribute] = AK
+        return USK
+    
+    def encrypt(self, GPP, policy_str, k, authority):
+        '''Generate the cipher-text from the content(-key) and a policy (executed by the content owner)'''
+        #GPP are global parameters
+        #k is the content key (group element based on AES key)
+        #policy_str is the policy string
+        #authority is the authority tuple
+        
+        _, APK, authAttrs = authority
+        
+        policy = self.util.createPolicy(policy_str)
+        secret = self.group.random()
+        shares = self.util.calculateSharesList(secret, policy)
+        shares = dict([(x[0].getAttributeAndIndex(), x[1]) for x in shares])
+        
+        C1 = k * (APK['e_alpha'] ** secret)
+        C2 = GPP['g'] ** secret
+        C3 = GPP['g_b'] ** secret
+        C = {}
+        CS = {}
+        D = {}
+        DS = {}
+        
+        for attr, s_share in shares.items():
+            k_attr = self.util.strip_index(attr)
+            r_i = self.group.random()
+            attrPK = authAttrs[attr]
+            C[attr] = (GPP['g_a'] ** s_share) * ~(attrPK['PK1'] ** r_i)
+            CS[attr] = GPP['g'] ** r_i
+            D[attr] = APK['g_beta_inv'] ** r_i
+            DS[attr] = attrPK['PK2'] ** r_i
+        
+        return {'C1': C1, 'C2': C2, 'C3': C3, 'C': C, 'CS': CS, 'D': D, 'DS': DS, 'policy': policy_str}
+        
+    def decrypt(self, GPP, CT, user):
+        '''Decrypts the content(-key) from the cipher-text (executed by user/content consumer)'''
+        UASK = user['authoritySecretKeys']
+        USK = user['keys']
+        usr_attribs = list(UASK['AK'].keys())
+        policy = self.util.createPolicy(CT['policy'])
+        pruned = self.util.prune(policy, usr_attribs)
+        if pruned == False:
+            return False
+        coeffs = self.util.getCoefficients(policy)
+        
+        first = pair(CT['C2'], UASK['K']) * ~pair(CT['C3'], UASK['KS'])
+        n_a = 1
+        
+        ugpk1, ugsk2 = USK
+        e_gg_auns = 1
+        
+        for attr in pruned:
+            x = attr.getAttributeAndIndex()
+            y = attr.getAttribute()
+            temp = \
+                pair(CT['C'][y], ugpk1) * \
+                pair(CT['D'][y], UASK['AK'][y]) * \
+                pair(CT['CS'][y], ~(UASK['KS'] ** ugsk2)) * \
+                ~pair(GPP['g'], CT['DS'][y])
+            e_gg_auns *= temp ** (coeffs[x] * n_a)
+        return CT['C1'] / (first / e_gg_auns)
+    
+    def ukeygen(self, GPP, authority, attribute, userObj):
+        '''Generate update keys for users and cloud provider (executed by attribute authority?)'''
+        ASK, _, authAttrs = authority
+        oldVersionKey = authAttrs[attribute]['VK']
+        newVersionKey = oldVersionKey
+        while oldVersionKey == newVersionKey:
+            newVersionKey = self.group.random()
+        authAttrs[attribute]['VK'] = newVersionKey
+        
+        u_uid = userObj['sk']
+        UKs = GPP['H'](attribute) ** (ASK['beta'] * (newVersionKey - oldVersionKey) * (u_uid + ASK['gamma']))
+        UKc = (newVersionKey/oldVersionKey, (oldVersionKey - newVersionKey)/(oldVersionKey * ASK['gamma']))
+        
+        authAttrs[attribute]['PK1'] = authAttrs[attribute]['PK1'] ** UKc[0]
+        authAttrs[attribute]['PK2'] = authAttrs[attribute]['PK2'] ** UKc[0]
+        
+        return { 'UKs': UKs, 'UKc': UKc }
+    
+    def skupdate(self, USK, attribute, UKs):
+        '''Updates the user attribute secret key for the specified attribute (executed by non-revoked user)'''
+        USK['AK'][attribute] = USK['AK'][attribute] * UKs
+    
+    def ctupdate(self, GPP, CT, attribute, UKc):
+        '''Updates the cipher-text using the update key, because of the revoked attribute (executed by cloud provider)'''
+        CT['C'][attribute] = CT['C'][attribute] * (CT['DS'][attribute] ** UKc[1])
+        CT['DS'][attribute] = CT['DS'][attribute] ** UKc[0]
+
+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 revokedTest():
+    print("RUN revokedTest")
+    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)
+    
+    bob = { 'id': 'bob', 'authoritySecretKeys': {}, 'keys': None }
+    bob['keys'], users[bob['id']] = maabe.registerUser(GPP)
+    
+    for attr in authorityAttributes[0:-1]:
+        maabe.keygen(GPP, authorities[authority1], attr, users[alice['id']], alice['authoritySecretKeys'])
+        maabe.keygen(GPP, authorities[authority1], attr, users[bob['id']], bob['authoritySecretKeys'])
+    
+    k = groupObj.random(GT)
+    
+    policy_str = '((ONE or THREE) and (TWO or FOUR))'
+    
+    CT = maabe.encrypt(GPP, policy_str, k, authorities[authority1])
+    
+    PT1a = maabe.decrypt(GPP, CT, alice)
+    PT1b = maabe.decrypt(GPP, CT, bob)
+    
+    assert k == PT1a, 'FAILED DECRYPTION (1a)!'
+    assert k == PT1b, 'FAILED DECRYPTION (1b)!'
+    print('SUCCESSFUL DECRYPTION 1')
+    
+    # revoke bob on "ONE"
+    attribute = "ONE"
+    UK = maabe.ukeygen(GPP, authorities[authority1], attribute, users[alice['id']])
+    maabe.skupdate(alice['authoritySecretKeys'], attribute, UK['UKs'])
+    maabe.ctupdate(GPP, CT, attribute, UK['UKc'])
+    
+    PT2a = maabe.decrypt(GPP, CT, alice)
+    PT2b = maabe.decrypt(GPP, CT, bob)
+    
+    assert k == PT2a, 'FAILED DECRYPTION (2a)!'
+    assert k != PT2b, 'SUCCESSFUL DECRYPTION (2b)!'
+    print('SUCCESSFUL DECRYPTION 2')
+
+def test():
+    groupObj = PairingGroup('SS512')
+    # k = groupObj.random()
+    #print "k", k, ~k, k * ~k
+    # g = groupObj.random(G1)
+    # print "g", g, pair(g, g)
+    # gt = groupObj.random(GT)
+    # print "gt", gt
+
+if __name__ == '__main__':
+    basicTest()
+    revokedTest()
+    # test()

charm/schemes/abenc/abenc_tbpre_lww14.py

@@ -0,0 +1,309 @@
+'''
+**Time-Based Proxy Re-Encryption (LWW14)**
+
+*Authors:* Qin Liu, Guojun Wang, Jie Wu
+
+| **Title:** "Time-based proxy re-encryption scheme for secure data sharing in a cloud environment"
+| **Published in:** Information Sciences, Volume 258, 2014
+| **Available from:** http://www.sciencedirect.com/science/article/pii/S0020025512006275
+| **Notes:** Time-based access control with proxy re-encryption for cloud storage
+
+.. rubric:: Scheme Properties
+
+* **Type:** ciphertext-policy attribute-based encryption (public key)
+* **Setting:** Pairing groups
+* **Assumption:** Decisional Bilinear Diffie-Hellman
+
+.. rubric:: Implementation
+
+:Authors: artjomb
+:Date: 07/2014
+'''
+
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,GT,pair
+from charm.toolbox.secretutil import SecretUtil
+
+from functools import reduce
+
+# taken from https://gist.github.com/endolith/114336
+def gcd(*numbers):
+    """Return the greatest common divisor of the given integers"""
+    import sys
+    if sys.version_info < (3, 5):
+        from fractions import gcd
+    else:
+        from math import gcd
+    return reduce(gcd, numbers)
+
+# taken from https://gist.github.com/endolith/114336
+def lcm(numbers):
+    """Return lowest common multiple."""    
+    def lcm(a, b):
+        return (a * b) // gcd(a, b)
+    return reduce(lcm, numbers, 1)
+
+class TBPRE(object):
+    def __init__(self, groupObj):
+        self.util = SecretUtil(groupObj, verbose=False)  #Create Secret Sharing Scheme
+        self.group = groupObj    #:Prime order group
+        #self.users = {}
+        #self.authorities = {}
+    
+    def setup(self, attributes):
+        '''Global Setup (executed by CA)'''
+        P0 = self.group.random(G1) # generator
+        P1 = self.group.random(G1) # random element
+        s = self.group.random()
+        mk0 = self.group.random()
+        mk1 = self.group.random()
+        Q0 = P0 ** mk0
+        SK1 = P1 ** mk0
+        
+        Htemp = lambda x, y: self.group.hash(x + y, ZR)
+        H = {
+            'user': lambda x: self.group.hash(str(x), ZR), # first convert G1 to str, then hash
+            'attr': lambda x: Htemp(x,"_attribute"),
+            'sy': lambda x: Htemp(x,"_year"),
+            'sym': lambda x: Htemp(x,"_year_month"),
+            'symd': lambda x: Htemp(x,"_year_month_day")
+        }
+        
+        PK = { 'A': {}, 'Q0': Q0, 'P0': P0, 'P1': P1 }
+        MK = { 'A': {}, 'mk0': mk0, 'mk1': mk1, 'SK1': SK1 }
+        for attribute in attributes:
+            ska = self.group.random()
+            PKa = P0 ** ska
+            PK['A'][attribute] = PKa
+            MK['A'][attribute] = ska
+        
+        #self.MK = MK # private
+        #self.s = s   # sent to cloud service provider
+        #self.PK = PK # public
+        
+        return (MK, PK, s, H)
+    
+    def registerUser(self, PK, H):
+        '''Registers a user by id (executed by user)'''
+        sku = self.group.random()
+        PKu = PK['P0'] ** sku
+        mku = H['user'](PKu)
+        
+        #self.users[userid] = { 'PKu': PKu, 'mku': mku }
+        return (sku, { 'PKu': PKu, 'mku': mku }) # (private, public)
+    
+    def hashDate(self, H, time, s):
+        hash = s
+        key = 'y'
+        if "year" in time:
+            hash = H['sy'](time['year']) ** hash
+        else:
+            print("Error: time has to contain at least 'year'")
+            return None, None
+        if "month" in time:
+            hash = H['sym'](time['month']) ** hash
+            key = 'ym'
+            if "day" in time:
+                hash = H['symd'](time['day']) ** hash
+                key = 'ymd'
+        elif "day" in time:
+            print("Error: time has to contain 'month' if it contains 'year'")
+            return None, None
+        return hash, key
+    
+    def timeSuffices(self, timeRange, needle):
+        # assumes that the time obj is valid
+        if timeRange['year'] != needle['year']:
+            return False
+        if 'month' not in timeRange:
+            return True
+        if 'month' not in needle:
+            return None # Error
+        if timeRange['month'] != needle['month']:
+            return False
+        if 'day' not in timeRange:
+            return True
+        if 'day' not in needle:
+            return None # Error
+        return timeRange['day'] == needle['day']
+    
+    def policyTerm(self, user, policy):
+        userAttributes = user['A'].keys()
+        for i, term in zip(range(len(policy)), policy):
+            notFound = False
+            for termAttr in term:
+                if termAttr not in userAttributes:
+                    notFound = True
+                    break
+            if not notFound:
+                return i
+        return False
+    
+    def keygen(self, MK, PK, H, s, user, pubuser, attribute, time):
+        '''Generate user keys for a specific attribute (executed by CA)'''
+        
+        hash, key = self.hashDate(H, time, s)
+        if hash is None:
+            return None
+        
+        if 'SKu' not in user:
+            user['SKu'] = PK['P0'] ** (MK['mk1'] * pubuser['mku'])
+        PKat = PK['A'][attribute] * (PK['P0'] ** hash)
+        SKua = MK['SK1'] * (PKat ** (MK['mk1'] * pubuser['mku']))
+        
+        if 'A' not in user:
+            user['A'] = {}
+        if attribute not in user['A']:
+            user['A'][attribute] = []
+        user['A'][attribute].append((time, SKua))
+    
+    def encrypt(self, PK, policy, F):
+        '''Generate the cipher-text from the content(-key) and a policy (executed by the content owner)'''
+        r = self.group.random()
+        nA = lcm(map(lambda x: len(x), policy))
+        U0 = PK['P0'] ** r
+        attributes = []
+        U = []
+        for term in policy:
+            Ui = 1
+            for attribute in term:
+                Ui *= PK['A'][attribute]
+            U.append(Ui ** r)
+        V = F * pair(PK['Q0'], PK['P1'] ** (r * nA))
+        return { 'A': policy, 'U0': U0, 'U': U, 'V': V, 'nA': nA }
+        
+    def decrypt(self, CT, user, term = None):
+        '''Decrypts the content(-key) from the cipher-text (executed by user/content consumer)'''
+        if term is None:
+            term = self.policyTerm(user, CT['A'])
+            if term is False:
+                print("Error: user attributes don't satisfy the policy")
+                return None
+        
+        sumSK = 1
+        for attribute in CT['A'][term]:
+            foundTimeSlot = False
+            for timeRange, SKua in user['A'][attribute]:
+                if self.timeSuffices(timeRange, CT['t']):
+                    foundTimeSlot = True
+                    sumSK *= SKua
+                    break
+            if not foundTimeSlot:
+                print("Error: could not find time slot in user attribute keys")
+                return None
+        
+        
+        n = CT['nA'] // len(CT['A'][term])
+        return CT['Vt'] / (pair(CT['U0t'], sumSK ** n) / pair(user['SKu'], CT['Ut']['year'][term] ** n)) # TODO: fix year
+    
+    def reencrypt(self, PK, H, s, CT, currentTime):
+        '''Re-encrypts the cipher-text using the current time (executed by cloud service provider)'''
+        if 'year' not in currentTime or 'month' not in currentTime or 'day' not in currentTime:
+            print("Error: pass proper current time containing 'year', 'month' and 'day'")
+            return None
+        
+        day = currentTime
+        month = dict(day)
+        del month['day']
+        year = dict(month)
+        del year['month']
+        
+        day, daykey = self.hashDate(H, day, s)
+        month, monthkey = self.hashDate(H, month, s)
+        year, yearkey = self.hashDate(H, year, s)
+        
+        rs = self.group.random()
+        U0t = CT['U0'] * (PK['P0'] ** rs)
+        
+        Ut = { 'year': [], 'month': [], 'day': [] }
+        for term, Ui in zip(CT['A'], CT['U']):
+            Uit_year = Ui
+            Uit_month = Ui
+            Uit_day = Ui
+            for attribute in term:
+                Uit_year *= (PK['A'][attribute] ** rs) * (U0t ** year)
+                Uit_month *= (PK['A'][attribute] ** rs) * (U0t ** month)
+                Uit_day *= (PK['A'][attribute] ** rs) * (U0t ** day)
+            Ut['year'].append(Uit_year)
+            Ut['month'].append(Uit_month)
+            Ut['day'].append(Uit_day)
+        
+        Vt = CT['V'] * pair(PK['Q0'], PK['P1'] ** (rs * CT['nA']))
+        
+        return { 'A': CT['A'], 'U0t': U0t, 'Ut': Ut, 'Vt': Vt, 'nA': CT['nA'], 't': currentTime }
+
+def basicTest():
+    print("RUN basicTest")
+    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)
+    alice2 = { 'id': 'alice2' }
+    alice2['sku'], users[alice2['id']] = tbpre.registerUser(PK, H)
+    
+    year = { 'year': "2014" }
+    pastYear = { 'year': "2013" }
+    
+    for attr in attributes[0:-1]:
+        tbpre.keygen(MK, PK, H, s, alice, users[alice['id']], attr, year)
+        tbpre.keygen(MK, PK, H, s, alice2, users[alice2['id']], attr, pastYear)
+    
+    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! 1'
+    print('SUCCESSFUL DECRYPTION 1')
+    
+    PT2 = tbpre.decrypt(CTt, alice2)
+    
+    assert k != PT2, 'SUCCESSFUL DECRYPTION! 2'
+    print('DECRYPTION correctly failed')
+
+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 test():
+    # print 1, lcm(1, 2)
+    print(2, lcm([1, 2]))
+
+if __name__ == '__main__':
+    basicTest()
+    # basicTest2()
+    # test()