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

charm/schemes/pksig/pksig_waters09.py

@@ -0,0 +1,121 @@
+'''
+**Waters Dual System Signature (Waters09)**
+
+*Authors:* B. Waters
+
+| **Title:** "Dual System Encryption: Realizing Fully Secure IBE and HIBE under Simple Assumptions"
+| **Published in:** CRYPTO, 2009
+| **Available from:** http://eprint.iacr.org/2009/385.pdf
+| **Notes:** Minor improvements: removed alpha from msk, added g2^-alpha.
+
+.. rubric:: Scheme Properties
+
+* **Type:** signature (identity-based)
+* **Setting:** bilinear groups (asymmetric)
+* **Assumption:** DLIN
+
+.. rubric:: Implementation
+
+:Authors: J. Ayo Akinyele (original), Fan Zhang (improvements)
+:Date: 2/2012 (original), 3/2013 (improvements)
+'''
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,GT,pair
+from charm.toolbox.IBEnc import IBEnc
+
+debug = False
+class IBEWaters09(IBEnc):
+    """
+    >>> group = PairingGroup('MNT224')
+    >>> ibe = IBEWaters09(group)
+    >>> (master_public_key, master_secret_key) = ibe.keygen()
+    >>> msg = "plese sign this message!!!!"
+    >>> signature = ibe.sign(master_public_key, master_secret_key, msg)
+    >>> ibe.verify(master_public_key, signature, msg)
+    True
+    """
+    def __init__(self, groupObj):
+        IBEnc.__init__(self)
+        global group, util
+        group = groupObj
+
+    def keygen(self):
+        g1 = group.random(G1)
+        g2 = group.random(G2)
+        a1, a2, b, alpha = group.random(ZR, 4)
+        _w, _h, _v, _v1, _v2, _u = group.random(ZR, 6)
+        
+        v = g1 ** _v 
+        v1 = g1 ** _v1 
+        v2 = g1 ** _v2
+        
+        v_2 = g2 ** _v
+        v1_2 = g2 ** _v1
+        v2_2 = g2 ** _v2
+        w1, h1 = g1 ** _w, g1 ** _h
+        w2, h2 = g2 ** _w, g2 ** _h
+        u2 = g2 ** _u
+        u1 = g1 ** _u
+        
+        tau1 = v * (v1 ** a1)
+        tau2 = v * (v2 ** a2)
+        pk = { 'g1':g1, 'g2':g2, 'g1^b':g1 ** b, 'g^a1':g1 ** a1, 'g^a2':g1 ** a2, 
+              'g^ba1':g1 ** (b * a1), 'g^ba2':g1 ** (b * a2), 'tau1':tau1, 'tau2':tau2, 
+              'tau1^b':tau1 ** b, 'tau2^b':tau2 ** b, 'u':u1, 'u2':u2,'w1':w1, 'h1':h1, 'w2':w2, 'h2':h2,
+              'egg_alpha': pair(g1, g2) ** (alpha * a1 * b) }
+        sk = {'g^alph_a1':g2 ** (alpha * a1),
+              'g2^b':g2 ** b,'v':v_2, 'v1':v1_2, 'v2':v2_2, 'g2^-alpha':g2 ** -alpha }
+        return (pk, sk)
+    
+    def sign(self, mpk, msk, m):
+        r1, r2, z1, z2, tagk = group.random(ZR, 5)
+        r = r1 + r2
+        M = group.hash(m)
+
+        S = {}
+        S[1] = msk['g^alph_a1'] * (msk['v'] ** r)
+        S[2] = msk['g2^-alpha'] * (msk['v1'] ** r) * (mpk['g2'] ** z1)
+        S[3] = msk['g2^b'] ** -z1
+        S[4] = (msk['v2'] ** r) * (mpk['g2'] ** z2)
+        S[5] = msk['g2^b'] ** -z2
+        S[6] = msk['g2^b'] ** r2
+        S[7] = mpk['g2'] ** r1
+        SK = ((mpk['u2'] ** M) * (mpk['w2'] ** tagk) * mpk['h2']) ** r1
+        
+        sigma = { 'sig':S, 'K':SK, 'tagk':tagk }
+        return sigma
+
+    def verify(self, mpk, sigma, m):
+        s1, s2, t, tagc = group.random(ZR, 4)
+        s = s1 + s2
+        M = group.hash(m)
+        
+        sig1, sig2, sig3, sig4, sig5, sig6, sig7, sigK, tagk = sigma['sig'][1],sigma['sig'][2],sigma['sig'][3],sigma['sig'][4],sigma['sig'][5],sigma['sig'][6],sigma['sig'][7],sigma['K'],sigma['tagk']
+        E1 = ((mpk['u'] ** M) * (mpk['w1'] ** tagc) * mpk['h1']) ** t
+        E2 = mpk['g1'] ** t
+        A = (mpk['egg_alpha'] ** s2)
+        theta =  ~(tagc - tagk)
+        
+        lhs_pair = pair(mpk['g1^b'] ** s, sig1) * pair(mpk['g^ba1'] ** s1, sig2) * pair(mpk['g^a1'] ** s1, sig3) * pair(mpk['g^ba2'] ** s2, sig4) * pair(mpk['g^a2'] ** s2, sig5)        
+        rhs_pair = pair((mpk['tau1'] ** s1) * (mpk['tau2'] ** s2), sig6) * pair((mpk['tau1^b'] ** s1) * (mpk['tau2^b'] ** s2) * (mpk['w1'] ** -t), sig7) * (( pair(E1, sig7) / pair(E2, sigK) ) ** theta) * A
+        if lhs_pair == rhs_pair:
+            return True
+        return False
+
+def main():
+    # scheme designed for symmetric billinear groups
+    grp = PairingGroup('MNT224')
+
+    ibe = IBEWaters09(grp)
+
+    (mpk, msk) = ibe.keygen()
+
+    m = "plese sign this message!!!!"
+    sigma = ibe.sign(mpk, msk, m)
+    if debug: print("Signature :=", sigma)
+
+    assert ibe.verify(mpk, sigma, m), "Invalid Verification!!!!"
+    if debug: print("Successful Individual Verification!")
+
+if __name__ == "__main__":
+    debug = True
+    main()

