sb-auth 0.0.1__py3-none-any.whl

sb_auth/exec.py

@@ -0,0 +1,29 @@
+from .sb_local import * 
+from .sb_client import * 
+from .sb_serve import * 
+
+while True: 
+    s = input("(s) server (c) client (l) local[offline]: ") 
+    s = s.strip().lower()  
+
+    if s in {"s","c","l"}:
+        break 
+
+if s == "s": 
+    sbs = SBAuthServer()
+    asyncio.run(sbs.service())
+    
+elif s == "c": 
+    sbc = SBAuthClient()
+    asyncio.run(sbc.contact()) 
+else:  
+    while True: 
+        s = input("(s) server OR (c) client side: ") 
+        s = s.strip().lower()  
+
+        if s in {"s","c"}:
+            break
+
+    stat = s == "s"      
+    sls = SBLocalService(stat)  
+    sls.run() 

sb_auth/rw_comm_lang.py

@@ -0,0 +1,33 @@
+"""
+read/write operations for Seqbuild's Comm Lang language. 
+"""
+import websockets
+import asyncio
+from .sb_op import * 
+import json 
+from morebs2.matrix_methods import vector_to_string,cr 
+from morebs2.globalls import is_alphanumeric 
+
+DEFAULT_PORT = 8765 
+
+"""
+outputs the program's conventional filename 
+for `info` (client name or server address). 
+"""
+def filename_for_CL(info,is_server_side:bool): 
+    assert type(is_server_side) == bool
+
+    if is_server_side: 
+        return "client__" + info + ".txt" 
+    
+    q = info.split(".")
+    assert len(q) == 4 
+
+    q1 = q[-1].split(":") 
+    assert len(q1) == 2 
+
+    q[-1] = q1[0] 
+    q1 = q1[1] 
+
+    s = "_".join(q) 
+    return "server__" + s + "-" + q1 + ".txt" 

sb_auth/sb_client.py

