def make_call(self, callee, caller, pseudonym, filename): plaintext = [callee, caller, pseudonym, filename] ciphertext = asym_encrypt(plaintext, constants.P.public_key) packet = [constants.Header.INITCALL, ciphertext] self.sendLine(serialize(packet)) self.p_deferred = defer.Deferred() self.p_deferred.addCallback(self.connect_to_n, filename)
def test_asym_encryption(self): identifier = helpers.pick_random() ciphertext = helpers.asym_encrypt(identifier, constants.P.public_key) s = helpers.serialize([0, ciphertext]) [op, d] = helpers.deserialize(s) plaintext = helpers.asym_decrypt(d, constants.P.private_key) self.assertEqual(identifier, plaintext)
def answer_call(self, cid): # knowledge of cid proofs our identity # XXX: possible race condition. when someone is able to answer the cid faster than me, he can take the call packet = [constants.Header.ANSWERCALL, cid] self.sendLine(serialize(packet)) self.setRawMode() self.file = open("output", "wb")
def GET(self, *args): l = len(args) if l == 0: use_query = db.query('SELECT COUNT(DISTINCT UKEY) AS USE_COUNT FROM USEFLAGS') use_tuple = use_query[0] use_data = {'USE_COUNT':use_tuple['USE_COUNT']} if helpers.is_json_request(): return helpers.serialize(use_data) else: return render.use(use_data) elif l == 1: global_use_query = db.query('SELECT COUNT(DISTINCT UUID) AS GLOBAL_COUNT\ FROM GLOBAL_USEFLAGS RIGHT OUTER JOIN USEFLAGS\ ON GLOBAL_USEFLAGS.UKEY = USEFLAGS.UKEY\ WHERE USEFLAG=$useflag', vars={'useflag':args[0]}) plus_use_query = db.query('SELECT COUNT(DISTINCT IPKEY) AS PLUS_COUNT\ FROM PLUS_USEFLAGS RIGHT OUTER JOIN USEFLAGS\ ON PLUS_USEFLAGS.UKEY = USEFLAGS.UKEY\ WHERE USEFLAG=$useflag', vars={'useflag':args[0]}) minus_use_query = db.query('SELECT COUNT(DISTINCT IPKEY) AS MINUS_COUNT\ FROM MINUS_USEFLAGS RIGHT OUTER JOIN USEFLAGS\ ON MINUS_USEFLAGS.UKEY = USEFLAGS.UKEY\ WHERE USEFLAG=$useflag', vars={'useflag':args[0]}) unset_use_query = db.query('SELECT COUNT(DISTINCT IPKEY) AS UNSET_COUNT\ FROM UNSET_USEFLAGS RIGHT OUTER JOIN USEFLAGS\ ON UNSET_USEFLAGS.UKEY = USEFLAGS.UKEY\ WHERE USEFLAG=$useflag', vars={'useflag':args[0]}) global_use_tuple = global_use_query[0] plus_use_tuple = plus_use_query[0] minus_use_tuple = minus_use_query[0] unset_use_tuple = unset_use_query[0] use_data = { 'GLOBAL_COUNT':global_use_tuple['GLOBAL_COUNT'], 'PLUS_COUNT':plus_use_tuple['PLUS_COUNT'], 'MINUS_COUNT':minus_use_tuple['MINUS_COUNT'], 'UNSET_COUNT':unset_use_tuple['UNSET_COUNT'] } if helpers.is_json_request(): return helpers.serialize(use_data) else: return render.use_useflag(args[0], use_data) else: return config.internalerror()
def forward(self, cid, coin): ''' Connect two user connections and set sockets to raw mode ''' if cid in self.factory.waiting_connections: # verify coin msg, sig = coin key = RSA.importKey(constants.B.public_key) if coin not in self.factory.bank.used_coins and key.verify(msg, sig): # connect self.goal = self.factory.waiting_connections.pop(cid) answer = [constants.Header.RAWNOW] self.sendLine(serialize(answer)) self.setRawMode() self.factory.bank.used_coins.append(coin) else: answer = [constants.Header.ERROR] self.sendLine(serialize(answer)) self.transport.loseConnection()
def GET(self): profile_count = db.select('ENV', what='PROFILE, COUNT(UUID) AS HOSTS', group='PROFILE') profile_data = dict() for t in profile_count: profile_data[t['PROFILE']] = {'HOSTS':t['HOSTS']} if helpers.is_json_request(): return helpers.serialize(profile_data) else: return render.profile(profile_data)
def GET(self): mirror_count = db.query('SELECT MIRROR,COUNT(UUID) AS HOSTS\ FROM HOST_MIRRORS NATURAL JOIN GENTOO_MIRRORS GROUP BY MIRROR') mirror_data = dict() for t in mirror_count: mirror_data[t['MIRROR']] = {'HOSTS':t['HOSTS']} if helpers.is_json_request(): return helpers.serialize(mirror_data) else: return render.mirror(mirror_data)
def GET(self): feature_count = db.query('SELECT FEATURE,COUNT(UUID) AS HOSTS\ FROM HOST_FEATURES NATURAL JOIN FEATURES GROUP BY FEATURE') feature_data = dict() for t in feature_count: feature_data[t['FEATURE']] = {'HOSTS':t['HOSTS']} if helpers.is_json_request(): return helpers.serialize(feature_data) else: return render.feature(feature_data)
def GET(self): repo_count = db.query('SELECT REPO,COUNT(DISTINCT IPKEY) AS PACKAGES,\ COUNT(DISTINCT UUID) AS HOSTS\ FROM INSTALLED_PACKAGES NATURAL JOIN REPOSITORIES GROUP BY REPO') repo_data = dict() for t in repo_count: repo_data[t['REPO']] = {'HOSTS':t['HOSTS'], 'PACKAGES':t['PACKAGES']} if helpers.is_json_request(): return helpers.serialize(repo_data) else: return render.repo(repo_data)
def connect_call(self, cid, connection): if cid in self.cids: print "Connecting %r" % cid self.delete_cid(cid) # spawn proxy to User self.waiting_connections[cid] = connection connection.setRawMode() # tell P packet = [constants.Header.ANSWERCALL, cid] self.pseudonym_provider.sendLine(serialize(packet)) else: print "No corresponding connection found"
def start_transfer(self, cid, filename): """ start filetransfer with coin """ if self.user.coins: coin = self.user.coins.pop() data = [constants.Header.INITCALL, cid, coin[0], coin[1][0]] line = serialize(data) self.sendLine(line) self.n_deferred = defer.Deferred() self.n_deferred.addCallback(self.send_raw_data, filename) self.n_deferred.addErrback(self.print_error) else: self.user.io.sendLine("You don't have coins!")
def lineReceived(self, line): data = deserialize(line) if data[0] == constants.Header.SIGN: # sign my blinds blinds = data[1:] print("Signing %d blinds" % len(blinds)) answer = [constants.Header.SIGN] for blind in blinds: blindsig = self.key.sign(b64decode(blind), "bla")[0] answer.append(blindsig) self.sendLine(serialize(answer))
def paging(self): ''' Collect all calls and pages them, use dummy when no call ''' temp = dict(self.server.calls) self.server.calls = dict().fromkeys(constants.locations.keys()) # for each location send packet to network provider for location in temp: packet = list() packet.append(constants.Header.PAGING) packet.append(location) calls = temp[location] if calls is None: # no calls, include dummies dummy = self.create_dummy() packet.extend(dummy) else: # add calls for call in calls: # list of calls packet.extend(call) print "sending " + serialize(packet) self.network_operator.sendLine(serialize(packet))
def __GET_CPV(self, cat, pkg, ver): p_query = db.query('SELECT COUNT(DISTINCT UUID) AS HOST_COUNT\ FROM INSTALLED_PACKAGES RIGHT OUTER JOIN PACKAGES\ ON INSTALLED_PACKAGES.PKEY = PACKAGES.PKEY\ WHERE CAT=$cat AND PKG=$pkg AND VER=$ver', vars={'cat':cat, 'pkg':pkg, 'ver':ver}) p_tuple = p_query[0] p_data = { 'HOST_COUNT':p_tuple['HOST_COUNT'], } if helpers.is_json_request(): return helpers.serialize(p_data) else: return render.package_cpv(cat, pkg, ver, p_data)
def main(): """ Main execution script. """ client = create_client() login.authenticate(client) logging.info("Login Successful.") query = {} query["PageSize"]="100" pagenumber = 1 pagetotal = 100 #query["PageNumber"] = "1" response = [] while pagetotal == 100: query["PageNumber"] = str(pagenumber) data = employee_termination.find_terminations(client, query) data_serial = helpers.serialize(data) #print(data) if data_serial == None: pagetotal = 0 else: data_mapped = mapping(data_serial) response += data_mapped pagetotal = len(data_serial["EmployeeTerminationInfo"]) logging.info("Request Parameter - Current PageSize: {0}, Current PageNumber: {1}".format(pagetotal,pagenumber)) pagenumber += 1 #print("NEXT") #write_json(response) ### Converting to CSV out = pd.DataFrame(response) out_columns = ["CompanyCode","EmployeeNumber","FirstName","LastName","EligibleForRehire","LastDayWorked","Notes","PaidThroughDate","Status","TerminationDate","TerminationReason","TerminationType","TimeClock"] out.to_csv(DEFAULT_FILE_DESTINATION+"EmployeeTermination.csv", columns=out_columns, index=False) out_pk = ["EmployeeNumber"] produce_manifest("EmployeeTermination.csv", out_pk) return
def GET(self): keyword_count = db.query('SELECT KEYWORD,\ COUNT(DISTINCT IPKEY) AS PACKAGES,\ COUNT(DISTINCT UUID) AS HOSTS\ FROM GLOBAL_KEYWORDS NATURAL JOIN KEYWORDS\ NATURAL JOIN INSTALLED_PACKAGES GROUP BY KEYWORD') keyword_data = dict() for t in keyword_count: keyword_data[t['KEYWORD']] = {'HOSTS':t['HOSTS'], 'PACKAGES':t['PACKAGES']} if helpers.is_json_request(): return helpers.serialize(keyword_data) else: # generate plot x_ticklabels = keyword_data.keys() y_values = [ keyword_data[k]['PACKAGES'] for k in x_ticklabels ] keyword_plot = helpers.barchart(title = 'Installed packages per keyword', x_label = 'Keyword', y_label = 'Number of Packages', x_ticklabels = x_ticklabels, y_values = y_values) return render.keyword(keyword_data, keyword_plot)
def GET(self): arch_count = db.select("ENV", what="ARCH, COUNT(UUID) AS HOSTS", group="ARCH") arch_data = dict() for t in arch_count: arch_data[t["ARCH"]] = {"HOSTS": t["HOSTS"]} if helpers.is_json_request(): return helpers.serialize(arch_data) else: # generate plot x_ticklabels = arch_data.keys() y_values = [arch_data[a]["HOSTS"] for a in x_ticklabels] arch_plot = helpers.barchart( title="Hosts per arch", x_label="Arch", y_label="Number of Hosts", x_ticklabels=x_ticklabels, y_values=y_values, ) return render.arch(arch_data, arch_plot)
def __GET_CP(self, top, cat, pkg): """ Get category/package-version """ p_query = db.query('SELECT COUNT(DISTINCT UUID) AS HOST_COUNT, \ COUNT(DISTINCT CAT, PKG, VER) AS CPV_COUNT\ FROM INSTALLED_PACKAGES RIGHT OUTER JOIN PACKAGES\ ON INSTALLED_PACKAGES.PKEY = PACKAGES.PKEY\ WHERE CAT=$cat AND PKG=$pkg', vars={'cat':cat, 'pkg':pkg}) p_tuple = p_query[0] p_data = { 'HOST_COUNT':p_tuple['HOST_COUNT'], 'CPV_COUNT':p_tuple['CPV_COUNT'], 'TOP_CPV':self.__top(top, cat, pkg) } if helpers.is_json_request(): return helpers.serialize(p_data) else: return render.package_cp(cat, pkg, p_data)
def __GET(self, top): """ Get category """ p_query = db.query('SELECT COUNT(DISTINCT UUID) AS HOST_COUNT, \ COUNT(DISTINCT CAT) AS C_COUNT, \ COUNT(DISTINCT CAT, PKG) AS CP_COUNT, \ COUNT(DISTINCT CAT, PKG, VER) AS CPV_COUNT\ FROM INSTALLED_PACKAGES RIGHT OUTER JOIN PACKAGES\ ON INSTALLED_PACKAGES.PKEY = PACKAGES.PKEY') p_tuple = p_query[0] p_data = { 'HOST_COUNT':p_tuple['HOST_COUNT'], 'C_COUNT':p_tuple['C_COUNT'], 'CP_COUNT':p_tuple['CP_COUNT'], 'CPV_COUNT':p_tuple['CPV_COUNT'], 'TOP_C':self.__top(top) } if helpers.is_json_request(): return helpers.serialize(p_data) else: return render.package(p_data)
def GET(self): self.args = web.input(cat='any', pkg='any', ver='any', repo='any') try: self.min_hosts = int(web.input(min_hosts=-1).min_hosts) except ValueError: self.min_hosts = -1 try: self.max_hosts = int(web.input(max_hosts=-1).max_hosts) except ValueError: self.max_hosts = -1 where = self._build_where() having = self._build_having() query = self._build_query(where, having) search_tuples = db.query(query, vars={ 'cat':self.args.cat, 'pkg':self.args.pkg, 'ver':self.args.ver, 'repo':self.args.repo, 'min_hosts':self.min_hosts, 'max_hosts':self.max_hosts}) if helpers.is_json_request(): search_list = list() for tuple in search_tuples: search_list.append({ 'CAT': tuple['CAT'], 'PKG': tuple['PKG'], 'VER': tuple['VER'], 'REPO': tuple['REPO'], 'HOSTS': tuple['HOSTS'] }) return helpers.serialize(search_list) else: return render.search(search_tuples)
client = context.socket(zmq.REP) client.bind(ZMQ_SERVER_NETWORK) # Set up a channel to receive KV17 requests sys.stderr.write('Setting up a ZeroMQ SUB: %s\n' % (ZMQ_PUBSUB_KV17)) subscribe_kv17 = context.socket(zmq.SUB) subscribe_kv17.connect(ZMQ_PUBSUB_KV17) subscribe_kv17.setsockopt(zmq.SUBSCRIBE, '') # Set up a poller poller = zmq.Poller() poller.register(client, zmq.POLLIN) poller.register(subscribe_kv17, zmq.POLLIN) sys.stderr.write('Ready.\n') while True: socks = dict(poller.poll()) if socks.get(client) == zmq.POLLIN: arguments = client.recv().split(',') if arguments[0] == 'j' and len(arguments) == 2: client.send(serialize(net.journeypatterncode(arguments[1]))) elif arguments[0] == 'p' and len(arguments) == 7: client.send(serialize(net.passed(arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6]))) else: client.send('') elif socks.get(subscribe_kv17) == zmq.POLLIN: pass
def test_serialization(self): packet = [constants.Header.INITCALL, helpers.pick_random(), helpers.pick_random()] line = helpers.serialize(packet) self.assertEqual(type(line), str) self.assertEqual(packet, helpers.deserialize(line))
def GET(self, *args): if len(args) == 0: form = host_form() return render.host_input(form) str_uuid = args[0] if not helpers.is_uuid(str_uuid): return config.notfound() uuid = helpers.uuidbin(str_uuid) hosts = db.select('HOSTS', vars={'uuid':uuid}, where='UUID=$uuid', what='UUID') if len(hosts) == 0: return config.notfound() host_data = dict() host_data['UUID'] = str_uuid env = db.select('ENV', vars={'uuid':uuid}, where="UUID=$uuid") e = env[0] for var in ['PLATFORM', 'LASTSYNC', 'PROFILE', 'ARCH', 'CHOST', 'CFLAGS', 'CXXFLAGS', 'FFLAGS', 'LDFLAGS', 'MAKEOPTS', 'SYNC']: host_data[var] = e[var] host_data['FEATURES'] = list() features = db.query('SELECT FEATURE\ FROM HOST_FEATURES NATURAL JOIN FEATURES\ WHERE UUID=$uuid', vars={'uuid':uuid}) for f in features: host_data['FEATURES'].append(f['FEATURE']) host_data['ACCEPT_KEYWORDS'] = list() keywords = db.query('SELECT KEYWORD\ FROM GLOBAL_KEYWORDS NATURAL JOIN KEYWORDS\ WHERE UUID=$uuid', vars={'uuid':uuid}) for k in keywords: host_data['ACCEPT_KEYWORDS'].append(k['KEYWORD']) host_data['USE'] = list() useflags = db.query('SELECT USEFLAG\ FROM GLOBAL_USEFLAGS NATURAL JOIN USEFLAGS\ WHERE UUID=$uuid', vars={'uuid':uuid}) for u in useflags: host_data['USE'].append(u['USEFLAG']) host_data['LANG'] = list() lang = db.query('SELECT LANG\ FROM HOST_LANG NATURAL JOIN LANG\ WHERE UUID=$uuid', vars={'uuid':uuid}) for l in lang: host_data['LANG'].append(l['LANG']) host_data['GENTOO_MIRRORS'] = list() mirrors = db.query('SELECT MIRROR\ FROM HOST_MIRRORS NATURAL JOIN GENTOO_MIRRORS\ WHERE UUID=$uuid', vars={'uuid':uuid}) for m in mirrors: host_data['GENTOO_MIRRORS'].append(m['MIRROR']) host_data['PACKAGES'] = dict() packages = db.query('SELECT CAT, PKG, VER\ FROM INSTALLED_PACKAGES NATURAL JOIN PACKAGES\ WHERE UUID=$uuid ORDER BY CAT, PKG, VER', vars={'uuid':uuid}) for p in packages: cpv = p['CAT'] + '/' + p['PKG'] + '-' + p['VER'] host_data['PACKAGES'][cpv] = dict() if helpers.is_json_request(): return helpers.serialize(host_data) else: return render.host(host_data)
def send_paging(self): ''' Forward paging packets from L ''' for key, value in self.paging_packets.iteritems(): self.transport.write(serialize(value), constants.locations[key])
def location_announcement(self): ''' send location announcements ''' for key, value in constants.locations.iteritems(): packet = [constants.Header.LOCATIONANNOUNCEMENT, key] self.transport.write(serialize(packet), value)
def send_msg(self, callee, caller, msg): msg = make_msg(msg) plaintext = [callee, caller, msg] ciphertext = asym_encrypt(plaintext, constants.P.public_key) packet = [constants.Header.MSG, ciphertext] self.sendLine(serialize(packet))
def __repr__(self): return yaml.dump(helpers.serialize(self))
def pseudonym_update(self, pseudonym, identifier, secret): """ Update pseudonym at Pseudonym Provider with asymmetric encryption (ECIES) """ plaintext = [pseudonym, identifier, secret] ciphertext = asym_encrypt(plaintext, constants.P.public_key) packet = [constants.Header.PSEUDONYMUPDATE, ciphertext] self.sendLine(serialize(packet))
def connectionMade(self): print "Connected to Network Operator" self.factory.clientConnectionMade(self) # send register message self.sendLine(serialize([constants.Header.REGISTER, "L"]))
def _send_blinds(self, protocol, blinding_factors, packet): protocol.blinding_factors = blinding_factors protocol.user = self protocol.sendLine(serialize(packet))
def location_update(self, pseudonym, location, seed): """ Update location at Location Provider with asymmetric encryption (ECIES) """ plaintext = [pseudonym, location, seed] ciphertext = asym_encrypt(plaintext, constants.L.public_key) packet = [constants.Header.LOCATIONUPDATE, ciphertext] self.sendLine(serialize(packet))