charm/schemes/pre_mg07.py

@@ -0,0 +1,150 @@
+'''
+**Identity-Based Proxy Re-Encryption (MG07)**
+
+*Authors:* Matthew Green, Giuseppe Ateniese
+
+| **Title:** "Identity-Based Proxy Re-Encryption"
+| **Published in:** Applied Cryptography and Network Security, 2007
+| **Available from:** http://link.springer.com/chapter/10.1007%2F978-3-540-72738-5_19
+| **Notes:** Section 4.3
+
+.. rubric:: Scheme Properties
+
+* **Type:** proxy re-encryption (identity-based)
+* **Setting:** bilinear groups (symmetric)
+* **Assumption:** DBDH
+
+.. rubric:: Implementation
+
+:Authors: N. Fotiou
+:Date: 11/2012
+'''
+from charm.toolbox.pairinggroup import pc_element,ZR,G1,G2,GT,pair
+from charm.core.math.integer import integer,bitsize, int2Bytes, randomBits
+from charm.toolbox.hash_module import Hash
+from charm.core.engine.util import objectToBytes
+
+debug = False
+class PreGA:
+    """
+    >>> from charm.toolbox.pairinggroup import PairingGroup,pc_element  
+    >>> ID = "nikos fotiou"
+    >>> ID2 = "test user"
+    >>> msg = "hello world!!!!!"
+    >>> group = PairingGroup('SS512', secparam=1024)  
+    >>> pre = PreGA(group)
+    >>> (master_secret_key, params) = pre.setup()
+    >>> id_secret_key = pre.keyGen(master_secret_key, ID)
+    >>> id2_secret_key = pre.keyGen(master_secret_key, ID2)
+    >>> ciphertext = pre.encrypt(params, ID, msg);
+    >>> pre.decryptFirstLevel(params,id_secret_key, ciphertext, ID)
+    b'hello world!!!!!'
+    >>> re_encryption_key = pre.rkGen(params,id_secret_key, ID, ID2)
+    >>> ciphertext2 = pre.reEncrypt(params, ID, re_encryption_key, ciphertext)
+    >>> pre.decryptSecondLevel(params,id2_secret_key,ID, ID2, ciphertext2)
+    b'hello world!!!!!'
+    """
+    def __init__(self, groupObj):
+        global group,h
+        group = groupObj
+        h = Hash(group) # use the default
+        
+    def setup(self):
+        s = group.random(ZR) 
+        g =  group.random(G1)
+        # choose H1-H6 hash functions
+        msk = { 's':s }
+        params = { 'g':g, 'g_s':g**s}
+        if(debug):
+            print("Public parameters...")
+            group.debug(params)
+            print("Master secret key...")
+            group.debug(msk)
+        return (msk, params)
+
+    def keyGen(self, msk, ID):
+        k = group.hash(ID,G1) ** msk['s']
+        skid = { 'skid':k }        
+        if(debug):
+            print("Key for id => '%s'" % ID)
+            group.debug(skid)
+        return skid
+
+    def encrypt(self, params, ID, M):
+        enc_M = integer(M)
+        if bitsize(enc_M)/8 > group.messageSize():
+            print("Message cannot be encoded.")
+            return None
+        sigma = group.random(GT)
+        r = h.hashToZr(sigma,enc_M)
+        A = params['g'] ** r 
+        B = sigma * pair(params['g_s'], group.hash(ID, G1) ** r)
+        C = enc_M ^ h.hashToZn(sigma)      
+        C_ = {'A':A, 'B':B, 'C':C}
+        S = group.hash((ID, C_),G1) ** r        
+        ciphertext = {'S':S,'C':C_}           
+        if(debug):
+            print('\nEncrypt...')
+            print('r => %s' % r)
+            print('sigma => %s' % sigma)
+            print('enc_M => %s' % enc_M)
+            group.debug(ciphertext)
+        return ciphertext
+        
+    def decryptFirstLevel(self, params, skid, cid, ID):
+        H = group.hash((ID, cid['C']), G1)
+        t = group.random(ZR)
+        sigma =  cid['C']['B'] / (pair(cid['C']['A'], skid['skid'] * H ** t)/pair(params['g'] ** t, cid['S']))
+        m =  cid['C']['C'] ^ h.hashToZn(sigma)
+        r = h.hashToZr(sigma,m)
+        if (cid['S'] != H**r) or (cid['C']['A'] != params['g'] ** r):
+            if debug: print("Decryption Failed")
+            return None 
+        if(debug):
+            print('\nDecrypting...')
+            print('H => %s' % H)
+            print('t => %s' % t)
+            print('r => %s' % r)
+            print('sigma => %s' % sigma)
+            print(int2Bytes(m))
+        return int2Bytes(m)
+    
+    def rkGen(self, params, skid, IDsrc, IDdest):
+        N = integer(randomBits(group.secparam))
+        K = pair(skid['skid'], group.hash(IDdest, G1))
+        if(debug):
+            print("\nRe-encryption key for id1 => '%s' to id2 => '%s'" % (IDsrc,IDdest))
+            group.debug(skid)
+            print('N => %s' % N)
+            print('K => %s' % K)
+        return  {'N':N, 'R':group.hash((K, IDsrc, IDdest, N), G1) * skid['skid']}
+        
+    def reEncrypt(self, params, IDsrc, rk, cid):
+        H = group.hash((IDsrc, cid['C']), G1)
+        if pair(params['g'], cid['S']) != pair(H, cid['C']['A']):
+            if debug: print("Re-encryption Failed")
+            return None                
+        t = group.random(ZR)
+        B_ = cid['C']['B'] / (pair(cid['C']['A'], rk['R'] * H ** t)/pair(params['g'] ** t, cid['S']))
+        if(debug):
+            print('\nRe-ncrypt...')
+            print('H => %s' % H)
+            print('t => %s' % t)
+            print('B\' => %s' % B_)
+        return {'A':cid['C']['A'], 'B':B_, 'C':cid['C']['C'], 'IDsrc':IDsrc, 'N':rk['N']}
+        
+    def decryptSecondLevel(self, params, skid, IDsrc, ID, cid):
+        K = pair(group.hash(IDsrc, G1), skid['skid'])
+        sigma = cid['B'] * pair(cid['A'], group.hash((K, IDsrc, ID, cid['N']), G1))
+        m = cid['C'] ^ h.hashToZn(sigma)
+        r = h.hashToZr(sigma,m)
+        if (cid['A'] != params['g'] ** r):
+            if debug: print("Decryption second level Failed")
+            return None 
+        if(debug):
+            print('\nDecrypting Second Level...')
+            print('K => %s' % K)
+            print('sigma => %s' % sigma)
+            print(int2Bytes(m)) 
+        return int2Bytes(m) 
+

