Implement base of code for rest of client functions

delivery1/client/bin/rep_activate_subject

@@ -0,0 +1,41 @@
+#!/bin/python3
+import os
+import sys
+import logging
+import requests
+import json
+import argparse
+
+logging.basicConfig(format='%(levelname)s\t- %(message)s')
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+state = {}
+
+#session file - username
+def activateSubject(args):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('session', nargs='?', default=None)
+    parser.add_argument('username', nargs='?',default=None)
+
+    args = parser.parse_args()
+
+    if not args.session or not args.username:
+        logger.error("Need session file and username.")
+        sys.exit(-1)
+
+    if (not os.path.isfile(args.session)):
+        logger.error("File '" + args.session + "' not found.")
+        sys.exit(-1)
+
+    subject = {'username' : args[1], 'status' : 'activate'}
+    try:
+        req = requests.post(f'http://{state['REP_ADDRESS']}/subject/', json=json.dumps(subject))
+        req.raise_for_status()
+    except requests.exceptions.RequestException as errex:
+        logger.error("Failed to obtain response from server.")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    activateSubject(sys.argv[1:])

delivery1/client/bin/rep_add_doc

@@ -0,0 +1,59 @@
+#!/bin/python3
+import os
+import sys
+import logging
+import requests
+import json
+import argparse
+
+from cryptLib import encryptionFuncts
+
+logging.basicConfig(format='%(levelname)s\t- %(message)s')
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+state = {}
+
+# session file - document name - file
+def addDoc(args):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('session', nargs='?', default=None)
+    parser.add_argument('name', nargs='?', default=None)
+    parser.add_argument('file', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+    if not args.session or not args.name or not args.file:
+        logger.error("Need session file, document's name and file to upload.")
+        sys.exit(-1)
+
+    if (not os.path.isfile(args.session)):
+        logger.error("File '" + args.session + "' not found.")
+        sys.exit(-1)
+
+    if (not os.path.isfile(args.file)):
+        logger.error("File '" + args.file + "' not found")
+        sys.exit(-1)
+
+
+    #encrypt content
+    with open(args.file, 'rb') as f:
+        content = f.read()
+
+    content = encryptionFuncts.encryptFile(state['REP_PUB_KEY'], content)
+
+    doc = {'name' : args.name, 'content' : content}
+    
+    try:
+        req = requests.post(f'http://{state['REP_ADDRESS']}/document/delete', json=json.dumps(doc))
+        req.raise_for_status()
+
+    except requests.exceptions.RequestException as errex: 
+        logger.error("Failed to obtain response from server.")
+        sys.exit(1)
+
+    sys.exit(0)
+
+if __name__ == '__main__':
+    addDoc(sys.argv[1:])

delivery1/client/bin/rep_add_subject

@@ -0,0 +1,54 @@
+#!/bin/python3
+import os
+import sys
+import logging
+import requests
+import json
+import argparse
+
+from cryptLib import encryptionFuncts
+
+logging.basicConfig(format='%(levelname)s\t- %(message)s')
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+state = {}
+
+# session file - username - name - email - credentials file
+def addSubject(args):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('session', nargs='?', default=None)
+    parser.add_argument('username', nargs='?', default=None)
+    parser.add_argument('name', nargs='?', default=None)
+    parser.add_argument('email', nargs='?', default=None)
+    parser.add_argument('credentials', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+    if len(args) != 5:
+        logger.error("Need session file, username, name, email and credentials file.")
+        sys.exit(-1)
+
+    if (not os.path.isfile(args.session)):
+        logger.error("File '" + args.session + "' not found.")
+        sys.exit(-1)
+
+    if (not os.path.isfile(args.credentials)):
+        logger.error("File '" + args.file + "' not found")
+        sys.exit(-1)
+
+    subject = {'username' : args.username, 'name' : args.name, 'email' : args.email, 'credentials' : args.credentials}
+    
+    try:
+        req = requests.post(f'http://{state['REP_ADDRESS']}/subject/add', json=json.dumps(subject))
+        req.raise_for_status()
+
+    except requests.exceptions.RequestException as errex: 
+        logger.error("Failed to obtain response from server.")
+        sys.exit(1)
+
+    sys.exit(0)
+
+if __name__ == '__main__':
+    addSubject(sys.argv[1:])

delivery1/client/bin/rep_create_org

@@ -5,6 +5,11 @@ import logging
 import requests
 import json
 import re
+import argparse
+
+from cryptLib import encryptionFuncts
+
+
 
 logging.basicConfig(format='%(levelname)s\t- %(message)s')
 logger = logging.getLogger()
@@ -13,31 +18,45 @@ logger.setLevel(logging.INFO)
 state = {}
 
 # Create organization
+# organization - username - name - email - public key file
 def createOrganization(args):
 
-    # {'name', 'username' , 'full_name', 'email' , 'public_key' }
+    parser = argparse.ArgumentParser()
 
+    parser.add_argument('org', nargs='?', default=None)
+    parser.add_argument('username', nargs='?', default=None)
+    parser.add_argument('name', nargs='?', default=None)
+    parser.add_argument('email', nargs='?', default=None)
+    parser.add_argument('key', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+    #Validate num of arguments
     if len(args) != 5:
-        logger.error("Missing parameters. Expected: 'name' 'username' 'full name' 'email' 'public key' ")
+        logger.error("Need organization, username, name, email and key file.")
         sys.exit(-1)
 
-    for item in args:
+    # Validate email
-        if item == '':
+    if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', args.email):
-            logger.error("Need a valid " + item)
-            sys.exit(-1)
-
-    input = {'name' : args[0], 'username' : args[1], 'full_name' : args[2], 'email' : args[3], 'public_key' : args[4]}
-
-    if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', input['email']):
         logger.error("Need a valid email.")
         sys.exit(-1)
 
-    if (not os.path.isfile(input['public_key'])):
+    # Validate key file
-        logger.error("File '" + input['public_key'] + "' not found.")
+    if (not os.path.isfile(args.key)):
+        logger.error("File '" + args.key + "' not found.")
         sys.exit(-1)
 
-    req = requests.post(f'http://{state['REP_ADDRESS']}/organization/create', json=json.dumps(input))
+    # load public key from file
+    pubKey = encryptionFuncts.load_public_key(args.key)
 
+    input = {'name' : args.org, 'username' : args.username, 'full_name' : args.name, 'email' : args.email, 'public_key' : pubKey}
+    
+    try:
+        req = requests.post(f'http://{state['REP_ADDRESS']}/organization/create', json=json.dumps(input))
+        req.raise_for_status()
+    except requests.exceptions.RequestException as errex: 
+            logger.error("Failed to obtain response from server.")
+            sys.exit(1)
 
 if __name__ == '__main__':
     createOrganization(sys.argv[1:])

delivery1/client/bin/rep_create_session

@@ -6,7 +6,6 @@ import logging
 import json
 import requests
 import re
-from getpass import getpass
 
 #  Identity attributes
 # {'username' : '', 'full_name' : '', 'email' : '', public_key : '' }
@@ -17,8 +16,38 @@ logger.setLevel(logging.INFO)
 
 state = {}
 
+# org - username - password - credentials file - session file
 def createSession(args):
-    pass
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('org', nargs='?', default=None)
+    parser.add_argument('username', nargs='?', default=None)
+    parser.add_argument('password', nargs='?', default=None)
+    parser.add_argument('credentials', nargs='?', default=None)
+    parser.add_argument('session', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+    if len(args != 5):
+        logger.error("Need organization, username, password, credentials and session file")
+        sys.exit(-1)
+
+    if (not os.path.isfile(args.credentials)):
+        logger.error("File '" + args.credentials + "' not found.")
+        sys.exit(-1)
+    
+    session = {'organization' : args.org, 'username' : args.username, 'password' : args.password, 'credentials' : args.credentials}
+
+    try:
+        req = requests.post(f'http://{state['REP_ADDRESS']}/session/create', json=json.dumps(session))
+        req.raise_for_status()
+    except requests.exceptions.RequestException as errex:
+        logger.error("Failed to obtain response from server")
+        sys.exit(1)
+
+    with open(args.session, 'w') as f:
+        f.write(json.dumps(req))
 
 if __name__ == '__main__':
     createSession(sys.argv[1:])

delivery1/client/bin/rep_decrypt_file

@@ -2,6 +2,9 @@
 import os
 import sys
 import logging
+import argparse
+
+from lib import decryption_functs
 
 logging.basicConfig(format='%(levelname)s\t- %(message)s')
 logger = logging.getLogger()
@@ -10,28 +13,39 @@ logger.setLevel(logging.INFO)
 #send to stdout contents of decrypted file
 # encrypted file - encryption metadata
 def decryptFile(args):
-    if len(args) != 3:
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('encrypted', nargs='?', default=None)
+    parser.add_argument('metadata', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+    if len(args) != 2:
         logger.error("Need encrypted file and it's metadata.")
         sys.exit(-1)
 
     # If first argument is not a file or not found
-    if (not os.path.isfile(args[1])):
+    if (not os.path.isfile(args.encrypted)):
-        logger.error("File '" + args[1] + "' not found.")
+        logger.error("File '" + args.encrypted + "' not found.")
         sys.exit(-1)
 
-    if (not os.path.isfile(args[2])):
+    if (not os.path.isfile(args.metadata)):
-        logger.error("File '" + args[2] + "' not found.")
+        logger.error("File '" + args.metadata + "' not found.")
         sys.exit(-1)
 
     #Get private key to decrypt
-    privateKey = ''
+    privateKey = decryption_functs.load_private_key(args.metadata)
 
     #Decrypt file
-    content = 'decrypt(privateKey, args[1])'
+    with open(args.encrypted, 'rb') as f:
+        content = f.read()
+
+    content = decryption_functs.decrypt_file(privateKey, content)
     
     # Send decrypted content to stdout 
     sys.stdout.write(content)
 
 
 if __name__ == '__main__':
-    decryptFile(sys.argv)
+    decryptFile(sys.argv[1:])

delivery1/client/bin/rep_delete_doc

@@ -0,0 +1,44 @@
+#!/bin/python3
+import os
+import sys
+import logging
+import requests
+import json
+import argparse
+
+logging.basicConfig(format='%(levelname)s\t- %(message)s')
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+state = {}
+
+# session file - document name
+def delDoc(args):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('session', nargs='?', default=None)
+    parser.add_argument('name', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+    if not args.session or not args.name:
+        logger.error("Need session file and document's name.")
+        sys.exit(-1)
+
+    if (not os.path.isfile(args.session)):
+        logger.error("File '" + args.session + "' not found.")
+        sys.exit(-1)
+
+    doc = {'name' : args.name}
+    try:
+        req = requests.post(f'http://{state['REP_ADDRESS']}/document/delete', json=json.dumps(doc))
+        req.raise_for_status()
+
+    except requests.exceptions.RequestException as errex: 
+        logger.error("Failed to obtain response from server.")
+        sys.exit(1)
+
+    sys.exit(0)
+
+if __name__ == '__main__':
+    delDoc(sys.argv[1:])

delivery1/client/bin/rep_get_doc_file

@@ -0,0 +1,52 @@
+#!/bin/python3
+import os
+import sys
+import logging
+import requests
+import json
+import argparse
+
+logging.basicConfig(format='%(levelname)s\t- %(message)s')
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+state = {}
+
+# session file - document name - output file(optional)
+def getDoc(args):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('session', nargs='?', default=None)
+    parser.add_argument('name', nargs='?', default=None)
+    parser.add_argument('output', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+    if not args.session or not args.name:
+        logger.error("Need session file and document's name.")
+        sys.exit(-1)
+
+    if (not os.path.isfile(args.session)):
+        logger.error("File '" + args.session + "' not found.")
+        sys.exit(-1)
+
+    doc = {'session' : args.session, 'name' : args.name}
+
+    try:
+        req = requests.post(f'http://{state['REP_ADDRESS']}/subject/', json=json.dumps(doc))
+        req.raise_for_status()
+    except requests.exceptions.RequestException as errex: 
+        logger.error("Failed to obtain response from server.")
+        sys.exit(1)
+
+    if args.output:
+        with open(args.output, 'w') as f:
+            f.write(req)
+
+    else:
+        sys.stdout.write(req)
+
+    sys.exit(0)
+
+if __name__ == '__main__':
+    getDoc(sys.argv[1:])

delivery1/client/bin/rep_get_doc_metadata

@@ -0,0 +1,45 @@
+#!/bin/python3
+import os
+import sys
+import logging
+import requests
+import json
+import argparse
+
+logging.basicConfig(format='%(levelname)s\t- %(message)s')
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+state = {}
+
+# session file - document name
+def getDocMetadata(args):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('session', nargs='?', default=None)
+    parser.add_argument('name', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+    if not args.session or not args.name:
+        logger.error("Need session file and document's name.")
+        sys.exit(-1)
+
+    if (not os.path.isfile(args.session)):
+        logger.error("File '" + args.session + "' not found.")
+        sys.exit(-1)
+
+    doc = {'session' : args.session, 'name' : args.name}
+
+    try:
+        req = requests.post(f'http://{state['REP_ADDRESS']}/document/metadata', json=json.dumps(doc))
+        req.raise_for_status()
+
+    except requests.exceptions.RequestException as errex: 
+        logger.error("Failed to obtain response from server.")
+        sys.exit(1)
+
+    sys.stdout.write(req)
+
+if __name__ == '__main__':
+    getDocMetadata(sys.argv[1:])

delivery1/client/bin/rep_get_file

@@ -4,6 +4,7 @@ import sys
 import logging
 import json
 import requests
+import argparse
 
 #  Identity attributes
 # {'username' : '', 'full_name' : '', 'email' : '', public_key : '' }
@@ -15,27 +16,39 @@ logger.setLevel(logging.INFO)
 state = {}
 
 #get file
-#file handle - file
+#file handle - file(optonal)
 def getFile(args):
+    parser = argparse.ArgumentParser()
 
-    if len(args) < 1:
+    parser.add_argument('filehandle', nargs='?', default=None)
+    parser.add_argument('file', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+
+    if not args.filehandle:
         logger.error("Need a file handle.")
         sys.exit(-1)
+    else:
+        if not os.path.isfile(args.filehandle):
+            logger.error("File '" + args.filehandle + "' not found" )
 
-    if len(args) == 2:
+    try:
-        if (not os.path.isfile(args[1])):
+        file = requests.get(f'http://{state['REP_ADDRESS']}/file'), params = {"file_handle" : args.filehandle}
-            logger.error("File '" + args[1] + "' not found.")
+        file.raise_for_status()
-            sys.exit(-1)
+    except requests.exceptions.RequestException as errex:
+        logger.error("Failed to obtain response from server.")
+        sys.exit(1)
 
-    file = json.loads(requests.get(f'http://{state['REP_ADDRESS']}/file'), params = {"file_handle" : args[0]})
+    file = json.loads(file)
 
     # decrypt file
     content = '' #decrypt(file.encode('utf-8'))
 
-    if len(args) == 1:
+    if not args.file:
         sys.stdout.write(content)
     else:
-        with open(args[1], "wb") as f:
+        with open(args.file, "wb") as f:
             f.write(content)
 
 if __name__ == '__main__':

delivery1/client/bin/rep_list_docs

@@ -0,0 +1,102 @@
+#!/bin/python3
+import os
+import sys
+import logging
+import requests
+import json
+import argparse
+import datetime
+
+logging.basicConfig(format='%(levelname)s\t- %(message)s')
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+state = {}
+
+def validDate(date):
+    try:
+        datetime.datetime.strptime(input,"%d/%m/%Y")
+    except ValueError as err:
+        logger.error("Date is invalid. Input format: DD/MM/YYYY")
+        sys.exit(-1)
+
+#session file - [-s username] [-d nt/ot/et date]
+def list_docs(args):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('session', nargs='?', default=None)
+    parser.add_argument("-s", '--username', nargs=1, help="Username")
+    parser.add_argument("-dnt", '--newerThan', help="Date new than")
+    parser.add_argument("-dot", '--olderThan', help="Date older than")
+    parser.add_argument("-deq", '--equalTo',   help="Date equal to")
+
+    args = parser.parse_args()
+
+    # Check if session file is valid
+    if args.session:
+        if (not os.path.isfile(args.session)):
+            logger.error("File '" + args.session + "' not found.")
+            sys.exit(-1)
+    else:
+        logger.error("Need session file.")
+        sys.exit(-1)
+
+    if args.newerThan:
+        validDate(args.newerThan)
+
+        try: 
+            subjects = requests.get(f'http://{state['REP_ADDRESS']}/user/list', 
+                                               json=json.dumps({'username' : args.username, 'newerThan' : args.newerThan}))
+            subjects.raise_for_status() 
+
+        except requests.exceptions.RequestException as errex: 
+            logger.error("Failed to obtain response from server.")
+            sys.exit(1)
+
+        subjects = json.loads(subjects)
+        
+    elif args.equalTo:
+        validDate(args.equalTo)
+
+        try: 
+            subjects = requests.get(f'http://{state['REP_ADDRESS']}/user/list', 
+                                               json=json.dumps({'username' : args.username, 'equalTo' : args.equalTo}))
+            subjects.raise_for_status() 
+
+        except requests.exceptions.RequestException as errex: 
+            logger.error("Failed to obtain response from server.")
+            sys.exit(1)
+
+        subjects = json.loads(subjects)
+
+    elif args.olderThan:
+        validDate(args.olderThan)
+
+        try: 
+            subjects = requests.get(f'http://{state['REP_ADDRESS']}/user/list', 
+                                               json=json.dumps({'username' : args.username, 'olderThan' : args.olderThan}))
+            subjects.raise_for_status() 
+
+        except requests.exceptions.RequestException as errex: 
+            logger.error("Failed to obtain response from server.")
+            sys.exit(1)
+
+        subjects = json.loads(subjects)
+
+    else:
+        try: 
+            subjects = requests.get(f'http://{state['REP_ADDRESS']}/user/list')
+            subjects.raise_for_status() 
+
+        except requests.exceptions.RequestException as errex: 
+            logger.error("Failed to obtain response from server.")
+            sys.exit(1)
+
+        subjects = json.loads(subjects)
+
+    for s in subjects:
+        sys.stdout.write(s['id'] + " - " + s['username'])
+
+
+if __name__ == '__main__':
+    list_docs(sys.argv[1:])

delivery1/client/bin/rep_list_subjects

@@ -0,0 +1,53 @@
+#!/bin/python3
+import os
+import sys
+import logging
+import requests
+import json
+import argparse
+
+logging.basicConfig(format='%(levelname)s\t- %(message)s')
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+state = {}
+
+# session file - username(optional)
+def list_subjects(args):
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('session', nargs='?', default=None)
+    parser.add_argument('username', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+    # Check if session file is valid
+    if (not os.path.isfile(args.session)):
+        logger.error("File '" + args.session + "' not found.")
+        sys.exit(-1)
+
+    if args.username:
+        try: 
+            subjects = json.loads(requests.get(f'http://{state['REP_ADDRESS']}/subject/list', json=json.dumps({'username' : args.username})))
+            subjects.raise_for_status() 
+
+        except requests.exceptions.RequestException as errex: 
+            logger.error("Failed to obtain response from server.")
+            sys.exit(1)
+
+    else:
+        try: 
+            subjects = json.loads(requests.get(f'http://{state['REP_ADDRESS']}/subject/list'))
+            subjects.raise_for_status() 
+
+        except requests.exceptions.RequestException as errex: 
+            logger.error("Failed to obtain response from server.")
+            sys.exit(1)
+
+    for s in subjects:
+        sys.stdout.write(s['id'] + " - " + s['username'])
+
+
+if __name__ == '__main__':
+    list_subjects(sys.argv[1:])

delivery1/client/bin/rep_subject_credentials

@@ -1,6 +1,9 @@
 #!/bin/python3
 import sys
 import logging
+import argparse
+
+from cryptLib import keyPair
 
 logging.basicConfig(format='%(levelname)s\t- %(message)s')
 logger = logging.getLogger()
@@ -10,19 +13,26 @@ logger.setLevel(logging.INFO)
 # password - file for keys
 def generateKeyPair(args):
 
-    if len(args) != 3:
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('password', nargs='?', default=None)
+    parser.add_argument('file', nargs='?', default=None)
+
+    args = parser.parse_args()
+
+    if len(args) != 2:
         logger.error("Need password and file to store keys")
         sys.exit(-1)
 
 
     #Generate the key pair
-    keyPair = ''
+    keys = keyPair.generate_key_pair(args.password)
 
     #Get the 2 different keys
     pubKey = ''
     privateKey = ''
 
-    with open(args[2], "wb") as f:
+    with open(args.file, "wb") as f:
         f.write(pubKey.encode() + b"\n\n" + privateKey.encode())
 
 

delivery1/client/bin/rep_suspend_subject

@@ -0,0 +1,36 @@
+#!/bin/python3
+import os
+import sys
+import logging
+import requests
+import json
+import argparse
+
+logging.basicConfig(format='%(levelname)s\t- %(message)s')
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+state = {}
+
+# session file - username
+def suspendSubject(args):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('session', nargs='?', default=None)
+    parser.add_argument('username', nargs='?',default=None)
+
+    args = parser.parse_args()
+
+    if len(args) != 2:
+        logger.error("Need session file and username.")
+        sys.exit(-1)
+
+    if (not os.path.isfile(args.session)):
+        logger.error("File '" + args.session + "' not found.")
+        sys.exit(-1)
+
+    subject = {'username' : args.username, 'status' : 'suspend'}
+    req = requests.post(f'http://{state['REP_ADDRESS']}/subject/', json=json.dumps(subject))
+
+if __name__ == '__main__':
+    suspendSubject(sys.argv)

delivery1/client/subject.py

@@ -0,0 +1,114 @@
+import os
+import sys
+import argparse
+import logging
+import json
+import requests
+from bin import *
+
+#  Identity attributes
+# {'username' : '', 'full_name' : '', 'email' : '', public_key : '' }
+
+logging.basicConfig(format='%(levelname)s\t- %(message)s')
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+def load_state():
+    state = {}
+    state_dir = os.path.join(os.path.expanduser('~'), '.sio')
+    state_file = os.path.join(state_dir, 'state.json')
+
+    logger.debug('State folder: ' + state_dir)
+    logger.debug('State file: ' + state_file)
+
+    if os.path.exists(state_file):
+        logger.debug('Loading state')
+        with open(state_file,'r') as f:
+            state = json.loads(f.read())
+
+    if state is None:
+        state = {}
+
+    return state
+
+def parse_env(state):
+    if 'REP_ADDRESS' in os.environ:
+        state['REP_ADDRESS'] = os.getenv('REP_ADDRESS')
+        logger.debug('Setting REP_ADDRESS from Environment to: ' + state['REP_ADDRESS'])
+
+    if 'REP_PUB_KEY' in os.environ:
+        rep_pub_key = os.getenv('REP_PUB_KEY')
+        logger.debug('Loading REP_PUB_KEY fron: ' + state['REP_PUB_KEY'])
+        if os.path.exists(rep_pub_key):
+            with open(rep_pub_key, 'r') as f:
+                state['REP_PUB_KEY'] = f.read()
+                logger.debug('Loaded REP_PUB_KEY from Environment')
+    return state
+
+def parse_args(state):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("-k", '--key', nargs=1, help="Path to the key file")
+    parser.add_argument("-r", '--repo', nargs=1, help="Address:Port of the repository")
+    parser.add_argument("-v", '--verbose', help="Increase verbosity", action="store_true")
+    # parser.add_argument("-c", "--command", help="Command to execute")
+    # parser.add_argument('arg0', nargs='?', default=None)
+    # parser.add_argument('arg1', nargs='?', default=None)
+    # parser.add_argument('arg2', nargs='?', default=None)
+    # parser.add_argument('arg3', nargs='?', default=None)
+    # parser.add_argument('arg4', nargs='?', default=None)
+    # parser.add_argument('arg5', nargs='?', default=None)
+
+    args = parser.parse_args()
+    if args.verbose:
+        logger.setLevel(logging.DEBUG)
+        logger.info('Setting log level to DEBUG')
+
+    if args.key:
+        if not os.path.exists(args.key[0]) or not os.path.isfile(args.key[0]):
+            logger.error(f'Key file not found or invalid: {args.key[0]}')
+            sys.exit(-1)
+
+        with open(args.key[0], 'r') as f:
+            state['REP_PUB_KEY'] = f.read()
+            logger.info('Overriding REP_PUB_KEY from command line')
+
+    if args.repo:
+        state['REP_ADDRESS'] = args.repo[0]
+        logger.info('Overriding REP_ADDRESS from command line')
+    
+    if args.command:
+        logger.info("Command: " + args.command)
+       
+    return state, {'command': args.command, 'arg0': args.arg0, 'arg1': args.arg1, 'arg2': args.arg2, 'arg3': args.arg3, 'arg4': args.arg4, 'arg5': args.arg5}
+
+def save(state):
+    state_dir = os.path.join(os.path.expanduser('~'), '.sio')
+    state_file = os.path.join(state_dir, 'state.json')
+
+    if not os.path.exists(state_dir):
+      logger.debug('Creating state folder')
+      os.mkdir(state_dir)
+
+    with open(state_file, 'w') as f:
+        f.write(json.dumps(state, indent=4))
+
+#Main function for checking commands
+def main(args):
+
+    state = load_state()
+    state = parse_env(state)
+    state, args = parse_args(state)
+
+    # if 'REP_ADDRESS' not in state:
+    #     logger.error("Must define Repository Address")
+    #     sys.exit(-1)
+
+    # if 'REP_PUB_KEY' not in state:
+    #     logger.error("Must set the Repository Public Key")
+    #     sys.exit(-1)
+
+    return state
+
+if __name__ == '__main__':
+    main(sys.argv)