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

charm/schemes/pksig/pksig_ecdsa.py

@@ -0,0 +1,71 @@
+'''
+**Elliptic Curve Digital Signature Algorithm (ECDSA)**
+
+*Authors:* NIST
+
+| **Title:** "Digital Signature Standard (DSS)"
+| **Published in:** FIPS 186, 1994
+| **Available from:** https://csrc.nist.gov/publications/detail/fips/186/4/final
+| **Notes:** Elliptic curve variant of DSA.
+
+.. rubric:: Scheme Properties
+
+* **Type:** signature (public key)
+* **Setting:** elliptic curve groups
+* **Assumption:** ECDLP (Elliptic Curve Discrete Logarithm)
+
+.. rubric:: Implementation
+
+:Authors: J. Ayo Akinyele
+:Date: 5/2011
+'''
+from charm.toolbox.ecgroup import ECGroup,ZR,G
+from charm.toolbox.PKSig import PKSig
+
+debug = False
+class ECDSA(PKSig):
+    """
+    >>> from charm.toolbox.eccurve import prime192v2
+    >>> group = ECGroup(prime192v2)
+    >>> ecdsa = ECDSA(group)
+    >>> (public_key, secret_key) = ecdsa.keygen(0)
+    >>> msg = "hello world! this is a test message."
+    >>> signature = ecdsa.sign(public_key, secret_key, msg)
+    >>> ecdsa.verify(public_key, signature, msg)
+    True
+    """
+    def __init__(self, groupObj):
+        PKSig.__init__(self)
+        global group
+        group = groupObj
+        
+    def keygen(self, bits):
+        group.paramgen(bits)
+        x, g = group.random(), group.random(G)
+        y = (g ** x)
+        return ({'g':g, 'y':y}, x)
+    
+    def sign(self, pk, x, M):
+        while True:
+            k = group.random()
+            r = group.zr(pk['g'] ** k)
+            e = group.hash(M)
+            s = (k ** -1) * (e + x * r)
+            if (r == 0 or s == 0):
+                print ("unlikely error r = %s, s = %s" % (r,s))
+                continue
+            else:
+                break
+        return { 'r':r, 's':s }
+        
+    def verify(self, pk, sig, M):
+        w = sig['s'] ** -1
+        u1 = group.hash(M) * w
+        u2 = sig['r'] * w
+        v = (pk['g'] ** u1) * (pk['y'] ** u2)
+    
+        if group.zr(v) == sig['r']:
+            return True
+        else:
+            return False
+

charm/schemes/pksig/pksig_hess.py