charm/schemes/prenc/pre_afgh06.py

@@ -0,0 +1,126 @@
+'''
+**AFGH Proxy Re-Encryption (AFGH06)**
+
+*Authors:* Ateniese, Fu, Green, Hohenberger
+
+| **Title:** "Improved Proxy Re-Encryption Schemes with Applications to Secure Distributed Storage"
+| **Published in:** ACM Transactions on Information and System Security (TISSEC), 2006
+| **Available from:** http://dl.acm.org/citation.cfm?id=1127346
+| **Notes:** First-level encryption & second-level decryption not yet implemented
+
+.. rubric:: Scheme Properties
+
+* **Type:** proxy re-encryption
+* **Setting:** Pairing groups (Type 1 "symmetric")
+* **Assumption:** eDBDH (Extended Decisional Bilinear DH)
+* **Properties:** CPA-secure, unidirectional, single-hop, non-interactive, collusion-resistant
+
+.. rubric:: Implementation
+
+:Authors: D. Nuñez
+:Date: 04/2016
+'''
+
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,GT,pair
+from charm.toolbox.PREnc import PREnc
+
+debug = False
+class AFGH06(PREnc):
+    """
+    Testing AFGH06 implementation 
+
+    >>> from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,GT,pair
+    >>> groupObj = PairingGroup('SS512')
+    >>> pre = AFGH06(groupObj)
+    >>> params = pre.setup()
+    >>> (pk_a, sk_a) = pre.keygen(params)
+    >>> (pk_b, sk_b) = pre.keygen(params)
+    >>> msg = groupObj.random(GT)
+    >>> c_a = pre.encrypt(params, pk_a, msg)
+    >>> rk = pre.rekeygen(params, pk_a, sk_a, pk_b, sk_b)
+    >>> c_b = pre.re_encrypt(params, rk, c_a)
+    >>> assert msg == pre.decrypt(params, sk_b, c_b), 'Decryption of re-encrypted ciphertext was incorrect'
+    """
+
+    def __init__(self, groupObj):
+        global group
+        group = groupObj
+        
+    def setup(self):
+        g = group.random(G1)
+        Z = pair(g,g)
+
+        params = { 'g': g, 'Z' : Z }
+        if(debug):
+            print("Setup: Public parameters...")
+            group.debug(params)
+        return params
+
+    def keygen(self, params):
+        x1, x2 = group.random(ZR), group.random(ZR)
+        Z_x1 = params['Z'] ** x1
+        g_x2 = params['g'] ** x2
+
+        sk = { 'sk1' : x1, 'sk2' : x2 }
+        pk = { 'pk1' : Z_x1, 'pk2' : g_x2 }
+        
+        if(debug):
+            print('\nKeygen...')
+            print("pk => '%s'" % pk)
+            print("sk => '%s'" % sk)
+        return (pk, sk)
+
+    def rekeygen(self, params, pk_a, sk_a, pk_b, sk_b):
+        pk_b2 = pk_b['pk2']
+        sk_a1 = sk_a['sk1']
+        rk = pk_b2 ** sk_a1
+        if(debug):
+            print('\nReKeyGen...')
+            print("rk => '%s'" % rk)
+        return rk
+
+    def encrypt(self, params, pk, m):
+        #m = group.encode(M, GT)
+        r = group.random(ZR)
+        
+        Z_a1 = pk['pk1']
+
+        c1 = params['g'] ** r
+        c2 = m * (Z_a1 ** r)
+
+        c = { 'c1' : c1, 'c2' : c2 }
+               
+        if(debug):
+            print('\nEncrypt...')
+            print('m => %s' % m)
+            print('r => %s' % r)
+            group.debug(c)
+        return c  
+        
+    def decrypt(self, params, sk, c):
+        c1 = c['c1'] 
+        c2 = c['c2']
+        m = c2 / (c1 ** (~sk['sk2']))
+        
+        if(debug):
+            print('\nDecrypt...')
+            print('m => %s' % m)
+
+        #return group.decode(m)
+        return m
+        
+    def re_encrypt(self, params, rk, c_a):
+        c1 = c_a['c1'] 
+        c2 = c_a['c2']
+
+        c1_prime = pair(c1, rk)
+
+        c_b = { 'c1' : c1_prime, 'c2' : c2 }
+        if(debug):
+            print('\nRe-encrypt...')
+            group.debug(c_b)
+        return c_b
+
+
+
+    

