def __init__(self, port=False):
"""
Initialisierung und Binden des Ports.
Der Port kann via Shell-Argument uebergeben werden, sonst wird versucht, Port 32323 zu binden.
@return: None
"""
self.database = DatabaseHandler("gu.db")
self.crypt = EncryptionHandler()
self.sid_Pool = Pool(0)
self.file_storage = "./files/"
self.max_rcv = 2048
self.users = [] # Nutzer, die zum Index Session-ID gehoeren
self.ivs = [] # Initialiserungsvektoren
self.ctr = [] # Counter
self.sesskey = [] # Sessionkeys
self.uidstrings = [] # User-ID-Strings
#serv_soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#file_soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serv_soc = socket.socket()
if port != False:
serv_soc.bind(("", port))
elif len(sys.argv) < 2:
serv_soc.bind(("", 32323))
else:
serv_soc.bind(("", int(sys.argv[1])))
serv_soc.listen(1)
try:
while True:
komm, addr = serv_soc.accept()
data = ""
data = komm.recv(self.max_rcv)
# Default-Antwort
resp = "error - invalid-client-request"
# Leere Verbindung
if not data:
komm.close()
continue
# Datenpaket ist verschluesslt (= Kein DHEX-Paket)
if self.crypt.is_encrypted(data):
#body = self.decrypt(data)
tmp = split(";", data, 1)
body = tmp[1]
#print "getting messages :" + body
# Wenn nicht entschluesselbar -> Fehler
if body == None:
komm.send(resp)
komm.close()
continue
body = body.decode("utf-8", "ignore")
try:
# Kopfdaten und Nutzdaten trennen
data = split(";", data, 1)
self.header = self.parse_header(data[0])
data = data[1]
except IndexError:
komm.send(resp)
komm.close()
continue
# Datenpaket encoden
#if self.header[0] != "dhex":
try:
if self.header[0] == "dhex":
resp = self.init_dh(data)
elif self.header[0] == "auth":
resp = self.auth_user(body)
elif self.header[0] == "msg":
resp = self.recv_msg(body)
elif self.header[0] == "getmsg":
resp = self.get_msg(body)
elif self.header[0] == "gmsg":
resp = self.recv_gmsg(body)
elif self.header[0] == "getgmsg":
resp = self.get_gmsg(body)
elif self.header[0] == "reqfile":
resp = self.request_file()
elif self.header[0] == "regfile":
resp = self.register_file(body)
elif self.header[0] == "getfile":
resp = self.get_globalname(body)
elif self.header[0] == "getpic":
resp = self.get_profile_pic(body)
elif self.header[0] == "adduser":
resp = self.add_user(body)
elif self.header[0] == "adressbook":
resp = self.get_address_book(body)
# Antwortpaket senden
if self.header[0] == "dhex":
komm.send(resp)
elif isinstance(resp, list):
#for item in resp:
#item = (str(item[0]).encode("utf-8", "ignore"), item[1].encode("utf-8", "ignore"))
komm.send(self.build_pack(json.dumps(resp)))
else:
if self.is_error(resp):
print "error: " + resp
komm.send(resp)
else:
resp = self.crypt.encode_string(resp)
komm.send(self.build_pack(resp))
komm.close()
except IndexError:
komm.send(resp)
komm.close()
finally:
#for client in clients:
# client.close()
serv_soc.close()
class ConnectionHandler:
"""
Infolib.ConnectionHandler ist eine Klasse, die die Grundfunktionalitaet des Infoservers bereitstellt.
Sie bindet einen Port, an dem alle Verbindungen eigehen und verteilt die Pakete nach den entsprechenden Kopfinformationen.
Sie baut auf allen anderen Klassen in der Infolib auf.
Eine Verwendung ausserhalb des Infobook-Projektes wird nicht empfohlen.
Eine Dokumentation des Ablaufes finden Sie im GitHub-Wiki unter https://github.org/hansau22/infobook/
"""
def __init__(self, port=False):
"""
Initialisierung und Binden des Ports.
Der Port kann via Shell-Argument uebergeben werden, sonst wird versucht, Port 32323 zu binden.
@return: None
"""
self.database = DatabaseHandler("gu.db")
self.crypt = EncryptionHandler()
self.sid_Pool = Pool(0)
self.file_storage = "./files/"
self.max_rcv = 2048
self.users = [] # Nutzer, die zum Index Session-ID gehoeren
self.ivs = [] # Initialiserungsvektoren
self.ctr = [] # Counter
self.sesskey = [] # Sessionkeys
self.uidstrings = [] # User-ID-Strings
#serv_soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#file_soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serv_soc = socket.socket()
if port != False:
serv_soc.bind(("", port))
elif len(sys.argv) < 2:
serv_soc.bind(("", 32323))
else:
serv_soc.bind(("", int(sys.argv[1])))
serv_soc.listen(1)
try:
while True:
komm, addr = serv_soc.accept()
data = ""
data = komm.recv(self.max_rcv)
# Default-Antwort
resp = "error - invalid-client-request"
# Leere Verbindung
if not data:
komm.close()
continue
# Datenpaket ist verschluesslt (= Kein DHEX-Paket)
if self.crypt.is_encrypted(data):
#body = self.decrypt(data)
tmp = split(";", data, 1)
body = tmp[1]
#print "getting messages :" + body
# Wenn nicht entschluesselbar -> Fehler
if body == None:
komm.send(resp)
komm.close()
continue
body = body.decode("utf-8", "ignore")
try:
# Kopfdaten und Nutzdaten trennen
data = split(";", data, 1)
self.header = self.parse_header(data[0])
data = data[1]
except IndexError:
komm.send(resp)
komm.close()
continue
# Datenpaket encoden
#if self.header[0] != "dhex":
try:
if self.header[0] == "dhex":
resp = self.init_dh(data)
elif self.header[0] == "auth":
resp = self.auth_user(body)
elif self.header[0] == "msg":
resp = self.recv_msg(body)
elif self.header[0] == "getmsg":
resp = self.get_msg(body)
elif self.header[0] == "gmsg":
resp = self.recv_gmsg(body)
elif self.header[0] == "getgmsg":
resp = self.get_gmsg(body)
elif self.header[0] == "reqfile":
resp = self.request_file()
elif self.header[0] == "regfile":
resp = self.register_file(body)
elif self.header[0] == "getfile":
resp = self.get_globalname(body)
elif self.header[0] == "getpic":
resp = self.get_profile_pic(body)
elif self.header[0] == "adduser":
resp = self.add_user(body)
elif self.header[0] == "adressbook":
resp = self.get_address_book(body)
# Antwortpaket senden
if self.header[0] == "dhex":
komm.send(resp)
elif isinstance(resp, list):
#for item in resp:
#item = (str(item[0]).encode("utf-8", "ignore"), item[1].encode("utf-8", "ignore"))
komm.send(self.build_pack(json.dumps(resp)))
else:
if self.is_error(resp):
print "error: " + resp
komm.send(resp)
else:
resp = self.crypt.encode_string(resp)
komm.send(self.build_pack(resp))
komm.close()
except IndexError:
komm.send(resp)
komm.close()
finally:
#for client in clients:
# client.close()
serv_soc.close()
def is_error(self, data):
"""
Prueft ob eine Antwort eine Fehlermeldung ist
@param data: Antwort
@type data: str
@return: Boolean Ergebnis
"""
if string.find(data, "error", 0, 4) == -1 :
return False
else:
return True
def init_dh(self, data):
"""
Initialisiert den DH-Schluesselaustausch anhand der Informationen aus der Anfrage des Clients.
@param data: Enthaelt den Oeffentlichen Teil vom Partner
@type data: str
@return: str - Sessionkey
"""
# DH-Antwort (B) auf die Anfrage (A)
ret = self.crypt.init_dh_b(self.sid_Pool.give_next(),data)
if ret == False:
return "error - DH-initiation-error - DHEX"
try:
# Alle Felder fuer die neu Initialiserte Session reservieren (befuellen)
self.users.append("")
self.uidstrings.append("")
self.ivs.append(ret[0])
self.ctr.append(ret[1])
self.sesskey.append(ret[2])
#print "sesskey : " + ret[2]
return ret[3]
except IndexError:
return "error - DH-initiation-server-error - DHEX"
def decrypt(self, data):
"""
Entschluesselt ein Datenpaket mit dem Sessionkey, der zur Session-ID gehoert.
@param data: Verschluesseltes Paket mit unverschluesselten Kopfinformationen
@type data: str
@return: str - Unverschluesseltes Paket ohne Kopfinformationen
"""
try:
tmp = split(";", data, 1) # ";" Seperiert Nutz- und Kopfdaten
sid = split(":", tmp[0], 2) # Extrahiere Session-ID
sid = int(sid[2])
data = self.crypt.decrypt(self.sesskey[sid], self.ctr[sid], tmp[1])
return data
except IndexError:
return None
def encrypt(self, data):
"""
Verschluesselt die Daten fuer ein Paket.
@param data: Daten-String ohne Kopfinformationen
@type data: str
@return: Verschluesselt Datenpaket ohne Kopfinformationen
"""
try:
sid = self.header[2]
#return self.crypt.encrypt(self.sesskey[sid], self.ctr[sid], data)
return data
except IndexError:
return None
def parse_header(self, data):
"""
Verarbeitet Kopfinformationen und wandelt die Informationen in benoetigte Typen
@param data: Kopfinformationen
@type data: str
@return: Array - Kopfinformationen
"""
try:
header = split(":", data, 2)
if not header[0] == "dhex":
header[2] = int(header[2])
return header
except IndexError:
pass
def build_pack(self, msg):
"""
Erstellt die Kopfinformationen fuer ein Datenpaket und fuegt die Nachricht an.
@param msg: Nachricht ohne Kopfinformationen
@type msg: str
@return: str - Nachrichtenpaket mit Kopfinformationen
"""
try:
package = "sresp" + ":" + str(self.header[2]) + ";"
#enc_msg = self.encrypt(msg)
#if enc_msg == None:
# return msg
package += msg
return package
except IndexError:
return msg
def auth_user(self, data):
"""
Prueft ob eine Nutzer-Passwort Kombination valid ist.
@param data: Paket des Clients ohne Kopfinformationen
@type data: str
@return: str - Digest, der den Nutzer-ID-String enthaelt
"""
cred = split(":", data, 1)
if len(cred) < 2:
return "error - not-enough-arguments - AUTH"
try:
if self.database.auth_user(cred[0], cred[1]) == True:
# User-ID String erzeugen
dig = self.crypt.get_hash(self.sesskey[self.header[2]] + str(cred[0]))
self.uidstrings[self.header[2]] = dig
self.users[self.header[2]] = self.database.get_user_id(cred[0])
return dig
else:
return "error - wrong-credentials - AUTH"
except IndexError:
return "error - invalid-header - AUTH"
def check_uidstring(self, index, string):
"""
Vergleicht einen Nutzer-ID-String mit dem, der zu dem Nutzer mit der Session-ID gehoert.
@param index: Session-ID
@type index: int
@param string: Nutzer-ID-String
@type string: str
@return: Boolean - Ergebnis
"""
try:
if self.uidstrings[index] == string:
return True
return False
except IndexError:
return False
def recv_msg(self, data):
"""
Traegt eine Nachricht in die Datenbank ein.
@param data: Datenpaket des Clients ohne Kopfinformationen
@type data: str
@return: str - Erfolgs-/Fehlermeldung
"""
try:
sid = self.header[2]
tmp = split(":", data, 2)
# Nicht alle Felder gegeben
if len(tmp) != 3:
return "error - not-long-enough - MSG"
if self.check_uidstring(sid, tmp[0]):
rcv_uid = self.database.get_user_id(tmp[1])
snd_uid = self.users[self.header[2]]
print "writing message:" + tmp[2]
if not self.database.rcv_message(snd_uid, rcv_uid, tmp[2]):
return "error - server-database-error - MSG"
return "success - MSG"
else:
return "error - wrong-uidstring - MSG"
except IndexError:
return "error - invalid-header - MSG"
def get_msg(self, data):
"""
Gibt dem Client die Nachrichten zurueck.
@param data: Letzte MID, die der Client an den Server gibt.
@type data: str
@return: Array - Nachrichten
"""
data = split(":", data, 2)
try:
if not self.check_uidstring(self.header[2], data[0]):
# print "wrong uid string :" + data[0]
return "error - wrong-credentials - GetMessage"
messages = self.database.get_messages_by_last_mid(self.header[2], data[1])
ret_msg = []
for item in messages:
username = self.database.get_user_by_id(item[0])
if (username == None) or (item[0] == "False"):
username = "******"
ret_msg.append((username, item[1]))
return ret_msg
except IndexError:
return "error - internal-database-request-error - MSG"
def get_gmsg(self, data):
"""
Gibt dem Client die Gruppennachrichten zurueck.
@param data: Letzte GID, die der Client an den Server gibt.
@type data: str
@return: Array - Nachrichten
"""
data = split(":", data, 2)
try:
if not self.check_uidstring(self.header[2], data[0]):
print "wrong uid string"
return "error - wrong-credentials - GetGroupMessage"
messages = self.database.get_messages_by_last_gid(self.header[2], data[1])
ret_msg = []
for item in messages:
groupname = self.database.get_group_by_id(item[0])
if groupname == None:
groupname = "Gruppenname unbekannt"
ret_msg.append(item[1] + ":" + groupname + ":" + item[2])
return ret_msg
except IndexError:
return "error - internal-database-request-error - GroupMessage"
def recv_gmsg(self, data):
"""
Traegt eine Broadcast-Nachricht in die Datenbank ein.
@param data: Datenpaket des Clients ohne Kopfinformationen
@type data: str
@return: str - Erfolgs-/Fehlermeldung
"""
try:
sid = self.header[2]
tmp = split(":", data, 2)
# Nicht alle Felder gegeben
if len(tmp) != 3:
return "error - not-enough-arguments - GroupMessage"
if self.check_uidstring(sid, tmp[0]):
rcv_gid = self.database.get_group_id(tmp[1])
snd_uid = self.users[self.header[2]]
print "writing group message:" + tmp[2]
if not self.database.rcv_brdc_message(snd_uid, rcv_gid, tmp[2]):
return "error - server-database-error - GroupMessage"
return "success - GroupMessage"
else:
print "error in uidstring"
return "error - wrong-uidstring - GroupMessage"
except IndexError:
return "error - invalid-header - GroupMessage"
def request_file(self):
"""
Gibt einen Dateistring fuer eine neue Datei zurueck, die ueber FTP hochgeladen werden kann
@return: str - Dateistring
"""
ret_value = self.generate_file_string()
if ret_value == None:
return "error - storage-full - REQFILE"
else:
self.database.add_file(ret_value)
return ret_value
def register_file(self, data):
"""
Registriert eine Datei (Setzt den Besitzer zu einem Upload und gibt Dateinamen an)
@param data: Datenpaket des Clients ohne Kopfinformationen
@type data: str
@return: str - Erfolgs-/Fehlermeldung
"""
values = split(":", data, 2)
print values
try:
filestring = values[0]
global_name = values[1]
del values
if not self.database.check_filestring(filestring):
return "error - wrong-filestring"
if not self.database.register_file(self.users[self.header[2]], global_name, filestring):
return "error - server-storage-error"
else:
return "success - FILE"
except IndexError:
return "error - invalid-header - FILE"
def get_globalname(self, data):
"""
Sucht eine Datei nach dem Dateinamen und gibt den filestring zuruekc
@param data: Datenpaket des Clients ohne Kopfinformationen
@type data: str
@return: str - filestring / str - error
"""
filestring = self.database.get_name_by_filestring(data)
if not filestring:
return "error - file-not-found - FILE"
return filestring
def generate_file_string(self):
"""
Generiert einen Datei-String fuer eine neu empfangene Datei
Prueft ausserdem, ob eine Datei mit diesem Namen in ./files vorhanden ist
@return: str - Dateistring
"""
for i in range(0, 14):
filestring = ""
for i in range(0, 10):
filestring = filestring + choice(string.ascii_letters)
if os.path.exists(self.file_storage + filestring):
break
else:
return filestring
return None
def get_profile_pic(self, data):
"""
Gibt dem Nutzer den String zum Profilfoto zurueck
@param data: Datenpaket des Clients ohne Kopfinformationen
@type data: str
@return: str - Dateistring zum Profilbild
"""
string = self.database.get_profile_pic(data)
if not string:
return "-"
return string
def add_user(self, data):
"""
Fuegt einen neuen Benutzer hinzu
@param data: Daten vom Client
@type data: str
@return: str - Nachricht an den Client
"""
tmp = split(":", data, 2)
if not len(tmp) == 2:
return "error - not-enough-arguments - ADDUSER"
username = tmp[0]
pwhash = tmp[1]
if not self.database.check_user(username):
return "error - already-present-username - ADDUSER"
self.database.add_user(username, pwhash)
return "success - ADDUSER"
def get_address_book(self, data):
"""
Gibt das Nutzer-Addressbuch zurueck
@param data: uidstring
@type data: str
@return: Array - [int UID, str Name]
"""
if not self.check_uidstring(int(self.header[2]), data):
return "error - wrong-uidstring - GETADRBOOK"
return self.database.get_address_book(self.users[int(self.header[2])])