def test_new_user_has_default_values(self):
user = User("abc123")
expected_dict = {
"id": "abc123",
"firstname": "Joe",
"lastname": "User",
"address": "123 Fake Street",
"city": "Blacksburg"
}
self.assertEquals(user.to_dict(), expected_dict)
def setup(self):
db: dataset.Database = self.get_db()
system_table = db.get_table("system")
if None == system_table.find_one(key="system_00"):
system_table: dataset.Table = db.create_table("system")
system_table.create_column("key", sqlalchemy.VARCHAR(256))
system_table.create_column("value", sqlalchemy.VARCHAR(256))
system_table.insert({"key": "system_00", "value": True})
User.setup(db)
InstanceInfo.setup(db)
def test_update_user_from_dictionary(self):
user = User("abc123")
update_dict = {
"firstname": "Sarah",
"lastname": "Tester",
"address": "111 Nowhere Way",
"city": "Christiansburg"
}
user.update(update_dict)
update_dict.update({"id": "abc123"})
self.assertEquals(user.to_dict(), update_dict)
def start(self, ip, port, callback): """ Begin listening for client connections at the given address. @param ip The IP address to listen on. @param port The port to listen on. Should be 6660-6669 or 7000. @param callback The function to call when a thread receives a message """ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) self._hostname = ip sock.bind((ip, port)) while True: # Listen with no queued connections - will block sock.listen(0) # A connection has been acquired - get its info (conn, (ip, _)) = sock.accept() # The user will manage its own connection info usr = User(conn, ip) # Users are autonomous, but store them as a key to keep track of # the channels they belong to self._users[usr] = [] # Let the user start listening on its own thread Thread(target = usr.listen, args = (callback,)).start()
def register_user(client_socket, parts):
"""
Method to register users and their clients
:param client_socket: Socket where a connection with a client is happening
:param parts: Parts of the message that was sent by the client
"""
username = parts[1]
one_time_id = parts[2]
signature = base64.b64decode(parts[3])
hostname = parts[4]
port = parts[5]
client_cert = parts[6]
valid_signature = Cryptography.verify_signature(
base64.b64decode(client_cert).decode(), one_time_id, signature)
if valid_signature and User.login(username, one_time_id):
ClientsStore.save_client(username, hostname, port, client_cert)
ClientsStore.set_online(username, hostname, port)
Administration.__socket_map[client_socket] = username
client_socket.send('OK'.encode())
else:
client_socket.send('NOTOK'.encode())
def run(self, server, protocol, command):
login = command['account_name']
password = command['password']
public_key = command['public_key']
hashed_password = get_hash(login, password)
session = sessionmaker(bind=self.db_engine)()
db_user = session.query(SQLUser).filter_by(login=login).first()
if db_user:
if db_user.password != hashed_password:
protocol.send_packet(ResponsePacket(402, command['id']))
session.close()
return
else:
db_user = SQLUser(login=login,
password=hashed_password,
public_key=public_key)
session.add(db_user)
session.commit()
user = User()
user.gid = db_user.gid
user.login = db_user.login
user.public_key = db_user.public_key
user.protocol = protocol
protocol.user = user
server.logged_users.update({user.login: user})
protocol.send_packet(ResponsePacket(202, command['id']))
def init_app(self, email: str, password: str):
db: dataset.Database = self.get_db()
system_table = db.get_table("system")
if None == system_table.find_one(key="app_00"):
user: User = User()
user._email = email
user._name = re.sub(r"@.*$", "", email)
user._password = password
self.update_user(user)
system_table.insert({"key": "app_00", "value": True})
return True
else:
return False
def list_users(client_socket, parts):
username = parts[1]
signature = base64.b64decode(parts[2])
user = User.load_user(username)
client = ClientsStore.get_client(username)
valid_signature = Cryptography.verify_signature(
base64.b64decode(client['cert']).decode(), username, signature)
if valid_signature:
user_list = ClientsStore.list_users(username,
user.get_clearance_level())
encoded_list = pickle.dumps(user_list)
client_socket.send(encoded_list)
else:
client_socket.send('UNAUTHORIZED'.encode())
def list_users(username, clearance_level):
"""
Method to list the User's that are online and which clearance level is compatible with the asking user
:param username: Username of the user that is asking for the list
:param clearance_level: Clearance level of the user that is asking for the list
:return: List of online users that the user can see
"""
user_list = []
for user in ClientsStore.__online:
if user != username:
if ClientsStore.is_online(username):
saved_user = User.load_user(user)
if saved_user.get_clearance_level() <= clearance_level:
user_entry = ClientsStore.get_client(user)
user_entry['username'] = user
user_list.append(user_entry)
return user_list
def perform_operations(client_socket, parts):
"""
Method to execute the privileged operations
:param client_socket: Socket where a connection with a client is happening
:param parts: Parts of the message that was sent by the client
"""
username = parts[1]
signature = base64.b64decode(parts[2])
n = int(parts[3])
number = int(parts[4])
user = User.load_user(username)
client = ClientsStore.get_client(username)
valid_signature = Cryptography.verify_signature(
base64.b64decode(client['cert']).decode(), username, signature)
if n <= 0.0:
client_socket.send('INVALID'.encode())
return
if valid_signature:
clearance = user.get_clearance_level()
if clearance == 1 and n > 2:
client_socket.send('UNAUTHORIZED'.encode())
return
if clearance == 2 and n > 3:
client_socket.send('UNAUTHORIZED'.encode())
return
if n == 2:
result = Functions.square_root(number)
elif n == 3:
result = Functions.cubic_root(number)
else:
result = Functions.n_root(number, n)
client_socket.send(str(result).encode())
else:
client_socket.send('UNAUTHORIZED'.encode())
def run_administration(server):
"""
Method that runs the administration panel
:param server: Server instance, whose properties can be fetched
"""
if Cryptography.get_passphrase() == "":
while len(Cryptography.get_passphrase()) != 32:
passphrase = input(
"Please insert the server's passphrase (32 characters): ")
Cryptography.set_passphrase(passphrase)
"""
Method to start the menu used by the administrator
"""
banner = """What do you want to do?
1 - Create user
2 - Quit
> """
print('Welcome to the administration panel!')
while True:
option = int(input(banner))
if option == 1:
username, one_time_id = User.create()
print(
f'\nUser created with success!\n\tUsername: {username}\n\tOne Time ID: {one_time_id}\n\n'
)
elif option == 2:
print('Quitting server...')
logging.info('Quitting server...')
Administration.RUNNING = False
socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect(
(server.get_hostname(), server.get_port()))
_thread.interrupt_main()
quit(0)
else:
print('Option not valid! Try again.')
def update_user(self, user: User):
user.update(self.get_db())
def get_user_info_from_email(self, email: str) -> User:
return User.find_one_from_email(self.get_db(), email)
import os
from server.database import DatabaseManager
from server.database import db
from server.user import User
databaseName = "database_test"
os.remove(os.path.abspath('./' + databaseName + ".db"))
db = DatabaseManager(databaseName)
user1 = User()
user1.SetName("Erik Palencik")
user1.SetEmail("*****@*****.**")
user1.SetPassword(
"1234567"
) #If you see this code i dont use this password anywhere, so dont even try
db.SerializeClass(user1)
rows = db.GetAllUsers().fetchall()
print("Writting all users:")
for row in rows:
print(row)