@@ -0,0 +1,271 @@
+from .rw_comm_lang import * 
+
+class SBAuthClient: 
+
+    def __init__(self): 
+        self.addr = None 
+        self.user_idn = None 
+        self.utable = UserTable(False) 
+        self.is_new_user = False 
+
+        self.finstat = False 
+        self.active_clp = None 
+        return
+
+    async def contact(self): 
+        s = await asyncio.get_running_loop().run_in_executor(None, \
+            input, "enter in IP address: ")
+        s1 = await asyncio.get_running_loop().run_in_executor(None, \
+            input, "enter in port number: ")
+
+        self.addr = s + ":" + s1 
+        server = "ws://" + self.addr 
+        await self.act(server)  
+
+    async def act(self,server):  
+        async with websockets.connect(server) as wsock:
+            print("Connected to server!")
+            while True: 
+                await self.recv(wsock)
+                if self.finstat:
+                    break
+                    
+    async def recv(self,wsock): 
+        async for message in wsock:
+            print(message) 
+
+            try: 
+                message2 = json.loads(message)
+                message = message2
+            except: pass 
+
+            # case: data input, CL key or data 
+            if type(message) == list: 
+                #q = message.split("\n") 
+                # case: receive COMM LANG key 
+                if message[0].strip() == "COMM LANG": 
+                    gen_name = message[1] 
+                    cl_string = message[2] 
+                    stat = self.write_key_to_file(cl_string,gen_name,False)
+                    if not stat: 
+                        self.finstat = True 
+                        return 
+                    continue 
+
+            # case: initial login 
+            elif message.strip() == "username. leave blank if you are new:": 
+                response = await self.login(wsock)
+                continue 
+
+            elif message.strip() == "read (r) or write (w) or quit (q)?":
+                stat = await self.rw_ops(wsock) 
+                if stat == -1: 
+                    self.finstat = True 
+                    return 
+                continue 
+
+    async def login(self,wsock): 
+        s = await asyncio.get_running_loop().run_in_executor(None, input, "[x] ")
+
+        await wsock.send(s) 
+        self.user_idn = s 
+        response = await wsock.recv()
+        print(response) 
+        response = response.strip() 
+        q = response.split(" ") 
+
+        # case: new user 
+        if response == "new username:": 
+            s2 = await asyncio.get_running_loop().run_in_executor(None, input, "[x] ")
+            await wsock.send(s2) 
+            self.user_idn = s2 
+            response = wsock.recv()
+            self.is_new_user = True
+        # case: username does not exist. 
+        elif q[-2] == ["try","again!"]:
+            print("Username does not exist. Please try again.")
+            s2 = await asyncio.get_running_loop().run_in_executor(None, input, "[x] ")
+            response = await wsock.send(s2) 
+        # case: provide the key 
+        elif q[:4] == ["enter","in","your","key"]:  
+            num_iter = int(q[5])
+            await self.send_passwd(wsock,num_iter,is_login=True)
+
+        return response
+
+    def write_key_to_file(self,cl_string,gen_name,is_update:bool):   
+        user_str = filename_for_CL(self.addr,False) 
+        fp = os.path.join(DEFAULT_SB_USER_DIR, user_str)  
+
+        fobj = open(fp, "w") 
+        fobj.write(cl_string) 
+        fobj.close() 
+
+        try: 
+            if not is_update: 
+                self.utable.add_user(self.addr,user_str,gen_name) 
+            else: 
+                self.utable.delta_user(self.addr,user_str,gen_name) 
+        except: 
+            print("key already present for server/port OR could not be updated") 
+            return False 
+        return True 
+
+    async def send_passwd(self,wsock,num_iter,is_login:bool):  
+
+        user_str = filename_for_CL(self.addr,False) 
+
+        if type(self.active_clp) == type(None): 
+            fp = filename_for_CL(self.addr,False)  
+            full_fp = os.path.join(DEFAULT_SB_USER_DIR,fp) 
+            self.active_clp = CommLangParser(full_fp) 
+            self.active_clp.process_file() 
+
+        gen_name = self.utable.user_to_X(self.addr,"g-name")
+
+        prev_elements = 0 
+        if is_login: 
+            prev_elements = self.utable.user_to_X(self.addr,"# iterations")
+
+        total_elements = prev_elements + num_iter 
+        q = process_CommLang_generator(self.active_clp,gen_name,\
+            total_elements+1,num_iter)
+
+        self.utable.update_user(self.addr,num_iter)
+        s = vector_to_string(q,cr)
+        print("\t\t sending key") 
+        print(s)
+        await wsock.send(s) 
+
+    #------------------------------- post login 
+
+    async def rw_ops(self,wsock): 
+        # read/write
+        rw_stat = None
+        fpath = None  
+        while True: 
+            q = await asyncio.get_running_loop().run_in_executor(None, input, "[x] ")
+            await wsock.send(q)  
+            s = await wsock.recv()
+            print(s) 
+            if s.strip() == "enter in filepath:": 
+                rw_stat = q  
+                break 
+
+            if q == "q": 
+                rw_stat = "q" 
+                break 
+
+        if rw_stat == "q": 
+            return -1  
+
+        F = self.r_ops if rw_stat == "r" else self.w_ops 
+        stat = await F(wsock) 
+        return stat 
+
+    async def r_ops(self,wsock): 
+        fpath = await asyncio.get_running_loop().run_in_executor(None, input, "[x] ")
+        await wsock.send(fpath) 
+
+        #while True: 
+        sec_check_prompt = await wsock.recv() 
+        sec_check_prompt = sec_check_prompt.strip().split(" ") 
+        assert sec_check_prompt[:4] == ["enter","in","your","key"]
+            #break  
+
+        num_iter = int(sec_check_prompt[5])
+        await self.send_passwd(wsock,num_iter,is_login=False) 
+
+        sec_check_two = await wsock.recv()
+        try: 
+            sec_check_two_ = json.loads(sec_check_two)
+            sec_check_two = sec_check_two_
+        except: 
+            return False 
+
+        # case: correct key     
+        if type(sec_check_two) == list: 
+            ##fpath2 = await asyncio.get_running_loop().run_in_executor(None, input, "[x] write out path? ") 
+            stat = await self.record_read_file(sec_check_two[1])
+            if not stat: 
+                print("could not write out contents to file.") 
+                return False
+        else: 
+            print("Security check failed.")
+            return False 
+
+        x = await wsock.recv()
+        self.update_key_proc(x) 
+        return True 
+
+    async def record_read_file(self,contents):
+
+        fpath2 = await asyncio.get_running_loop().run_in_executor(None, input, "[x] write out path? ") 
+        
+        try: 
+            with open(fpath2,"w") as f: 
+                f.write(contents) 
+        except: 
+            return False 
+        return True 
+
+    async def w_ops(self,wsock): 
+        q = await wsock.recv() 
+        print(q) 
+
+        while True: 
+            fpath = await asyncio.get_running_loop().run_in_executor(None, input, "[x]: ") 
+
+            contents = None 
+            try: 
+                with open(fpath,"r") as f: 
+                    contents_ = f.read() 
+                    contents = contents_ 
+            except: 
+                pass 
+            
+            if type(contents) == type(None): 
+                print("invalid path.") 
+                continue 
+            break 
+
+        sec_check_prompt = await wsock.recv() 
+        sec_check_prompt = sec_check_prompt.strip().split(" ") 
+        assert sec_check_prompt[:4] == ["enter","in","your","key"]
+
+        num_iter = int(sec_check_prompt[5])
+        await self.send_passwd(wsock,num_iter,is_login=False) 
+
+        sec_check_two = await wsock.recv()
+        print(sec_check_two)
+
+        if sec_check_two[:8] != "proceed.": 
+            print("Security check failed.")
+            return False
+        
+        fpath2 = await asyncio.get_running_loop().run_in_executor(None, input, "[x] server side path: ") 
+        C = json.dumps([fpath2,contents]) 
+        await wsock.send(C)  
+        s = await wsock.recv() 
+        print(s)
+
+        if s == "Wrote content.": 
+            x = await wsock.recv() 
+            self.update_key_proc(x)   
+        return True 
+
+    def update_key_proc(self,x): 
+
+        # check for update to key here 
+        try: 
+            x_ = json.loads(x) 
+
+            # 
+            if type(x_) == list: 
+                print("updating key")
+                #q = ["COMM LANG",gen_name,content]
+                gen_name = x_[1] 
+                cl_string = x_[2] 
+                self.write_key_to_file(cl_string,gen_name,is_update=True)
+        except: 
+            print(x) 

