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

charm/schemes/prenc/pre_nal16.py

@@ -0,0 +1,216 @@
+'''
+**NAL Proxy Re-Encryption (NAL16)**
+
+*Authors:* Nuñez, Agudo, Lopez
+
+| **Title:** "On the Application of Generic CCA-Secure Transformations to Proxy Re-Encryption"
+| **Published in:** Security and Communication Networks, 2016
+| **Available from:** http://onlinelibrary.wiley.com/doi/10.1002/sec.1434/full
+| **Notes:** First-level encryption & second-level decryption not yet implemented; type annotations to-do
+
+.. rubric:: Scheme Properties
+
+* **Type:** proxy re-encryption
+* **Setting:** Pairing groups (Type 1 "symmetric")
+* **Assumption:** 3-wDBDHI (3-weak Decisional Bilinear DH Inversion)
+* **Properties:** CCA_21-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
+from charm.toolbox.hash_module import Hash,int2Bytes,integer
+
+debug = False
+class NAL16a(PREnc):
+    """
+    Testing NAL16a implementation 
+
+    >>> from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,GT,pair
+    >>> groupObj = PairingGroup('SS512')
+    >>> pre = NAL16a(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 F(self, params, t):
+        return (params['u'] ** t) * params['v']
+
+    def setup(self):
+        g, u, v = group.random(G1), group.random(G1), group.random(G1)
+        Z = pair(g,g)
+
+        params = {'g': g, 'u': u, 'v': v, 'Z': Z} 
+        if(debug):
+            print("Setup: Public parameters...")
+            group.debug(params)
+        return params
+
+    def keygen(self, params):
+        x = group.random(ZR)
+        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 = pk_b ** (~sk_a)
+        if(debug):
+            print('\nReKeyGen...')
+            print("rk => '%s'" % rk)
+        return rk
+
+    def encrypt(self, params, pk, m):
+        #m = group.encode(M, GT)
+        r1, r2 = group.random(ZR), group.random(ZR)
+        
+        c0 = self.F(params, r1) ** r2
+        c1 = m * (params['Z'] ** r2)
+        c2 = pk ** r2
+
+        c = {'c0': c0, 'c1': c1, 'c2': c2}
+               
+        if(debug):
+            print('\nEncrypt...')
+            print('m => %s' % m)
+            print('r1 => %s' % r1)
+            print('r2 => %s' % r2)
+            print('c => %s' % c)
+            group.debug(c)
+        return c  
+        
+    def decrypt(self, params, sk, c):
+    
+        c1 = c['c1'] 
+        c2 = c['c2']
+
+        m = c1 / (c2 ** (~sk))
+        
+        if(debug):
+            print('\nDecrypt...')
+            print('m => %s' % m)
+
+        #return group.decode(m)
+        return m
+        
+    def re_encrypt(self, params, rk, c_a):
+
+        c2 = c_a['c2']
+
+        c_b = c_a
+        c_b['c2'] = pair(c2, rk)
+        
+        if(debug):
+            print('\nRe-encrypt...')
+            print('c\' => %s' % c_b)
+        return c_b
+
+class NAL16b(NAL16a):
+    """
+    Testing NAL16 implementation 
+
+    >>> from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,GT,pair
+    >>> groupObj = PairingGroup('SS512')
+    >>> pre = NAL16b(groupObj)
+    >>> params = pre.setup()
+    >>> (pk_a, sk_a) = pre.keygen(params)
+    >>> (pk_b, sk_b) = pre.keygen(params)
+    >>> msg = b"Hello world!"
+    >>> 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, h
+        group = groupObj
+        h = Hash(group)
+
+    def H(self, gt, s):
+        h1 = group.hash((gt, s, 1), ZR)
+        h2 = group.hash((gt, s, 2), ZR)
+        if(debug):
+            print('\nH ...')
+            print("gt => '%s'" % gt)
+            print("s => '%s'" % s)
+            print("h1 => '%s'" % h1)
+            print("h2 => '%s'" % h2)
+        return (h1, h2)
+
+    def G(self, x):
+        hh = h.hashToZn(x)
+        if(debug):
+            print('\nG ...')
+            print("x => '%s'" % x)
+            print("G(x) => '%s'" % hh)
+        return hh
+
+    def encrypt(self, params, pk, m):
+        sigma = group.random(GT)
+        c3 = self.G(sigma) ^ integer(m)
+        (r1, r2) = self.H(sigma, c3)
+
+        c = super(NAL16b, self).encrypt(params, pk, sigma)
+
+        c['c3'] = c3
+               
+        if(debug):
+            print('\nEncrypt...')
+            print('m => %s' % m)
+            print('r1 => %s' % r1)
+            print('r2 => %s' % r2)
+            print('c => %s' % c)
+            group.debug(c)
+        return c 
+
+    def decrypt(self, params, sk, c):
+        sigma = super(NAL16b, self).decrypt(params, sk, c)
+        c3 = c['c3']
+        (r1, r2) = self.H(sigma, c3)
+        m = int2Bytes(c3 ^ self.G(sigma))
+        
+        if(debug):
+            print('\nDecrypt...')
+            print('m => %s' % m)
+        return m
+
+    def re_encrypt(self, params, rk, c_a):
+        c_b = super(NAL16b, self).re_encrypt(params, rk, c_a)
+        c_b['c3'] = c_a['c3']
+        if(debug):
+            print('\nRe-encrypt...')
+            print('c\' => %s' % c_b)
+        return c_b
+
+# groupObj = PairingGroup('SS512')
+# pre = NAL16b(groupObj)
+# params = pre.setup()
+
+# (pk_a, sk_a) = pre.keygen(params)
+# (pk_b, sk_b) = pre.keygen(params)
+# msg = b"Hello world!"
+# 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)
+# pre.decrypt(params, sk_b, c_b) 

charm/schemes/protocol_a01.py

@@ -0,0 +1,272 @@
+'''
+**Abe Blind Signature Scheme (A01)**
+
+*Authors:* Masayuki Abe
+
+| **Title:** "A Secure Three-move Blind Signature Scheme for Polynomially Many Signatures"
+| **Published in:** EUROCRYPT 2001
+| **Available from:** http://www.iacr.org/archive/eurocrypt2001/20450135.pdf
+| **Notes:** Three-move interactive blind signature protocol
+
+.. rubric:: Scheme Properties
+
+* **Type:** blind signature
+* **Setting:** integer groups
+* **Assumption:** DL
+
+.. rubric:: Implementation
+
+:Authors: Antonio de la Piedra
+:Date: 12/2013
+'''
+from charm.toolbox.integergroup import integer, IntegerGroupQ, randomBits
+from charm.toolbox.conversion import Conversion
+from charm.core.engine.protocol import *
+from charm.toolbox.enum import Enum
+from socket import socket,AF_INET,SOCK_STREAM,SOL_SOCKET,SO_REUSEADDR
+import hashlib
+import sys
+
+party = Enum('Signer', 'User')
+SIGNER, USER = party.Signer, party.User
+HOST, PORT = "", 8082
+
+def SHA1(bytes1):
+    s1 = hashlib.new('sha256')
+    s1.update(bytes1)
+    return s1.digest()
+
+debug = False
+class Asig(Protocol):    
+    def __init__(self, groupObj, p=0, q=0, secparam=0):
+        Protocol.__init__(self, None)        
+
+        signer_states = { 1:self.signer_state1, 3:self.signer_state3, 5:self.signer_state5, 7:self.signer_state7 }
+        user_states = { 2:self.user_state2, 4:self.user_state4, 6:self.user_state6, 8:self.user_state8 }
+
+        signer_trans = { 1:3, 3:5, 5:7 }
+        user_trans = { 2:4, 4:6, 6:8 }
+
+        Protocol.addPartyType(self, SIGNER, signer_states, signer_trans, True)
+        Protocol.addPartyType(self, USER, user_states, user_trans)
+
+        self.group = groupObj
+        Protocol.setSubclassVars(self, self.group) 
+                        
+        group = groupObj
+        group.p, group.q, group.r = p, q, 2
+              
+        if group.p == 0 or group.q == 0:
+            group.paramgen(secparam)
+            p = group.p
+
+        p = group.p
+        q = group.q
+           
+    def signer_state1(self):
+        print("SIGNER state #1")
+
+        x, g, = self.group.random(), self.group.randomGen()
+        z, h, = self.group.randomGen(), self.group.randomGen()
+        
+        y = g ** x 
+
+        hs1 = hashlib.new('sha256')
+        hs1.update(Conversion.IP2OS(integer(p)))
+        hs1.update(Conversion.IP2OS(integer(q)))
+        hs1.update(Conversion.IP2OS(integer(g)))
+        hs1.update(Conversion.IP2OS(integer(h)))
+        hs1.update(Conversion.IP2OS(integer(y)))
+        
+        msg = integer(hs1.digest())
+        z = (msg ** ((p - 1)/q)) % p
+                                
+        Protocol.store(self, ('g', g), ('y', y), ('x', x), ('h', h), ('z', z))
+        Protocol.setState(self, 3)
+        
+        return { 'g':g, 'y':y, 'h':h, 'z':z  }
+
+    def user_state2(self, input):
+        print("USER state #2")
+        
+        g = input.get('g')
+        y = input.get('y')
+        h = input.get('h')
+        z = input.get('z')
+                
+        Protocol.store(self, ('g', g), ('y', y), ('h', h), ('z', z))
+        Protocol.setState(self, 4)
+        return { 'g':g, 'y':y }
+
+    def signer_state3(self, input):
+        print("SIGNER state #3")
+
+        rnd = (integer(randomBits(80)))
+
+        msg = integer(SHA1(Conversion.IP2OS(rnd)))
+        z1 = (msg ** ((p - 1)/q)) % p
+                        
+        (g, y, h ,z) = Protocol.get(self,  ['g', 'y', 'h', 'z'])
+        
+        z2 = z/z1
+        
+        u = self.group.random()        
+        s1 = self.group.random()                
+        s2 = self.group.random()        
+        d = self.group.random()        
+
+        a = g ** u
+        
+        b1 = (g ** s1) * (z1 ** d)         
+        b2 = (h ** s2) * (z2 ** d) 
+        
+        Protocol.store(self, ('u', u), ('s1', s1), ('s2', s2), ('d', d))
+        Protocol.setState(self, 5)
+
+        return { 'rnd':rnd, 'a':a, 'b1':b1, 'b2':b2  }
+
+    def user_state4(self, input):
+        print("USER state #4")
+
+        (g, y, h ,z) = Protocol.get(self,  ['g', 'y', 'h', 'z'])
+        
+        rnd = input.get('rnd')
+        a = input.get('a')
+        b1 = input.get('b1')
+        b2 = input.get('b2')
+        
+        msg = integer(SHA1(Conversion.IP2OS(rnd)))
+        z1 = (msg ** ((p - 1)/q)) % p
+
+        gamma = self.group.random()
+        
+        tau = self.group.random()
+
+        t1 = self.group.random()        
+        t2 = self.group.random()        
+        t3 = self.group.random()        
+        t4 = self.group.random()        
+        t5 = self.group.random()        
+
+        zeta = z ** gamma
+        zeta1 = z1 ** gamma
+        zeta2 = zeta/zeta1
+                                                         
+        alpha = a * (g ** t1) * (y ** t2) % p
+        beta1 = (b1 ** gamma) * (g ** t3) * (zeta1 ** t4) % p
+        beta2 = (b2 ** gamma) * (h ** t5) * (zeta2 ** t4) % p        
+        eta = z ** tau
+                
+        epsilon = self.group.hash(zeta, zeta1, alpha, beta1, beta2, eta, "msg")
+        e = epsilon - t2 - t4
+                
+        Protocol.store(self, ('z', z), ('z1', z1), ('zeta', zeta), ('zeta1', zeta1))
+        Protocol.store(self, ('zeta2', zeta2), ('alpha', alpha), ('beta1', beta1), ('beta2', beta2))
+        Protocol.store(self, ('t1', t1), ('t2', t2), ('t3', t3), ('t4', t4), ('t5', t5))
+        Protocol.store(self, ('gamma', gamma), ('tau', tau), ('eta', eta))
+
+        Protocol.setState(self, 6)        
+
+        return { 'e':e }        
+        
+    def signer_state5(self, input):
+        print("SIGNER state #5")
+
+        e = input.get('e')
+        (d, u, x) = Protocol.get(self, ['d', 'u', 'x'])
+        
+        c = e - d
+        r = u - c*x
+                
+        Protocol.setState(self, 7)
+        
+        return { 'r':r, 'c':c, 'd':d }
+
+    def user_state6(self, input):
+        print("USER state #6")
+
+        r = input.get('r')
+        c = input.get('c')
+        d = input.get('d')
+        
+        Protocol.store(self, ('r', r), ('c', c), ('d', d))
+        
+        Protocol.setState(self, 8)
+        return { 'r':r }
+
+    def signer_state7(self, input):
+        print("SIGNER state #7")
+
+        (s1, s2) = Protocol.get(self, ['s1', 's2'])
+                        
+        Protocol.setState(self, None)
+        
+        return { 's1':s1, 's2':s2 }
+
+    def user_state8(self, input):
+        print("USER state #8")
+
+        s1 = input.get('s1')
+        s2 = input.get('s2')
+        
+        (r, c, d) = Protocol.get(self, ['r', 'c', 'd'])
+
+        (alpha, beta1, beta2, g, y, z, h) = Protocol.get(self, ['alpha', 'beta1', 'beta2', 'g', 'y', 'z', 'h'])
+        (zeta, zeta1, zeta2, z, z1) = Protocol.get(self, ['zeta', 'zeta1', 'zeta2', 'z', 'z1'])
+        (t1, t2, t3, t4, t5) = Protocol.get(self, ['t1', 't2', 't3', 't4', 't5'])
+        (gamma, tau, eta) = Protocol.get(self, ['gamma', 'tau', 'eta'])
+        
+        rho = r + t1
+        omega = c + t2
+        
+        sigma1 = (gamma*s1) + t3
+        sigma2 = (gamma*s2) + t5
+        
+        delta = d + t4
+
+        mu = tau - (delta * gamma)
+
+        # Verification
+
+        tmp1 = (g ** rho) * (y ** omega) % p
+        tmp2 = (g ** sigma1) * (zeta1 ** delta) % p
+        tmp3 = (h ** sigma2) * (zeta2 ** delta) % p
+        tmp4 = (z ** mu) * (zeta ** delta) % p
+        
+        p1 = (omega + delta) % q
+        p2 = self.group.hash(zeta, zeta1, tmp1, tmp2, tmp3, tmp4, "msg")        
+        
+        print("Verification OK:", p1 == p2)
+        
+        Protocol.setState(self, None)
+        return None
+         
+if __name__ == "__main__":
+
+    p = integer(156053402631691285300957066846581395905893621007563090607988086498527791650834395958624527746916581251903190331297268907675919283232442999706619659475326192111220545726433895802392432934926242553363253333261282122117343404703514696108330984423475697798156574052962658373571332699002716083130212467463571362679)
+    q = integer(78026701315845642650478533423290697952946810503781545303994043249263895825417197979312263873458290625951595165648634453837959641616221499853309829737663096055610272863216947901196216467463121276681626666630641061058671702351757348054165492211737848899078287026481329186785666349501358041565106233731785681339)
+
+    groupObj = IntegerGroupQ()
+    sp = Asig(groupObj, p, q, 1024)
+
+    if sys.argv[1] == "-s":
+        print("Operating as signer...")
+        svr = socket(AF_INET, SOCK_STREAM)
+        svr.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+        svr.bind((HOST, PORT))
+        svr.listen(1)
+        svr_sock, addr = svr.accept()
+        print("Connected by ", addr)
+        _name, _type, _sock = "signer", SIGNER, svr_sock
+    elif sys.argv[1] == "-u":
+        print("Operating as user...")
+        clt = socket(AF_INET, SOCK_STREAM)
+        clt.connect((HOST, PORT))
+        clt.settimeout(15)
+        _name, _type, _sock = "user", USER, clt
+    else:
+        print("Usage: %s [-s or -u]" % sys.argv[0])
+        exit(-1)
+    sp.setup( {'name':_name, 'type':_type, 'socket':_sock} )
+    sp.execute(_type)
+    

charm/schemes/protocol_ao00.py

@@ -0,0 +1,215 @@
+'''
+**Abe-Okamoto Partially Blind Signature Scheme (AO00)**
+
+*Authors:* Masayuki Abe, Tatsuaki Okamoto
+
+| **Title:** "Provably Secure Partially Blind Signatures"
+| **Published in:** CRYPTO 2000
+| **Available from:** http://www.iacr.org/archive/crypto2000/18800272/18800272.pdf
+| **Notes:** Interactive partially blind signature protocol
+
+.. rubric:: Scheme Properties
+
+* **Type:** partially blind signature
+* **Setting:** integer groups
+* **Assumption:** DL
+
+.. rubric:: Implementation
+
+:Authors: Antonio de la Piedra
+:Date: 12/2013
+'''
+from charm.toolbox.integergroup import integer, IntegerGroupQ
+from charm.core.engine.protocol import *
+from charm.toolbox.enum import Enum
+from socket import socket,AF_INET,SOCK_STREAM,SOL_SOCKET,SO_REUSEADDR
+import hashlib
+import sys
+
+party = Enum('Signer', 'User')
+SIGNER, USER = party.Signer, party.User
+HOST, PORT = "", 8082
+
+def SHA2(bytes1):
+    s1 = hashlib.new('sha256')
+    s1.update(bytes1)
+    return s1.digest()
+
+debug = False
+class AOSig(Protocol):    
+    def __init__(self, groupObj, p=0, q=0, secparam=0):
+        Protocol.__init__(self, None)        
+
+        signer_states = { 1:self.signer_state1, 3:self.signer_state3, 5:self.signer_state5 }
+        user_states = { 2:self.user_state2, 4:self.user_state4, 6:self.user_state6 }
+
+        signer_trans = { 1:3, 3:5 }
+        user_trans = { 2:4, 4:6 }
+
+        Protocol.addPartyType(self, SIGNER, signer_states, signer_trans, True)
+        Protocol.addPartyType(self, USER, user_states, user_trans)
+
+        self.group = groupObj
+        Protocol.setSubclassVars(self, self.group) 
+                        
+        group = groupObj
+        group.p, group.q, group.r = p, q, 2
+              
+        if group.p == 0 or group.q == 0:
+            group.paramgen(secparam)
+            p = group.p
+
+        p = group.p
+        q = group.q
+           
+    def signer_state1(self):
+        print("SIGNER state #1")
+
+        p = self.group.p
+        q = self.group.q
+                
+        x, g, = self.group.random(), self.group.randomGen()
+        
+        y = g ** x 
+                        
+        Protocol.store(self, ('g', g), ('y', y), ('x', x))
+        Protocol.setState(self, 3)
+        
+        return { 'g':g, 'y':y }
+
+    def user_state2(self, input):
+        print("USER state #2")
+        
+        g = input.get('g')
+        y = input.get('y')
+                
+        Protocol.store(self, ('g', g), ('y', y))
+        Protocol.setState(self, 4)
+        return { 'g':g, 'y':y }
+
+    def signer_state3(self, input):
+        print("SIGNER state #3")
+
+        u = self.group.random()        
+        s = self.group.random()        
+        d = self.group.random()        
+
+        g = input.get('g')
+        y = input.get('y')
+        
+        str = "info"
+
+        msg = integer(SHA2(str))
+        z = (msg ** ((p - 1)/q)) % p
+                
+        a = g ** u
+        b = (g ** s) * (z ** d) 
+        
+        Protocol.store(self, ('u', u), ('s', s), ('d', d))
+        Protocol.setState(self, 5)
+
+        return { 'a':a, 'b':b, 's':s }
+
+    def user_state4(self, input):
+        print("USER state #4")
+        
+        p = self.group.p
+        q = self.group.q
+                        
+        a = input.get('a')
+        b = input.get('b')
+        s = input.get('s')
+        
+        g, y = Protocol.get(self, ['g', 'y'])
+         
+        t1 = self.group.random()        
+        t2 = self.group.random()        
+        t3 = self.group.random()        
+        t4 = self.group.random()        
+        
+        str = "info"
+                
+        msg = integer(SHA2(str))
+        z = (msg ** ((p - 1)/q)) % p
+                
+        alpha = a * (g ** t1) * (y ** t2) % p
+        beta  = b * (g ** t3) * (z ** t4) % p
+        
+        epsilon = self.group.hash(alpha, beta, z, "msg")
+        e = epsilon - t2 - t4
+                
+        Protocol.store(self, ('z', z), ('s', s), ('t1', t1), ('t2', t2), ('t3', t3), ('t4', t4), ('alpha', alpha), ('beta', beta))
+        Protocol.setState(self, 6)        
+
+        return { 'e':e }        
+        
+    def signer_state5(self, input):
+        print("SIGNER state #5")
+
+        e = input.get('e')
+        (d, u, x, s) = Protocol.get(self, ['d', 'u', 'x', 's'])
+        
+        c = e - d
+        r = u - c*x
+                
+        Protocol.setState(self, None)
+        
+        return { 'r':r, 'c':c, 'd':d }
+
+    def user_state6(self, input):
+        print("USER state #6")
+
+        r = input.get('r')
+        c = input.get('c')
+        d = input.get('d')
+        
+        (t1, t2, t3, t4, s) = Protocol.get(self, ['t1', 't2', 't3', 't4', 's'])
+        (alpha, beta, g, y, z) = Protocol.get(self, ['alpha', 'beta', 'g', 'y', 'z'])
+        
+        rho = r + t1
+        omega = c + t2
+        sigma = s + t3
+        delta = d + t4
+
+        # Verification
+
+        tmp1 = (g ** rho) * (y ** omega) % p
+        tmp2 = (g ** sigma) * (z ** delta) % p
+        
+        p1 = (omega + delta) % q
+        p2 = self.group.hash(tmp1, tmp2, z, "msg")
+        
+        print("Verification OK:", p1 == p2)
+
+        Protocol.setState(self, None)
+        return None
+                
+if __name__ == "__main__":
+
+    p = integer(156053402631691285300957066846581395905893621007563090607988086498527791650834395958624527746916581251903190331297268907675919283232442999706619659475326192111220545726433895802392432934926242553363253333261282122117343404703514696108330984423475697798156574052962658373571332699002716083130212467463571362679)
+    q = integer(78026701315845642650478533423290697952946810503781545303994043249263895825417197979312263873458290625951595165648634453837959641616221499853309829737663096055610272863216947901196216467463121276681626666630641061058671702351757348054165492211737848899078287026481329186785666349501358041565106233731785681339)
+
+    groupObj = IntegerGroupQ()
+    sp = AOSig(groupObj, p, q, 1024)
+
+    if sys.argv[1] == "-s":
+        print("Operating as signer...")
+        svr = socket(AF_INET, SOCK_STREAM)
+        svr.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+        svr.bind((HOST, PORT))
+        svr.listen(1)
+        svr_sock, addr = svr.accept()
+        print("Connected by ", addr)
+        _name, _type, _sock = "signer", SIGNER, svr_sock
+    elif sys.argv[1] == "-u":
+        print("Operating as user...")
+        clt = socket(AF_INET, SOCK_STREAM)
+        clt.connect((HOST, PORT))
+        clt.settimeout(15)
+        _name, _type, _sock = "user", USER, clt
+    else:
+        print("Usage: %s [-s or -u]" % sys.argv[0])
+        exit(-1)
+    sp.setup( {'name':_name, 'type':_type, 'socket':_sock} )
+    sp.execute(_type)
+