charm/schemes/prenc/pre_bbs98.py

@@ -0,0 +1,123 @@
+'''
+**BBS Proxy Re-Encryption (BBS98)**
+
+*Authors:* Blaze, Bleumer, Strauss
+
+| **Title:** "Divertible Protocols and Atomic Proxy Cryptography"
+| **Published in:** Advances in Cryptology - EUROCRYPT'98, 1998
+| **Available from:** http://link.springer.com/chapter/10.1007/BFb0054122
+
+.. rubric:: Scheme Properties
+
+* **Type:** proxy re-encryption
+* **Setting:** DDH-hard EC groups of prime order (F_p) or Integer Groups
+* **Assumption:** DDH (Decisional Diffie-Hellman)
+* **Properties:** CPA-secure, bidirectional, multihop, interactive, transitive, not collusion-resistant
+
+.. rubric:: Implementation
+
+:Authors: D. Nuñez (dnunez@lcc.uma.es)
+:Date: 04/2016
+'''
+
+from charm.toolbox.ecgroup import G
+from charm.toolbox.PREnc import PREnc
+
+debug = False
+class BBS98(PREnc):
+    """
+    Testing BBS98 implementation
+
+    >>> from charm.toolbox.eccurve import prime192v1
+    >>> from charm.toolbox.ecgroup import ECGroup
+    >>> groupObj = ECGroup(prime192v1)
+    >>> bbs = BBS98(groupObj)
+    >>> params = bbs.setup()
+    >>> (pk_a, sk_a) = bbs.keygen(params)
+    >>> (pk_b, sk_b) = bbs.keygen(params)
+    >>> msg = b"hello world!!!123456"
+    >>> c_a = bbs.encrypt(params, pk_a, msg)
+    >>> assert msg == bbs.decrypt(params, sk_a, c_a), 'Decryption of original ciphertext was incorrect'
+    >>> rk = bbs.rekeygen(params, pk_a, sk_a, pk_b, sk_b)
+    >>> c_b = bbs.re_encrypt(params, rk, c_a)
+    >>> assert msg == bbs.decrypt(params, sk_b, c_b), 'Decryption of re-encrypted ciphertext was incorrect'
+    """
+
+    def __init__(self, groupObj, p=0, q=0):
+        global group
+        group = groupObj
+        if group.groupSetting() == 'integer':
+            group.p, group.q, group.r = p, q, 2
+
+    def setup(self, secparam=0):
+        global g
+        if group.groupSetting() == 'integer':
+            if group.p == 0 or group.q == 0:
+                group.paramgen(secparam)
+            g = group.randomGen()
+        elif group.groupSetting() == 'elliptic_curve':
+            group.paramgen(secparam)
+            g = group.random(G)
+
+        params = {'g': g}
+        if(debug):
+            print("Setup: Public parameters...")
+            group.debug(params)
+        return params
+
+    def keygen(self, params):
+        x = group.random()
+        g_x = params['g'] ** x
+
+        sk = x      # { 'sk' : x }
+        pk = g_x    # { 'pk' : g_x }
+
+        if(debug):
+            print('\nKeygen...')
+            print("pk => '%s'" % pk)
+            print("sk => '%s'" % sk)
+        return (pk, sk)
+
+    def rekeygen(self, params, pk_a, sk_a, pk_b, sk_b):
+        rk = sk_b * (~sk_a)
+        if(debug):
+            print('\nReKeyGen...')
+            print("rk => '%s'" % rk)
+        return rk
+
+    def encrypt(self, params, pk, M):
+        m = group.encode(M)
+        r = group.random()
+        c1 = pk ** r
+        c2 = (params['g'] ** r) * m
+
+        c = {'c1': c1, 'c2': c2}
+
+        if(debug):
+            print('\nEncrypt...')
+            print('m => %s' % m)
+            print('r => %s' % r)
+            group.debug(c)
+        return c
+
+    def decrypt(self, params, sk, c):
+        c1 = c['c1']
+        c2 = c['c2']
+        m = c2 / (c1 ** (~sk))
+
+        if(debug):
+            print('\nDecrypt...')
+            print('m => %s' % m)
+
+        return group.decode(m)
+
+    def re_encrypt(self, params, rk, c_a):
+        c1 = c_a['c1']
+        c2 = c_a['c2']
+
+        c_b = {'c1': (c1 ** rk), 'c2': c2}
+
+        if(debug):
+            print('\nRe-encrypt...')
+            group.debug(c_b)
+        return c_b