sb-auth 0.0.1__tar.gz

sb_auth-0.0.1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Richard Pham
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sb_auth-0.0.1/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: sb_auth
+Version: 0.0.1
+Summary: An implementation of a WebSocket authentication scheme, unsecured ws://
+Home-page: https://github.com/Changissnz/sb_auth
+Author: Richard Pham
+Author-email: Richard Pham <phamrichard45@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/changissnz/sb_auth
+Project-URL: Issues, https://github.com/changissnz/sb_auth/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.22.1
+Requires-Dist: matplotlib>=3.5.3
+Requires-Dist: scipy>=1.14.1
+Requires-Dist: morebs2>=0.1.94
+Requires-Dist: python-resources>=0.3
+Requires-Dist: seqbuild>=0.0.49
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+
+# sb_auth (SeqBuild Authenticator) 
+
+*Work in progress* 
+
+A WebSocket authentication schematic b/t two devices, both using the `Seqbuild` library. 
+
+Simple client-server layout. Authentication allows for file read/write operations to take 
+place between the two devices. 
+
+*NOTE*  
+The current websocket implementation uses the unsecured `ws://` protocol instead of the 
+secured `wss://` one. The development of this authenticator has not advanced into 
+production-level mode.  
+
+This codebase works for local WiFi networks but otherwise, more code with third-party 
+services must be used for secured communication. 
+
+## Description 
+
+There are three perspectives for use: 
+- local (server or client side): offline mode, used to modify read/write settings and delete bunk 
+Comm Lang key files.  
+- server: can serve an unspecified number of clients. Every authenticated client has read/write access to permitted files/folders.  
+- client: can access one server at a time to read/write permitted files.  
+
+The procedure in which a client interacts with a server goes so:  
+1. Client sends IP address and port number (default is 8765, variable<DEFAULT_PORT>), and 
+connects to the server.  
+2. Client inputs username. If server has no registered username, it sends client a new 
+Comm Lang file key. This is a script, containing a primary generator pseudo-random number 
+generator G, that can be executed by `seqbuild`'s Comm Lang interpreter. Client stores this
+Comm Lang file key and sets the number of past iterations `i_p` to 0.  
+3. Client is required to output `q` integers from generator G, `q` specified by the server and 
+in the range of `DEFAULT_SB_AUTH_KEYSIZE_RANGE`, default set to `[24,58]`, every time client 
+prompts to read/write a file.  
+4. When the number of past iterations `i_p` of G passes a number `q2`, specified by the server 
+and in the range of `DEFAULT_SB_AUTH_INDEX_RANGE`, default set to `[627,1450)`, server sends 
+client a new Comm Lang file key.  
+
+Server does not require any user input. Client requires user to input IP address/port, as well 
+as for read/write operations to permitted files.  
+
+On the server side, every username it has stored in its client directory is associated with a 
+file for file+folder exclusions. These exclusions prohibit the client from read/write operations 
+concerning them.  
+
+## Default File Naming 
+
+- Server Side:  
+    - username directory file is @ `user_data/server_dir`.  
+    - directory file stores Comm Lang key file names and generator index (number of past iterations) 
+    for every username. 
+    - directory file column layout is 
+        - username  
+        - Comm Lang key filepath  
+        - primary generator name  
+        - generator index  
+        - number of sessions key has been used 
+    - every username `U` has a Comm Lang file key @ `user_data/commond_U.txt`.  
+    - default permissions file is @ `user_data/default_user_permissions.txt`.  
+    - every username `U` has an exclusion file @ `user_data/permissions_U.txt`.
+
+- Client Side: 
+    - username directory file is @ `user_data/client_dir`.  
+    - column layout is virtually identical to that of server side. 
+    - every server of IP address `I` and port `Q` is assigned a Comm Lang key file. 
+
+## The Identity Aspect 
+
+Websocket has the problem of authentication. If a username's Comm Lang file key for a  
+server is shared between `> 1` devices, those devices can all access the server under  
+the same username.  
+
+For a server with a fixed IP address and port combination, a device can only access it  
+through one username, given how the file naming convention goes.  
+
+## Technicals Behind the Generator Key  
+
+The program used to generator Comm Lang key files is `seqbuild` @  
+[Seqbuild](https://www.github.com/changissnz/seqbuild). Specifically, the Comm Lang file 
+generator is @ the file `face/easy_gen_struct.py`. There may be instances where the key 
+may be a generator such that two different devices output different sequences of integers. 
+So the Comm Lang key file generator is not guaranteed to be stable. 
+
+## Usage 
+
+Go into this directory, and run this script: 
+
+```
+from sb_auth.exec import * 
+```

sb_auth-0.0.1/README.md

@@ -0,0 +1,91 @@
+# sb_auth (SeqBuild Authenticator) 
+
+*Work in progress* 
+
+A WebSocket authentication schematic b/t two devices, both using the `Seqbuild` library. 
+
+Simple client-server layout. Authentication allows for file read/write operations to take 
+place between the two devices. 
+
+*NOTE*  
+The current websocket implementation uses the unsecured `ws://` protocol instead of the 
+secured `wss://` one. The development of this authenticator has not advanced into 
+production-level mode.  
+
+This codebase works for local WiFi networks but otherwise, more code with third-party 
+services must be used for secured communication. 
+
+## Description 
+
+There are three perspectives for use: 
+- local (server or client side): offline mode, used to modify read/write settings and delete bunk 
+Comm Lang key files.  
+- server: can serve an unspecified number of clients. Every authenticated client has read/write access to permitted files/folders.  
+- client: can access one server at a time to read/write permitted files.  
+
+The procedure in which a client interacts with a server goes so:  
+1. Client sends IP address and port number (default is 8765, variable<DEFAULT_PORT>), and 
+connects to the server.  
+2. Client inputs username. If server has no registered username, it sends client a new 
+Comm Lang file key. This is a script, containing a primary generator pseudo-random number 
+generator G, that can be executed by `seqbuild`'s Comm Lang interpreter. Client stores this
+Comm Lang file key and sets the number of past iterations `i_p` to 0.  
+3. Client is required to output `q` integers from generator G, `q` specified by the server and 
+in the range of `DEFAULT_SB_AUTH_KEYSIZE_RANGE`, default set to `[24,58]`, every time client 
+prompts to read/write a file.  
+4. When the number of past iterations `i_p` of G passes a number `q2`, specified by the server 
+and in the range of `DEFAULT_SB_AUTH_INDEX_RANGE`, default set to `[627,1450)`, server sends 
+client a new Comm Lang file key.  
+
+Server does not require any user input. Client requires user to input IP address/port, as well 
+as for read/write operations to permitted files.  
+
+On the server side, every username it has stored in its client directory is associated with a 
+file for file+folder exclusions. These exclusions prohibit the client from read/write operations 
+concerning them.  
+
+## Default File Naming 
+
+- Server Side:  
+    - username directory file is @ `user_data/server_dir`.  
+    - directory file stores Comm Lang key file names and generator index (number of past iterations) 
+    for every username. 
+    - directory file column layout is 
+        - username  
+        - Comm Lang key filepath  
+        - primary generator name  
+        - generator index  
+        - number of sessions key has been used 
+    - every username `U` has a Comm Lang file key @ `user_data/commond_U.txt`.  
+    - default permissions file is @ `user_data/default_user_permissions.txt`.  
+    - every username `U` has an exclusion file @ `user_data/permissions_U.txt`.
+
+- Client Side: 
+    - username directory file is @ `user_data/client_dir`.  
+    - column layout is virtually identical to that of server side. 
+    - every server of IP address `I` and port `Q` is assigned a Comm Lang key file. 
+
+## The Identity Aspect 
+
+Websocket has the problem of authentication. If a username's Comm Lang file key for a  
+server is shared between `> 1` devices, those devices can all access the server under  
+the same username.  
+
+For a server with a fixed IP address and port combination, a device can only access it  
+through one username, given how the file naming convention goes.  
+
+## Technicals Behind the Generator Key  
+
+The program used to generator Comm Lang key files is `seqbuild` @  
+[Seqbuild](https://www.github.com/changissnz/seqbuild). Specifically, the Comm Lang file 
+generator is @ the file `face/easy_gen_struct.py`. There may be instances where the key 
+may be a generator such that two different devices output different sequences of integers. 
+So the Comm Lang key file generator is not guaranteed to be stable. 
+
+## Usage 
+
+Go into this directory, and run this script: 
+
+```
+from sb_auth.exec import * 
+```

sb_auth-0.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "sb_auth"
+version = "0.0.1"
+dependencies = [
+"numpy>=1.22.1",
+"matplotlib>=3.5.3",
+"scipy>=1.14.1",
+"morebs2>=0.1.94",
+"python-resources>=0.3",
+"seqbuild>=0.0.49",
+]
+authors = [
+  { name="Richard Pham", email="phamrichard45@gmail.com" },
+]
+description = 'An implementation of a WebSocket authentication scheme, unsecured ws://'
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["sb_auth*"]
+
+[tool.setuptools.package-data]
+"seqbuild.face.sample_script" = ["*"]
+
+[project.urls]
+Homepage = "https://github.com/changissnz/sb_auth"
+Issues = "https://github.com/changissnz/sb_auth/issues"
+

sb_auth-0.0.1/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-0.0.1/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-0.0.1/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)