@@ -0,0 +1,104 @@
+'''
+**Hess Identity-Based Signature (Hess02)**
+
+*Authors:* F. Hess
+
+| **Title:** "Efficient Identity Based Signature Schemes Based on Pairings"
+| **Published in:** Selected Areas in Cryptography, 2002
+| **Available from:** LNCS Vol. 2595, pages 310-324
+| **Notes:**
+
+.. rubric:: Scheme Properties
+
+* **Type:** signature (identity-based)
+* **Setting:** bilinear groups (asymmetric)
+* **Assumption:** BDH
+
+.. rubric:: Implementation
+
+:Authors: J. Ayo Akinyele
+:Date: 11/2011
+'''
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,pair
+from charm.toolbox.PKSig import PKSig
+#import gc
+#gc.disable()
+#gc.set_debug(gc.DEBUG_LEAK)
+
+debug = False
+
+class Hess(PKSig):
+    """
+    >>> from charm.toolbox.pairinggroup import PairingGroup
+    >>> group = PairingGroup('SS512')
+    >>> hess = Hess(group)
+    >>> (master_public_key, master_secret_key) = hess.setup()
+    >>> ID = "janedoe@email.com"
+    >>> (public_key, secret_key) = hess.keygen(master_secret_key, ID)
+    >>> msg = "this is a message!" 
+    >>> signature = hess.sign(master_public_key, secret_key, msg)
+    >>> hess.verify(master_public_key, public_key, msg, signature)
+    True
+    """
+    def __init__(self, groupObj):
+        global group,H1,H2
+        group = groupObj
+        H1 = lambda x: group.hash(x, G1)
+        H2 = lambda x,y: group.hash((x,y), ZR)
+        
+    def setup(self):
+        g2, alpha = group.random(G2), group.random(ZR)
+        msk = alpha
+        P = g2 ** alpha 
+        mpk = {'P':P, 'g2':g2}
+        return (mpk, msk)
+
+    def keygen(self, msk, ID):
+        alpha = msk
+        sk = H1(ID) ** alpha
+        pk = H1(ID)
+        return (pk, sk)
+    
+    def sign(self, pk, sk, M):
+        if debug: print("sign...")
+        h, s = group.random(G1), group.random(ZR)
+        S1 = pair(h,pk['g2']) ** s 
+        a = H2(M, S1)
+        S2 = (sk ** a) * (h ** s)
+        return {'S1':S1, 'S2':S2}
+#        return (S1, S2)
+
+    
+    def verify(self, mpk, pk, M, sig):
+        if debug: print("verify...")
+        (S1, S2) = sig['S1'], sig['S2']
+        a = H2(M, S1)
+        if pair(S2, mpk['g2']) == (pair(pk, mpk['P']) ** a) * S1: 
+            return True
+        return False
+
+def main():
+   
+   groupObj = PairingGroup('SS512')
+   chch = Hess(groupObj)
+   (mpk, msk) = chch.setup()
+
+   _id = "janedoe@email.com"
+   (pk, sk) = chch.keygen(msk, _id)
+   if debug:  
+    print("Keygen...")
+    print("pk =>", pk)
+    print("sk =>", sk)
+ 
+   M = "this is a message!" 
+   sig = chch.sign(mpk, sk, M)
+   if debug:
+    print("Signature...")
+    print("sig =>", sig)
+
+   assert chch.verify(mpk, pk, M, sig), "invalid signature!"
+   if debug: print("Verification successful!")
+
+if __name__ == "__main__":
+    debug = True
+    main() 

charm/schemes/pksig/pksig_hw.py

@@ -0,0 +1,110 @@
+'''
+**Hohenberger-Waters Hash-and-Sign Signature (HW09)**
+
+*Authors:* S. Hohenberger, B. Waters
+
+| **Title:** "Realizing Hash-and-Sign Signatures under Standard Assumptions"
+| **Published in:** EUROCRYPT, 2009
+| **Available from:** pages 333-350
+| **Notes:** CDH construction.
+
+.. rubric:: Scheme Properties
+
+* **Type:** signature (public key)
+* **Setting:** bilinear groups (asymmetric)
+* **Assumption:** CDH
+
+.. rubric:: Implementation
+
+:Authors: J. Ayo Akinyele
+:Date: 11/2011
+'''
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,pair
+from charm.toolbox.PKSig import PKSig
+from math import ceil, log 
+
+debug=False
+class HW(PKSig):
+    """
+    >>> from charm.toolbox.pairinggroup import PairingGroup, GT
+    >>> group = PairingGroup('SS512')
+    >>> hw = HW(group)
+    >>> (public_key, secret_key) = hw.setup()
+    >>> msg = "please sign this message now please!"    
+    >>> signature = hw.sign(public_key, secret_key, public_key['s'], msg)
+    >>> hw.verify(public_key, msg, signature)
+    True
+    """
+    def __init__(self, groupObj):
+        global group
+        group = groupObj
+
+    def ceilog(self, value):
+        return group.init(ZR, ceil(log(value, 2)))
+        
+    def setup(self):
+        s = 0
+        g1, a = group.random(G1), group.random(ZR)
+        g2 = group.random(G2)
+        A = g2 ** a
+        u, v, d = group.random(G1), group.random(G1), group.random(G1)
+        U = pair(u, A)
+        V = pair(v, A)
+        D = pair(d, A)
+        w, z, h = group.random(ZR), group.random(ZR), group.random(ZR)
+        w1, w2 = g1 ** w, g2 ** w
+        z1, z2 = g1 ** z, g2 ** z
+        h1, h2 = g1 ** h, g2 ** h
+        pk = {'U':U, 'V':V, 'D':D, 'g1':g1, 'g2':g2, 'A':A,  
+              'w1':w1, 'w2':w2, 'z1':z1, 'z2':z2, 
+              'h1':h1, 'h2':h2, 'u':u, 'v':v, 'd':d, 's':s }
+        sk = {'a':a }
+        return (pk, sk)
+    
+    def sign(self, pk, sk, s, msg):
+        s += 1
+        S = group.init(ZR, s)
+        if debug: print("S =>", S)
+        M = group.hash(msg, ZR)
+        r, t = group.random(ZR), group.random(ZR)
+        sigma1a = ((pk['u'] ** M) * (pk['v'] ** r) * pk['d']) ** sk['a']
+        sigma1b = ((pk['w1'] ** self.ceilog(s)) * (pk['z1'] ** S) * pk['h1']) ** t
+        sigma1 =  sigma1a * sigma1b
+        sigma2 = pk['g1'] ** t
+        
+        return { 1:sigma1, 2:sigma2, 'r':r, 'i':s }
+        
+    def verify(self, pk, msg, sig):
+        M = group.hash(msg, ZR)
+        sigma1, sigma2 = sig[1], sig[2]
+        r, s = sig['r'], sig['i']
+        S = group.init(ZR, s)        
+        U, V, D = pk['U'], pk['V'], pk['D']
+        rhs_pair = pair(sigma2, (pk['w2'] * self.ceilog(s)) * (pk['z2'] ** S) * pk['h2'])
+        
+        if( pair(sigma1, pk['g2']) == (U ** M) * (V ** r) * D * rhs_pair ):
+            return True
+        else:
+            return False
+        
+def main():
+    groupObj = PairingGroup('SS512')
+    hw = HW(groupObj)
+    
+    (pk, sk) = hw.setup()
+    if debug:
+        print("Public parameters")
+        print("pk =>", pk)
+
+    m = "please sign this message now please!"    
+    sig = hw.sign(pk, sk, pk['s'], m)
+    if debug:
+        print("Signature...")
+        print("sig =>", sig)
+
+    assert hw.verify(pk, m, sig), "invalid signature"
+    if debug: print("Verification Successful!!")
+
+if __name__ == "__main__":
+    debug = True
+    main()

