def __init__(self, p=0, q=0): ChamHash.__init__(self) global group group = IntegerGroupQ(0) # if p and q parameters have already been selected group.p, group.q, group.r = p, q, 2 self.group = group
def __init__(self, group=None, p=0, q=0, secparam=512): self.group = group if group is not None else IntegerGroupQ() self.group.p, self.group.q, self.group.r = p, q, 2 if self.group.p == 0 or self.group.q == 0: self.group.paramgen(secparam) self.p = self.group.p self.q = self.group.q self.x, self.g, = self.group.random(), self.group.randomGen() self.z, self.h, = self.group.randomGen(), self.group.randomGen() self.y = (self.g ** self.x) % self.p hs1 = hashlib.new('sha256') hs1.update(Conversion.IP2OS(integer(self.p))) hs1.update(Conversion.IP2OS(integer(self.q))) hs1.update(Conversion.IP2OS(integer(self.g))) hs1.update(Conversion.IP2OS(integer(self.h))) hs1.update(Conversion.IP2OS(integer(self.y))) msg = integer(Conversion.OS2IP(hs1.digest())) self.z = ((msg ** ((self.p - 1) / self.q)) % self.p) self.u = None self.d = None self.s1 = None self.s2 = None
def params(self, p=0, q=0, bits=1024): global group group = IntegerGroupQ(0) if p == 0 or q == 0: group.paramgen(bits) else: group.p, group.q, group.r = p, q, 2
def setup_key_handler(timestamp: int, number: int, policy: int): """ :param timestamp: (int) Timestamp of when the first knowledge proofs should be available on the ledger :param number: (int) Number of requested credentials :param policy: (int) The policy that a user is requesting credentials for. :return: (dict) """ resp = [] policy = PolicyModel.query.get(policy) sigvars = UserModel.query.get(current_user.id).get_sigvar( timestamp, policy) if not policy: raise Exception("Couldn't find policy") if sigvars: raise Exception("Key already exists") for i in range(0, number): # Retrieve key for particular timestamp and policy combination time = timestamp + (i * policy.publication_interval * 60 ) # publication_interval is in minutes # If no KeyModel exists for a given policy at a set time we create one key_model = policy.get_key(time) if key_model is None: signer = SignerBlindSignature(IntegerGroupQ()) new = KeyModel(time, policy, signer) policy.keys.append(new) new.save_to_db() policy.save_to_db() else: signer = key_model.signer # Retrieve pubkey and generate challenge to send in the response pubkey = SigConversion.convert_dict_strlist(signer.get_public_key()) challenge = SigConversion.convert_dict_strlist(signer.get_challenge()) # Save sigvars = SigVarsModel(timestamp=time, policy=policy.policy, u=signer.u, d=signer.d, s1=signer.s1, s2=signer.s2, user_id=current_user.id) sigvars.save_to_db() data = { 'timestamp': time, 'public_key': pubkey, 'challenge': challenge } resp.append(data) return resp
def __init__(self, pubk: dict): self.p = pubk.get('p') self.q = pubk.get('q') self.g = pubk.get('g') self.y = pubk.get('y') self.h = pubk.get('h') self.z = pubk.get('z') self.group = IntegerGroupQ() self.group.setparam(p=self.p, q=self.q)
def __init__(self): self.groupObj = IntegerGroupQ() self.groupObj.paramgen(256) self.signer = SignerBlindSignature(self.groupObj, 0, 0, 256) self.user = UserBlindSignature(self.signer.get_public_key()) self.verify = BlindSignatureVerifier(self.signer.get_public_key()) self.user = UserBlindSignature(self.signer.get_public_key()) self.sig, self.e, self.message = None, None, None self.zeta, self.zeta1, self.rho = None, None, None self.omega, self.sigma1, self.sigma2 = None, None, None self.delta, self.mu, self.tmp1 = None, None, None self.tmp2, self.tmp3, self.tmp4 = None, None, None
def __init__(self, input_=None): if input_ is not None: self.p = input_.get('p') self.q = input_.get('q') self.g = input_.get('g') self.y = input_.get('y') self.h = input_.get('h') self.z = input_.get('z') self.group = IntegerGroupQ() self.group.setparam(p=self.p, q=self.q) self.db = input_.get('db') if self.db is None: self.db = {}
def get_key(self, timestamp: int) -> KeyModel: """ Find a policy key model based on the timestamp given. :param timestamp: (int) :return: (KeyModel) or None """ key = self.__get_from_list(self.keys, timestamp) if key is None: signer = SignerBlindSignature(IntegerGroupQ()) key = KeyModel(timestamp, self.policy, signer) key.save_to_db() self.keys.append(key) self.save_to_db() return key
def testElGamal(self): p = integer( 148829018183496626261556856344710600327516732500226144177322012998064772051982752493460332138204351040296264880017943408846937646702376203733370973197019636813306480144595809796154634625021213611577190781215296823124523899584781302512549499802030946698512327294159881907114777803654670044046376468983244647367 ) q = integer( 74414509091748313130778428172355300163758366250113072088661006499032386025991376246730166069102175520148132440008971704423468823351188101866685486598509818406653240072297904898077317312510606805788595390607648411562261949792390651256274749901015473349256163647079940953557388901827335022023188234491622323683 ) groupObj = IntegerGroupQ() el = ElGamal(groupObj, p, q) (pk, sk) = el.keygen() msg = b"hello world!" cipher1 = el.encrypt(pk, msg) m = el.decrypt(pk, sk, cipher1) assert m == msg, "Failed Decryption!!!" if debug: print("SUCCESSFULLY DECRYPTED!!!")
def decode(self, jsn): obj = json.loads(jsn) db = obj.pop('db') if obj.get('db') is not None else None if isinstance(self, SignerBlindSignature): new = SignerBlindSignature(IntegerGroupQ()) elif isinstance(self, UserBlindSignature): new = UserBlindSignature() else: raise Exception("Unexpected argument") for key in obj: if obj[key] == 'null': attr_val = None else: attr_val = SigConversion.strlist2modint(obj[key]) setattr(new, key, attr_val) if db: for key in db: db[key] = SigConversion.strlist2modint(db[key]) setattr(new, 'db', db) new.group = IntegerGroupQ() new.group.setparam(p=new.p, q=new.q) return new
def __init__(self): super().__init__(None) sender_states = { 1: self.sender_state_1, 3: self.sender_state_3, 5: self.sender_state_5, } receiver_states = { 2: self.receiver_state_2, 4: self.receiver_state_4, } sender_trans = {1: 3, 3: 5} receiver_trans = {2: 4} self.group = IntegerGroupQ() self.group.paramgen(SECURITY_PARAM) Protocol.addPartyType(self, SENDER, sender_states, sender_trans, True) Protocol.addPartyType(self, RECEIVER, receiver_states, receiver_trans)
def main(): nr_of_clients = 200 G = IntegerGroupQ() G.paramgen(1024) g = G.randomG() clients_list = [Client(G, g, i) for i in range(nr_of_clients)] for client in clients_list: g_v , r = client.proof_x g_x, id = client.g_x, client.id hash = G.hash(g, g_v, g_x, id) assert g_v == (g**r) * (g_x **hash) g_xs = [client.g_x for client in clients_list] hashes = [] for client in clients_list: client.compute_g_y(g_xs) hashes.append(client.answer()) # print(hashes) answers = [] for client in clients_list: assert G.hash(client.g_c_y) == hashes[client.id] answers.append(client.g_c_y) print(reduce(lambda x, y: x * y, answers, integer(1, G.p)) % G.p)
Receiver hides alpha in a univariate polynomial: Receiver chooses random poly S of degree k such that S(0) = alpha Receiver's plan is to use R(x) = Q(x, S(x)) to learn P(alpha) R(0) = Q(0, S(0)) = P(S(0)) = P(alpha) """ import random from charm.toolbox.integergroup import IntegerGroupQ from charm.core.math.integer import integer from charm.core.math.integer import reduce as reduce_modulus from utils import Poly, LI SECURITY_PARAM = 20 G = IntegerGroupQ() G.paramgen(SECURITY_PARAM) g = G.randomGen() k = 4 m = 4 d_p = 12 # Degree of P d = d_p * k # Degree of P_x def main(): # Receiver has alpha. alpha = G.random() # Sender has polynomial P. P = Poly([G.random() for _ in range(d_p + 1)])
def setup(security_parameter): G = IntegerGroupQ() G.paramgen(security_parameter) g = G.randomG() sk = G.random() return G, g, sk
def __init__(self): global group group = IntegerGroupQ(0)
self.T = list(range(self.N)) self.X = [self.group.random() for _ in range(self.N)] random.shuffle(self.T) self.T = self.T[:self.n] R = [(x, self.S(x) if i in self.T else self.group.random()) for i, x in enumerate(self.X)] return R def getValue(self, Q): A = [xq for i, xq in enumerate(Q) if i in self.T] value = lagrange_interpolation(A, integer(0, self.group.q)) return value group = IntegerGroupQ() group.paramgen(256) # security parameter k = 5 degree_of_polynomial = 10 m = 5 start = time.time() # generate polynomial and masked polynomial with point (0,0) alice = Alice(group, k, degree_of_polynomial) bob = Bob(group, k) # polynomial used to calculate P(A)
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))