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))