charm/schemes/pksig/pksig_lamport.py

@@ -0,0 +1,63 @@
+'''
+**Lamport One-Time Signature (Lamport79)**
+
+*Authors:* L. Lamport
+
+| **Title:** "Constructing Digital Signatures from a One Way Function"
+| **Published in:** Technical Report, 1979
+| **Available from:** http://lamport.azurewebsites.net/pubs/dig-sig.pdf
+| **Notes:** One-time signature scheme based on one-way functions.
+
+.. rubric:: Scheme Properties
+
+* **Type:** signature (public key)
+* **Setting:** hash functions
+* **Assumption:** One-Way Function
+
+.. rubric:: Implementation
+
+:Authors: Jonas Thuresson, Martin Örndahl
+:Date: 03/2018
+'''
+from charm.toolbox.PKSig import PKSig
+from hashlib import sha256
+import os
+
+byte_masks = [2 ** b for b in range(8)]
+byte_masks.reverse()
+
+
+def _h(x):
+    return sha256(x).digest()
+
+
+def _bytes_to_booleans(x):
+    return [byte & mask != 0 for byte in x for mask in byte_masks]
+
+
+class Lamport(PKSig):
+    '''
+    >>> sig = Lamport()
+    >>> pk, sk = sig.keygen()
+    >>> msg = 'hello'.encode('utf-8')
+    >>> s = sig.sign(None, sk, msg)
+    >>> assert sig.verify(pk, msg, s), "Signature could not be verified"
+    '''
+
+    def __init__(self):
+        super().__init__()
+
+    def keygen(self, securityparam=256):
+        nbr_bytes = securityparam // 8
+        sk = [(os.urandom(nbr_bytes), os.urandom(nbr_bytes)) for _ in range(securityparam)]
+        pk = [(_h(i), _h(j)) for i, j in sk]
+        return pk, sk
+
+    def sign(self, pk, sk, message):
+        msg_hash = _h(message)
+        return [sk1 if not b else sk2 for ((sk1, sk2), b) in zip(sk, _bytes_to_booleans(msg_hash))]
+
+    def verify(self, pk, message, sig):
+        msg_hash = _h(message)
+        expected = [pk1 if not b else pk2 for ((pk1, pk2), b) in zip(pk, _bytes_to_booleans(msg_hash))]
+        return all([_h(s) == p for (s, p) in zip(sig, expected)])