sb_auth/sb_local.py

@@ -0,0 +1,160 @@
+from .rw_comm_lang import * 
+
+
+CLIENT_LIST_TITLE = "\t\t USER LIST"
+CLIENT_LIST_INPUT = "press (enter) for the next group of users OR\nenter in the name of a user: "
+
+CLIENT_PERMISSIONS_INPUT0 = "(ro) read folder (ri) read file (wo) write folder (wi) write file (b) go back: "
+CLIENT_PERMISSIONS_INPUT1 = "(a) add | (d) delete | (b) go back | press (enter) for the next group: "  
+
+CLIENT_PERMISSIONS_TITLE = "\t\t USER EXCLUSION: "
+CLIENT_PERMISSIONS_ADD_INPUT = "add exclusion: " 
+CLIENT_PERMISSIONS_DELETE_INPUT = "delete exclusion: " 
+
+def display_loop(L,ref_index,title,input_str):  
+
+    print(title) 
+    end = min(len(L),ref_index + 50)
+    for i in range(ref_index,end): 
+        print(L[i] + "\n") 
+    print("\n\n") 
+    x = input(input_str) 
+    return x  
+
+"""
+server side 
+"""
+class SBLocalService: 
+
+    def __init__(self,is_server_side:bool): 
+        self.is_server_side = is_server_side
+        self.utable = UserTable(self.is_server_side)
+        self.user_list = sorted(self.utable.t0.keys())
+
+        # for server side 
+        self.uperms = dict()  
+
+        self.preprocess()
+        return 
+
+    def load_user_permissions(self): 
+        
+        for u in self.user_list: 
+            fp_user = user_idn_to_default_permissions_file_path(u)
+            uperm = UserPermissions(fp_user)
+            self.uperms[u] = uperm 
+
+    def preprocess(self):
+
+        if self.is_server_side: 
+            self.load_user_permissions() 
+        return 
+
+    def run(self):
+        mode = "user"
+        user_idn = None 
+        perm_op = None 
+
+        while True: 
+            #if type(extra) == type(None): 
+            if mode == "user": 
+                user_idn,i = self.display_list(mode)
+                mode = "perm view" 
+            elif mode == "perm view": 
+                perm_op = self.user_selection(user_idn)
+                if perm_op == "b": 
+                    mode = "user"
+                    continue  
+                mode = "perm op"
+            else: 
+                op,i = self.display_list(mode,user_idn,perm_op)
+
+                if op == "b": 
+                    mode = "user" 
+                    continue 
+
+                uperm = self.uperms[user_idn] 
+                if op == "a": 
+                    to_add = True 
+                    S = CLIENT_PERMISSIONS_ADD_INPUT
+                elif op == "d": 
+                    to_add = False
+                    S = CLIENT_PERMISSIONS_DELETE_INPUT
+                else: 
+                    continue 
+
+                P = input(S)
+                uperm.update(perm_op[0],P,to_add=to_add)
+                mode = "user" 
+
+        return
+
+    def display_list(self,list_type,*args): 
+        assert list_type in {"user","perm op"}
+        
+        F = self.display_user_list_ if list_type == \
+            "user" else self.display_usr_perm_list
+        i = 0 
+        name = None 
+
+        while True: 
+            stat = F(i,*args)  
+            stat = stat.strip() 
+            if stat == "": 
+                i = i + 50 
+                if i >= len(self.user_list): 
+                    i = 0 
+            else: 
+                name = stat 
+                break 
+        return name,i 
+    
+    def user_selection(self,user_idn): 
+        if user_idn not in self.user_list: 
+            print("* user does not exist!") 
+            return None 
+
+        while True: 
+            s = input(CLIENT_PERMISSIONS_INPUT0) 
+            s = s.strip().lower()
+
+            if s in {"ro","ri","wo","wi","b"}: 
+                break 
+        return s 
+
+    def user_op(self,user_idn,action): 
+        assert action in {"ro","ri","wo","wi"}
+        return self.display_list("perm view",user_idn,action)
+
+    def display_usr_perm_list(self,ref_index,user_idn,action): 
+        if user_idn not in self.uperms: 
+            return "b" 
+        uperm = self.uperms[user_idn]
+
+        if action == "ro": 
+            Q = uperm.read_folder_ex
+
+        elif action == "ri": 
+            Q = uperm.read_file_ex
+
+        elif action == "wo": 
+            Q = uperm.write_folder_ex 
+
+        elif action == "wi": 
+            Q = uperm.write_file_ex
+
+        else: 
+            return "" 
+
+        return display_loop(Q,ref_index,title="\t\t* exclusion list",\
+            input_str=CLIENT_PERMISSIONS_INPUT1)
+
+    def display_user_list_(self,ref_index): 
+        return display_loop(self.user_list,ref_index,title=CLIENT_LIST_TITLE,\
+            input_str=CLIENT_LIST_INPUT) 
+
+    def delete_client(self): 
+        return -1 
+
+    def delete_server(self): 
+        return -1