charm/schemes/pksig/pksig_ps01.py

@@ -0,0 +1,135 @@
+'''
+**Pointcheval-Sanders Signature (PS16) - Known Messages**
+
+*Authors:* D. Pointcheval, O. Sanders
+
+| **Title:** "Short Randomizable Signatures"
+| **Published in:** CT-RSA, 2016
+| **Available from:** https://eprint.iacr.org/2015/525.pdf
+| **Notes:** Section 4 - Signatures over known messages.
+
+.. rubric:: Scheme Properties
+
+* **Type:** signature (public key)
+* **Setting:** bilinear groups (asymmetric)
+* **Assumption:** PS assumption
+
+.. rubric:: Implementation
+
+:Authors: Lovesh Harchandani
+:Date: 6/2018
+'''
+from functools import reduce
+
+from charm.toolbox.pairinggroup import PairingGroup, ZR, G1, G2, pair
+
+debug = False
+
+
+class PS01:
+    """
+    Signatures over known messages, section 4 of the paper
+    """
+
+    def __init__(self, groupObj):
+        global group
+        group = groupObj
+
+    @staticmethod
+    def keygen(num_messages=1):
+        x = group.random(ZR)
+        ys = [group.random(ZR) for _ in range(num_messages)]
+        sk = {'x': x, 'y': ys}
+        g2 = group.random(G2)
+        pk = {'X': g2 ** x, 'Y': [g2 ** y for y in ys], 'g2': g2}
+        return pk, sk
+
+    def sign(self, sk, *messages):
+        h = group.random(G1)
+        ms = [group.hash(m, ZR) for m in messages]
+        exp = sk['x'] + sum([sk['y'][i] * ms[i] for i in range(len(messages))])
+        return h, h ** exp
+
+    def verify(self, pk, sig, *messages):
+        s1, s2 = sig
+        if group.init(G1) == s1:
+            return False
+        ms = [group.hash(m, ZR) for m in messages]
+        l2 = pk['X'] * self.product([pk['Y'][i] ** ms[i] for i in range(len(messages))])
+        return pair(s1, l2) == pair(pk['g2'], s2)
+
+    def randomize_sig(self, sig):
+        s1, s2 = sig
+        t = group.random(ZR)
+        return s1 ** t, s2 ** t
+
+    @staticmethod
+    def product(seq):
+        return reduce(lambda x, y: x * y, seq)
+
+
+def main():
+    grp = PairingGroup('MNT224')
+    ps = PS01(grp)
+
+    print("Signing a single message")
+
+    (pk, sk) = ps.keygen()
+
+    if debug:
+        print("Keygen...")
+        print("pk :=", pk)
+        print("sk :=", sk)
+
+    M = "Please sign this stupid message!"
+    sig = ps.sign(sk, M)
+    if debug:
+        print("Signature: ", sig)
+
+    result = ps.verify(pk, sig, M)
+    assert result, "INVALID signature!"
+    if debug:
+        print("Successful Verification!!!")
+
+    rand_sig = ps.randomize_sig(sig)
+    assert sig != rand_sig
+    if debug:
+        print("Randomized Signature: ", rand_sig)
+
+    result = ps.verify(pk, rand_sig, M)
+    assert result, "INVALID signature!"
+    if debug:
+        print("Successful Verification!!!")
+
+    print("Signing multiple messages")
+
+    messages = ['Hi there', 'Not there', 'Some message ................', 'Dont know .............']
+    (pk, sk) = ps.keygen(len(messages))
+    if debug:
+        print("Keygen...")
+        print("pk :=", pk)
+        print("sk :=", sk)
+
+    sig = ps.sign(sk, *messages)
+    if debug:
+        print("Signature: ", sig)
+
+    result = ps.verify(pk, sig, *messages)
+    assert result, "INVALID signature!"
+    if debug:
+        print("Successful Verification!!!")
+
+    rand_sig = ps.randomize_sig(sig)
+    assert sig != rand_sig
+    if debug:
+        print("Randomized Signature: ", rand_sig)
+
+    result = ps.verify(pk, rand_sig, *messages)
+    assert result, "INVALID signature!"
+    if debug:
+        print("Successful Verification!!!")
+
+
+if __name__ == "__main__":
+    debug = True
+    main()

charm/schemes/pksig/pksig_ps02.py

@@ -0,0 +1,124 @@
+'''
+**Pointcheval-Sanders Signature (PS16) - Sequential Aggregate**
+
+*Authors:* D. Pointcheval, O. Sanders
+
+| **Title:** "Short Randomizable Signatures"
+| **Published in:** CT-RSA, 2016
+| **Available from:** https://eprint.iacr.org/2015/525.pdf
+| **Notes:** Section 5 - Sequential aggregate signatures over known messages.
+
+.. rubric:: Scheme Properties
+
+* **Type:** signature (public key)
+* **Setting:** bilinear groups (asymmetric)
+* **Assumption:** PS assumption
+
+.. rubric:: Implementation
+
+:Authors: Lovesh Harchandani
+:Date: 6/2018
+'''
+from functools import reduce
+
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,pair
+
+debug = False
+
+
+class PS02:
+    """
+    Sequential Aggregate signatures over known messages, section 5 of the paper
+    """
+
+    def __init__(self, groupObj):
+        global group
+        group = groupObj
+
+    def setup(self):
+        x = group.random(ZR)
+        g1 = group.random(G1)
+        g2 = group.random(G2)
+        self.x = x
+        self.g1 = g1
+        self.X1 = g1 ** x
+        self.g2 = g2
+        self.X2 = g2 ** x
+
+    def keygen(self, num_messages):
+        ys = [group.random(ZR) for _ in range(num_messages)]
+        sk = {'y': ys}
+        pk = {'Y': [self.g2 ** y for y in ys]}
+        return pk, sk
+
+    def sign(self, sk, pk, messages):
+        if not (len(pk['Y']) == len(messages) == len(sk['y'])):
+            raise ValueError('Missing or extra messages or keys')
+        for m in messages:
+            if m == 0:
+                raise ValueError('message cant be 0')
+        for i in range(len(messages)):
+            for j in range(i+1, len(messages)):
+                if pk['Y'][i] == pk['Y'][j]:
+                    raise ValueError('all public keys should be distinct')
+
+        prev_sig = (self.g1, self.X1)
+
+        for i in range(len(messages)):
+            if i > 0 and not self.verify({'Y': pk['Y'][:i]}, prev_sig, messages[:i]):
+                raise ValueError('Intermediate verification error')
+            t = group.random(ZR)
+            s1, s2 = prev_sig
+            m = group.hash(messages[i], ZR)
+            prev_sig = (s1 ** t, (s2 * (s1 ** (sk['y'][i] * m))) ** t)
+
+        return prev_sig
+
+    def verify(self, pk, sig, messages):
+        if len(pk['Y']) != len(messages):
+            raise ValueError('Missing or extra messages or keys')
+        s1, s2 = sig
+        if group.init(G1) == s1:
+            return False
+        l2 = self.X2 * self.product([pk['Y'][i] ** group.hash(messages[i], ZR) for i in range(len(messages))])
+        return pair(s1, l2) == pair(self.g2, s2)
+
+    @staticmethod
+    def product(seq):
+        return reduce(lambda x, y: x * y, seq)
+
+
+def main():
+    grp = PairingGroup('MNT224')
+    ps = PS02(grp)
+    ps.setup()
+
+    if debug:
+        print("Setup...")
+        print("x :=", ps.x)
+        print("g1 :=", ps.g1)
+        print("X1 :=", ps.X1)
+        print("g2 :=", ps.g2)
+        print("X2 :=", ps.X2)
+
+    messages = ['Hi there', 'Not there', 'Some message ................', 'Dont know .............']
+
+    (pk, sk) = ps.keygen(len(messages))
+    if debug:
+        print("Keygen...")
+        print("pk :=", pk)
+        print("sk :=", sk)
+
+    sig = ps.sign(sk, pk, messages)
+    if debug:
+        print("Signature: ", sig)
+
+    result = ps.verify(pk, sig, messages)
+    assert result, "INVALID signature!"
+    if debug:
+        print("Successful Verification!!!")
+
+
+if __name__ == "__main__":
+    debug = True
+    main()