sb_auth/sb_op.py

@@ -0,0 +1,87 @@
+from .usr_table import * 
+from seqbuild.face.easy_gen_struct import *  
+from morebs2.matrix_methods import is_number 
+
+# DEFAULT VARIABLES  
+PROHIBITED_COMMLANG_COMMANDS = {"load","show","chaintest","qualtest","open"} 
+PROHIBITED_SB_AUTH_NAMES = {"server_dir","client_dir","default",""} 
+DEFAULT_SB_AUTH_KEYSIZE_RANGE = [24,58]  
+DEFAULT_SB_AUTH_INDEX_RANGE = [627,1450] # [0,5] #
+DEFAULT_SB_SKIPSIZE_RANGE = [0,3]  
+
+"""
+checks if file abides by constrained Comm Lang rules. 
+"""
+def verify_CommLang_file(f,gen_name):
+    if not os.path.isfile(f): return False 
+
+    clp = CommLangParser(f)
+
+    while not clp.finstat: 
+        clp.load_next_command()
+
+        if len(clp.cmdlines) > 0: 
+            q = clp.cmdlines[0] 
+            c = q.split(" ")
+            if c[0] in PROHIBITED_COMMLANG_COMMANDS: 
+                return False 
+            if c[0] == "set": 
+                if "open" in c: return False 
+
+        clp.process_command() 
+        clp.check_finstat() 
+
+    if type(gen_name) == type(None): 
+        gen_name = clp.single_output_generator_list()[-1]
+
+    clp.close() 
+
+    try: 
+        stat = process_CommLang_generator(f,gen_name,0)
+        return stat  
+    except: 
+        return False
+
+# TODO:
+'''
+if num_iter = 0: checks generator first 50 outputs are real numbers. 
+otherwise: outputs `num_iter` values 
+'''  
+def process_CommLang_generator(f,generator_name,num_iter=0,output_last=0):
+    if type(f) == str: 
+        assert os.path.isfile(f) 
+        clp = CommLangParser(f) 
+        clp.process_file() 
+    else: 
+        assert type(f) == CommLangParser
+        clp = f 
+
+    assert num_iter >= 0 
+
+    excluded_types = {complex,np.complex64,np.complex128}
+    def vfunc(): 
+        for _ in range(50): 
+            try: 
+                x = G() 
+                stat = is_number(x,excluded_types)
+                if not stat: return False 
+            except: 
+                return False 
+        return True 
+
+    def nfunc():
+        X = [] 
+        for _ in range(num_iter): 
+            r = G()
+            X.append(float(round(r,5))) 
+        return X[-output_last:]
+
+    F = vfunc if num_iter == 0 else nfunc 
+
+    assert generator_name in clp.vartable, "got {}, available {}".format(generator_name,\
+        set(clp.vartable.keys()))
+
+    G = clp.vartable[generator_name]
+    G = MAIN_method_for_object(G) 
+    assert type(G) in {FunctionType,MethodType} 
+    return F()