artystd 0.0.2__tar.gz

artystd-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arty
+
+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.

artystd-0.0.2/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.5
+Name: artystd
+Version: 0.0.2
+Summary: Arty's standard library
+Project-URL: Homepage, https://github.com/Artytuihj/Artys_STD_LIB
+Project-URL: Issues, https://github.com/Artytuihj/Artys_STD_LIB/issues/
+Author: Artytuihj
+License-Expression: MIT
+License-File: LICENSE
+Keywords: stdlib
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Provides-Extra: all
+Requires-Dist: artys-std[servernet]; extra == 'all'
+Provides-Extra: clientnet
+Requires-Dist: cryptography>=42; extra == 'clientnet'
+Requires-Dist: requests>=2.31; extra == 'clientnet'
+Provides-Extra: servernet
+Requires-Dist: artys-std[clientnet]; extra == 'servernet'
+Requires-Dist: fastapi>=0.110; extra == 'servernet'
+Description-Content-Type: text/markdown
+
+# Arty's STD LIB
+
+A collection of commonly used modules shared across all of My projects.
+
+## Modules
+
+| Module | Full name | What it does |
+|--------|-----------|--------------|
+| **ASHTP** | Arty's Secure HTTP Transport Protocol | Custom HTTP wrapper for environments where TLS and HTTPS aren't available |
+| **Events Manager** | Arty's Events Manager | Subscribe to and invoke events across threads and scripts |
+| **CAP** | Command and Argument Parser | Define commands along with their arguments and flags |
+
+---
+
+### ASHTP
+Custom HTTP wrapper for use when TLS and HTTPS aren't available.
+
+### Events Manager
+Lets events be subscribed to and invoked from different threads and scripts.
+
+### CAP
+Lets you define commands and their arguments and flags.

artystd-0.0.2/README.md

@@ -0,0 +1,22 @@
+# Arty's STD LIB
+
+A collection of commonly used modules shared across all of My projects.
+
+## Modules
+
+| Module | Full name | What it does |
+|--------|-----------|--------------|
+| **ASHTP** | Arty's Secure HTTP Transport Protocol | Custom HTTP wrapper for environments where TLS and HTTPS aren't available |
+| **Events Manager** | Arty's Events Manager | Subscribe to and invoke events across threads and scripts |
+| **CAP** | Command and Argument Parser | Define commands along with their arguments and flags |
+
+---
+
+### ASHTP
+Custom HTTP wrapper for use when TLS and HTTPS aren't available.
+
+### Events Manager
+Lets events be subscribed to and invoked from different threads and scripts.
+
+### CAP
+Lets you define commands and their arguments and flags.

artystd-0.0.2/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "artystd"
+version = "0.0.2"
+authors = [{ name = "Artytuihj" }]
+description = "Arty's standard library"
+
+requires-python = ">=3.10"
+keywords = ["stdlib"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+readme = "README.md"
+
+dependencies = []
+
+[project.optional-dependencies]
+clientnet = ["requests>=2.31", "cryptography>=42"]
+servernet = ["artys-std[clientnet]", "fastapi>=0.110"]
+all = ["artys-std[servernet]"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src"
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["/src/artystd"]
+
+[project.urls]
+Homepage = "https://github.com/Artytuihj/Artys_STD_LIB"
+Issues = "https://github.com/Artytuihj/Artys_STD_LIB/issues/"

artystd-0.0.2/src/artystd/ashtp/ASHTPClient.py

@@ -0,0 +1,533 @@
+#std
+import json
+import secrets
+import tempfile
+import time
+import zipfile
+from email import generator
+from pathlib import Path
+import asyncio
+import logging
+import base64
+import hashlib
+from typing import Iterable, Iterator
+
+#pypi
+import requests
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.exceptions import InvalidTag
+from requests import Response
+
+#in module
+from src.artystd.ashtp import PROTOCOL_VERSION
+from src.artystd.utilities.ArtysEventManager import ArtysEventManager
+
+
+class HandshakeError(Exception):
+    pass
+
+class ParsingError(Exception):
+    pass
+
+class ReplayError(Exception):
+    pass
+
+class ASHTPGeneralException(Exception):
+    pass
+
+
+def _DeriveKeys(secret:bytes, transcrypt:bytes, length:int=64)-> tuple[bytes,bytes]:
+    symKey = HKDF(algorithm=hashes.SHA256(), length=length, salt=None,
+                  info=b"ashtp sym sesscion key" + transcrypt).derive(secret)
+    return symKey[32:], symKey[:32]
+
+def _aad(sid: bytes, method: str, endpoint: str, ref: int | None = None) -> bytes:
+    if not endpoint.startswith("/"):
+        endpoint = "/" + endpoint
+    a = sid + method.upper().encode() + b" " + endpoint.encode()
+    if ref is not None:
+        a += b" " + ref.to_bytes(8, "little")   # fixed width at the end, so unambiguous
+    return a
+
+class Session():
+    def __init__(self, send_key:bytes, recv_key:bytes):
+        self.send = ChaCha20Poly1305(send_key)
+        self.recv = ChaCha20Poly1305(recv_key)
+        self.sendN = 0
+        self.recvN = -1
+
+    @staticmethod
+    def _nonce(n: int) -> bytes:
+        return b"\0" * 4 + n.to_bytes(8, "little") # generates a 12 byte number ( 0 0 0 0 )just filed with zeros (0 0 0 0 0 0 0 0) a simple counter little means less significant comes first
+
+    def Encrypt(self, data:bytes, tag:bytes = b""):
+        n = self.sendN # save the number used to build the nonce
+        self.sendN += 1 # increment
+        return n, self.send.encrypt(self._nonce(n), data, tag) # here we encrypt data with the send key and tag (ct stands for "cyphertext")
+
+    def Decrypt(self, data:bytes,n ,tag:bytes = b""):
+        if not ( self.recvN < n < 2**64): # make sure we are not being replayed and below the limit
+            raise ReplayError("The message is being replayed or key is stale. rekey! ")
+        dr = self.recv.decrypt(self._nonce(n), data, tag) # do the same as encrypt but backwards ("dr" stands for decryption result)
+        self.recvN = n
+        return dr
+
+class ASHTPClient:
+    def __init__(self,
+                 server_public_encryption_const: bytes,
+                 server_ip: str,
+                 server_port: int | None = None,
+                 url_prefix: str = "http://",
+                 url_health: str = "/health",
+                 url_handshake: str = "/privet",
+                 url_auth: str = "/auth",
+                 timeout_time: int = 5,
+                 max_reties: int = 5,
+                 health_poll_rate: int = 5):
+
+        # ----------------------------------------------
+        # |||  Arty's Secure HTTP Transport Protocol |||
+        # ----------------------------------------------
+
+        # ---------- protocol ----------
+        self._version: str = PROTOCOL_VERSION
+
+        # ---------- server address ----------
+        self.serverIp: str = server_ip
+        self.serverPort: int | None = server_port
+        self.serverPrefix: str = url_prefix
+        self.serverHealthEndpoint: str = url_health
+        self.serverHandshakeEndpoint: str = url_handshake
+        self.serverAuthEndpoint: str = url_auth
+        self.serverUrl: str = f"{self.serverPrefix}{self.serverIp}{f":{self.serverPort}" if self.serverPort else ""}"
+
+        # ---------- request behaviour ----------
+        self.timeoutTime: int = timeout_time
+        self.maxRequestRetries: int = max_reties
+
+        # ---------- health polling settings ----------
+        self.healthCheckRate: int = health_poll_rate
+
+        # ---------- file transfer ----------
+        self._tmp = Path(tempfile.gettempdir()) / "ashtp" / "C"
+        self._tmp.mkdir(parents=True, exist_ok=True)
+
+        # ---------- integrations (optional) ----------
+        self.logger = logging.getLogger(__name__)
+
+        # ---------- crypto / handshake ----------
+        self.Sb: bytes = server_public_encryption_const  # server's constant public key
+        self.HELLO_REPLY_FORMAT = {
+            "F":          {"type": bytes, "len": 32, "required": True}, # servers temp public key to make the symertric one
+            "session_id": {"type": bytes, "len": 16, "required": True}, # just a random id
+            "ok":         {"type": bytes, "len": 23, "required": True}, # ts sends "ok" and a 16 bit tag to detect tampering or corruption
+        }
+        self.AUTH_REPLY_FORMAT = {
+            "ok": {"type": str, "required": True}
+        }
+        self.secureTunnelActive = False
+        self.session:Session = None
+        self.sessionId:bytes = b""
+        self.apiKey: str = ""
+        self._connecting: bool = False
+        self._lastConnect: float = 0.0
+
+        # ---------- runtime state ----------
+        self.isOnline: bool = False
+        self.failedRequests: int = 0
+
+        # ---------- background tasks (keep last, they use everything above) ----------
+        self._healthTask = None
+
+    def Log(self, message:str):
+        self.logger.info(message)
+
+    def Error(self, message:str):
+        self.logger.error(message)
+
+    def emit(self, event:str ,*args, **kwargs):
+        ArtysEventManager.EmitEvent(event, *args, **kwargs)
+
+
+    def Parse(self, msg: dict, fmt: dict)-> dict:
+        """
+        takes one dict and compares it to a template
+        :param msg:
+        :param fmt:
+        :return:
+        """
+        if not isinstance(msg, dict) or set(msg) - set(fmt):
+            raise ParsingError("msg inst a dict or has forbidden fields")
+        output = {}
+
+        for name , spec in fmt.items():
+            if name not in msg:
+                if spec["required"]:
+                    raise ParsingError("msg is missing keys defined in template")
+                continue
+            value = msg[name]
+            if spec["type"] is bytes:
+                try:
+                    value = base64.b64decode(value, validate=True)
+                except Exception as e:
+                    raise ParsingError(f"{name} isn't bytes or the field is corrupted")
+
+                if len(value) != spec["len"]:
+                    raise ParsingError(f"{name} dosen't match length target")
+            elif not isinstance(value, spec["type"]):
+                raise ParsingError(f"{name} dosen't match type")
+            output[name] = value
+        return output
+
+    def Seal(self, msg:bytes, method:str, path:str,session:Session|None = None, sessionId:bytes|None = None, ref:int|None = None) -> tuple[bytes, int]:
+        """ Turns unencrypted JSON into request ready data
+
+        :param ref:
+        :param sessionId:
+        :param session:
+        :param msg:
+        :param method:
+        :param path:
+        :return:
+        """
+
+        sec = session if session is not None else self.session
+        secId = sessionId if sessionId is not None else self.sessionId
+
+        plain = json.dumps(msg).encode()
+        tag = _aad(secId, method, path, ref=ref)
+        n, data = sec.Encrypt(plain, tag)
+
+        return data, n
+
+    def SealFileStream(self, meta:dict, filePath:Path, method:str, path:str, chunkSize:int=64*1024,
+                       session:Session|None = None, sessionId:bytes|None = None, ref:int|None = None) -> Iterator[tuple[bytes, int]]:
+        """ Turns an unencrypted File into request ready byte stream
+
+        :param chunkSize:
+        :param filePath:
+        :param meta:
+        :param method:
+        :param path:
+        :param sessionId:
+        :param session:
+        :param ref:
+        :return:
+        """
+
+        sec = session if session is not None else self.session
+        secId = sessionId if sessionId is not None else self.sessionId
+        initialRequest = json.dumps( meta | {"chunk_size": chunkSize} ).encode()
+        with tempfile.TemporaryDirectory(dir=self._tmp) as td: # niche thing i like
+
+            zipPath = Path(td) / f"{filePath.name}.zip"
+            with zipfile.ZipFile(zipPath, "w", zipfile.ZIP_DEFLATED) as zf:
+                for file in filePath.rglob("*"):
+                    if file.is_dir():
+                        zf.write(file, arcname=str(file.relative_to(filePath)) + "/")
+                    else:
+                        zf.write(file, arcname=file.relative_to(filePath))
+
+            data, n = self.Seal(initialRequest, method, path, sec, secId, ref)
+            yield data, n
+
+            with zipPath.open("rb") as f:
+                while chunk := f.read(chunkSize):
+                    data, n = self.Seal(chunk, method, path, sec, secId, ref)
+                    yield data, n
+
+    def TearOpen(self, msg:bytes, method:str, path:str, serverCount:int, session:Session|None = None, sessionId:bytes|None = None, ref:int|None = None) -> dict:
+        """
+        Turns encrypt byte data into (hopefuly) a readable JSON
+
+        :param ref:
+        :param serverCount:
+        :param msg:
+        :param method:
+        :param path:
+        :param session:
+        :param sessionId:
+        :return:
+        """
+        sec = session if session is not None else self.session
+        secId = sessionId if sessionId is not None else self.sessionId
+
+        if sec is None or secId is None:
+            raise HandshakeError("no active session")
+
+        path = path if path.startswith("/") else "/" + path
+        n = serverCount
+        tag = _aad(secId, method, path, ref=ref)
+        plain  = sec.Decrypt(msg, n, tag)
+
+        return json.loads(plain.decode())
+
+    async def Init(self,api_key:str) -> bool:
+        """
+        Initializes the connection with the server and creates the encrypted authenticated channel.
+        This function HAS to be used at the start of comunication with any server running the "ashtp" protocol.
+        :param api_key:
+        :return:
+        """
+        self.apiKey = api_key
+        key_id = hashlib.blake2b(self.Sb, digest_size=8).digest()
+        proto = self._version.encode("utf-8")
+
+        for i in range(3):
+
+            e = X25519PrivateKey.generate() # clients private key
+            E = e.public_key() # clients public key
+            Eb = E.public_bytes( # clients public key but converted to bytes
+                encoding=serialization.Encoding.Raw,
+                format=serialization.PublicFormat.Raw
+            )
+
+            eS = e.exchange(X25519PublicKey.from_public_bytes(self.Sb)) # mix our private with servers const public
+
+            #handshake package
+            hello = {
+                "protocol": self._version,
+                "spk_hash": base64.b64encode( key_id ).decode(),
+                "E":        base64.b64encode( Eb ).decode(),
+            }
+
+            #send of the handshake
+            try:
+                resp = await asyncio.to_thread(requests.post, f"{self.serverUrl}{self.serverHandshakeEndpoint}",
+                                               json = hello, timeout = self.timeoutTime)
+                resp.raise_for_status() # neat thing it raises when bad status arrives like 500 or 404
+            except Exception as err:
+                self.failedRequests += 1
+                self.Error(str(err))
+                continue
+
+            try:
+                reply = self.Parse(resp.json(), self.HELLO_REPLY_FORMAT)# check that the handshake package is actualy valid
+                F = reply["F"]
+                eF = e.exchange(X25519PublicKey.from_public_bytes(F)) # exchange keys to get the secret number (mix our private with servers public)
+
+                c2s, s2c = _DeriveKeys(eS + eF, proto + key_id + Eb + F + self.Sb + reply["session_id"])
+                session = Session(c2s, s2c)
+
+                if session.Decrypt(reply["ok"],0, b"") != b"lets go":
+                    raise HandshakeError("<ok> didnt match the expected! keys/ package are either malformed or where tampered with")
+
+            except (HandshakeError, ParsingError, InvalidTag, ValueError) as err:
+                self.Error(f"Handshake Failed: {err}")
+                return False
+            try:
+                authPackage = json.dumps({ "api_key":api_key }).encode()
+
+                authBytes, n = self.Seal(authPackage, "POST", self.serverAuthEndpoint, session, reply["session_id"])
+                headers = {
+                    "ashtp-Session": base64.b64encode(reply["session_id"]).decode(),    # take session id make it into base64 and turn it into words
+                    "ashtp-Counter": str(n),                                            # the counter needed for encryption/decryption
+                    "ashtp-Content": "json",                                            # content type
+                }
+                resp = await asyncio.to_thread(requests.post, f"{self.serverUrl}{self.serverAuthEndpoint}",
+                                               data=authBytes, headers=headers, timeout=self.timeoutTime)
+                resp.raise_for_status()
+                serverCounter= int(resp.headers["ashtp-Counter"])
+                resp = self.TearOpen(resp.content, "POST", self.serverAuthEndpoint, serverCounter ,session, reply["session_id"], ref=n)
+
+                resp = self.Parse(resp, self.AUTH_REPLY_FORMAT)
+                if not resp.get("ok") == "ok": raise HandshakeError("couldnt log in")
+
+            except Exception as err:
+                self.Error(f"Handshake Failed: {err}")
+                return False
+
+
+            #lets go we connected
+
+            self.session = session
+            self.sessionId = reply["session_id"]
+            self.secureTunnelActive = True
+            self.isOnline = True
+            self.failedRequests = 0
+            self.emit("ashtp_server_status_changed", True)
+            return True
+        return False
+
+    async def CheckHealth(self):
+        combinedUrl = f"{self.serverUrl}{self.serverHealthEndpoint}"
+
+        while True:
+            try:
+                resp = await asyncio.to_thread(requests.get, combinedUrl,timeout=self.timeoutTime)
+                resp.raise_for_status()
+                if resp.json():
+                    self.failedRequests = 0
+                else:
+                    self.failedRequests += 1
+
+            except Exception as e:
+                print(e)
+                self.failedRequests += 1
+
+            prev = self.isOnline
+            if self.failedRequests > self.maxRequestRetries:
+                self.isOnline = False
+                self.secureTunnelActive = False
+            elif self.failedRequests == 0:
+                self.isOnline = True
+            if self.isOnline != prev:
+                self.Log(f"status -> {self.isOnline}")
+            self.emit("ashtp_server_status_changed", self.isOnline)
+
+            # rebuild the tunnel whenever the server is up but we have no working session
+            if (self.isOnline and not self.secureTunnelActive and self.apiKey
+                    and not self._connecting and time.monotonic() - self._lastConnect > 15):
+                self._connecting = True
+                self._lastConnect = time.monotonic()
+                try:
+                    await self.Init(self.apiKey)
+                except Exception as err:
+                    self.Error(f"reconnect failed: {err}")
+                finally:
+                    self._connecting = False
+
+            await asyncio.sleep(self.healthCheckRate)
+
+    async def _request(self, method: str, path: str, contentType:str, request: Iterable[bytes], timeout, usrHeaders:dict|None = None, sendBody: bool = True) -> dict:
+        if not self.isOnline:
+            raise ASHTPGeneralException("Server is offline")
+        if not self.secureTunnelActive:
+            raise ASHTPGeneralException("No active tunnel")
+
+        timeout = self.timeoutTime if timeout is None else timeout
+        path = path if path.startswith("/") else "/" + path
+        url = f"{self.serverUrl}{path}"
+
+        response:Response = Response()
+
+        if contentType == "json":
+            payload = next(iter(request)) if request is not None else json.dumps({"placeholder": secrets.randbits(64)}).encode()
+            last_error = ""
+            for attempt in range(self.maxRequestRetries):
+                data, n = self.Seal(payload, method, path)
+
+                headers = {
+                    "ashtp-Session": base64.b64encode(self.sessionId).decode(), # take session id make it into base64 and turn it into words
+                    "ashtp-Counter": str(n),                                    # the counter needed for encryption/decryption
+                    "ashtp-Content": "json",                                    # content type
+                }
+
+                kwargs = {"headers": (usrHeaders or {}) | headers, "timeout": timeout}
+                if sendBody:
+                    kwargs["data"] = data
+                if usrHeaders is not None:
+                    body = kwargs.setdefault("data", {})
+                    if not isinstance(body, dict):
+                        raise TypeError("user headers can only be attached to dict bodies")
+                    uh = body.setdefault("user_headers", {})
+                    for key, header in usrHeaders.items():
+                        if isinstance(header, str):
+                            header = header.encode()
+                        uh[key] = base64.b64encode(header).decode()
+                try:
+                    resp = await asyncio.to_thread(requests.request, method, url, **kwargs)
+                    resp.raise_for_status()
+                except requests.exceptions.HTTPError as e:
+                    self.failedRequests += 1
+                    last_error = str(e)
+                    if e.response is not None and e.response.status_code == 401:
+                        self.secureTunnelActive = False
+                    if e.response is not None and e.response.status_code < 500:
+                        raise ASHTPGeneralException(last_error) from e
+                except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
+                    self.failedRequests += 1
+                    last_error = str(e)
+                else:
+                    response = resp
+
+                await asyncio.sleep(
+                    min(0.25 * 2 ** attempt, 5))  # wait longer each time we fail to not hammer the server
+            raise ASHTPGeneralException(last_error)
+        elif contentType == "file":
+            payload = request
+
+        if (contentType := response.headers.get("ashtp-Content")) is not None:
+            if type == "json":
+                ...
+            elif type == "file":
+                ...
+        raise ASHTPGeneralException("welp...")
+
+
+    async def GetData(self, path:str, request:dict=None, timeout:float=None, usrHeaders:dict=None) -> dict:
+        return await self._request("GET", path, request, timeout, usrHeaders, sendBody=True)
+
+    async def PostData(self, path:str, request:dict, timeout:float=None, usrHeaders:dict=None) -> dict:
+        return await self._request("POST", path, request, timeout, usrHeaders)
+
+
+    async def GetFile(self, path:str, request:dict=None, timeout:float=None, usrHeaders:dict = None) -> Path:
+        """
+                Streams a file from the server.
+                Can only be used to request files!
+                If the file are larger than 1GB they will be put in tmp.
+
+                :param path:
+                :param usrHeaders:
+                :param timeout:
+                :param request:
+                :return: path to downlaoded file
+        """
+
+        if not self.isOnline:
+            raise ASHTPGeneralException("Server is offline")
+        if not self.secureTunnelActive:
+            raise ASHTPGeneralException("No active tunnel")
+
+        timeout = self.timeoutTime if timeout is None else timeout
+        path = path if path.startswith("/") else "/" + path
+        url = f"{self.serverUrl}{path}"
+        payload = request if request is not None else {"placeholder": secrets.randbits(64)}
+
+        data, headers, n = self.Seal(payload, "GET", url)
+        kwargs = {"headers": (usrHeaders or {}) | headers, "timeout": timeout}
+
+
+
+
+
+async def PostFile(self, endPoint: str, file:Path,headers:dict = {}) -> dict:
+    """
+    Posts file to the server.
+    Can only be used to upload files
+
+    :param endPoint:
+    :param file:
+    :return: response
+    """
+
+    if not self.isOnline:
+        return {"status": "failed", "code": "400", "message": "server is offline"}
+
+    if not self.isOnline:
+        return {"status": "failed", "code": "400", "message": "a secure connection to the server was not established"}
+
+    combinedUrl = f"{self.serverUrl}{endPoint if endPoint.startswith("/") else "/" + endPoint}"
+    kwargs = {"headers": self.persistentHeaders | headers}
+    last_error = ""
+
+    with open(file, "rb") as f:
+        kwargs["headers"]["Content-Name"] = f.name
+        kwargs["files"] = {"file": f}
+
+        for i in range(0, self.maxRequestRetries):
+            f.seek(0)
+            try:
+                resp = await asyncio.to_thread(requests.post, combinedUrl, **kwargs)
+                resp.raise_for_status()
+                response = resp.json()
+                self.failedRequests = 0
+                return response
+            except Exception as e:
+                last_error = e
+
+    return {"status": "failed", "code": "000", "message": str(last_error)}

artystd-0.0.2/src/artystd/ashtp/ASHTPServer.py

@@ -0,0 +1,425 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import tempfile
+import time
+from collections import deque
+from pathlib import Path
+
+from cryptography.exceptions import InvalidTag
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305
+from cryptography.hazmat.primitives import hashes, serialization
+import base64
+import hashlib
+from fastapi import FastAPI, Request, Response
+import logging
+import inspect
+
+from dataclasses import dataclass, field
+import secrets
+
+from src.artystd.ashtp import PROTOCOL_VERSION, SUPPORTED_SERVER_VERSIONS
+from src.artystd.ashtp.IKeyAuthority import IKeyAuthority as ika
+
+
+class HandshakeError(Exception):
+    pass
+class ParsingError(Exception):
+    pass
+class ReplayError(Exception):
+    pass
+class BodyTooLarge(Exception):
+    pass
+class ErrorHandlingError(Exception):
+    pass
+class ClientTooOldError(Exception):
+    ...
+class KeyLacksPermissionError(Exception):
+    ...
+
+def _DeriveKeys(secret:bytes, transcrypt:bytes, length:int=64)-> tuple[bytes,bytes]:
+    symKey = HKDF(algorithm=hashes.SHA256(), length=length, salt=None,
+                  info=b"ashtp sym sesscion key" + transcrypt).derive(secret)
+    return symKey[32:], symKey[:32]
+
+def _aad(sid: bytes, method: str, endpoint: str, ref: int | None = None) -> bytes:
+    if not endpoint.startswith("/"):
+        endpoint = "/" + endpoint
+    a = sid + method.upper().encode() + b" " + endpoint.encode()
+    if ref is not None:
+        a += b" " + ref.to_bytes(8, "little")   # fixed width at the end, so unambiguous
+    return a
+
+async def _ReadBody(req: Request, limit: int) -> tuple[bytes, dict]:
+    cl = req.headers.get("content-length")
+    if cl is not None and int(cl) > limit:
+        raise BodyTooLarge
+    buf = bytearray()
+    async for chunk in req.stream():
+        buf += chunk
+        if len(buf) > limit:
+            raise BodyTooLarge
+    return bytes(buf), dict(req.headers)
+
+@dataclass
+class ActiveSession:
+    session: Session
+    created: float = field(default_factory=time.monotonic)
+    permsLevel: int = -1
+    name: str = "None"
+class Session:
+    def __init__(self, send_key:bytes, recv_key:bytes):
+        self.send = ChaCha20Poly1305(send_key)
+        self.recv = ChaCha20Poly1305(recv_key)
+        self.sendN = 0
+        self.recvN = -1
+
+    @staticmethod
+    def _nonce(n: int) -> bytes:
+        return b"\0" * 4 + n.to_bytes(8, "little") # generates a 12 byte number ( 0 0 0 0 )just filed with zeros (0 0 0 0 0 0 0 0) a simple counter little means less significant comes first
+
+    def Encrypt(self, data:bytes, tag:bytes = b""):
+        n = self.sendN # save the number used to build the nonce
+        self.sendN += 1 # increment
+        return n, self.send.encrypt(self._nonce(n), data, tag) # here we encrypt data with the send key and tag (ct stands for "cyphertext")
+
+    def Decrypt(self, data:bytes,n ,tag:bytes = b""):
+        if not ( self.recvN < n < 2**64): # make sure we are not being replayed and below the limit
+            raise ReplayError("The message is being replayed or key is stale. rekey! ")
+        dr = self.recv.decrypt(self._nonce(n), data, tag) # do the same as encrypt but backwards ("dr" stands for decryption result)
+        self.recvN = n
+        return dr
+class RateLimiter:#neat  thingy
+    def __init__(self, limit: int, window: float):
+        self.limit = limit
+        self.window = window
+        self.hits: dict[str, deque[float]] = {} # store key and a queue of req attempts
+
+    def _Trim(self, key: str) -> deque:
+        q = self.hits.setdefault(key, deque()) # get the queue from the dict and if dosent exist yet make it
+        now = time.monotonic()
+        while q and now - q[0] > self.window: # repeat while q is a thing and q[0] fits within the window
+            q.popleft()
+        return q
+
+    def Count(self, key: str) -> int:#remove stale requests
+        return len(self._Trim(key))
+
+    def Blocked(self, key: str) -> bool:
+        return self.Count(key) >= self.limit# call count and check if we are over the limit
+
+    def Hit(self, key: str):
+        self._Trim(key).append(time.monotonic())# add to the counter
+
+class ASHTPServer:
+    def __init__(self,
+                 application:type[FastAPI],
+                 server_private_encryption_const: bytes,
+                 key_authority: ika,
+                 url_prefix: str = "http://",
+                 url_health: str = "/health",
+                 url_handshake: str = "/privet",
+                 url_auth: str = "/auth",):
+
+        # ----------------------------------------------
+        # |||  Arty's Secure HTTP Transport Protocol |||
+        # ----------------------------------------------
+
+        # --------- protocol ----------
+        self._version: str = PROTOCOL_VERSION
+
+        # ------- server address --------
+        self.serverPrefix: str = url_prefix
+        self.serverHealthEndpoint: str = url_health
+        self.serverHandshakeEndpoint: str = url_handshake
+        self.serverAuthEndpoint: str = url_auth
+
+        # -------- file transfer ---------
+        self._tmp = Path(tempfile.gettempdir()) / "ashtp" / "S"
+        self._tmp.mkdir(parents=True, exist_ok=True)
+
+        # ---------- crypto / handshake -------
+        self.sb: bytes = server_private_encryption_const  # server's constant private key
+        self.s = X25519PrivateKey.from_private_bytes(self.sb)  # servers const private
+        self.S = self.s.public_key()  # servers const public
+        self.Sb = self.S.public_bytes(  # const public in bytes
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw
+        )
+
+        self.HELLO_FORMAT = {
+            "protocol": {"type": str, "required": True},
+            "spk_hash": {"type": bytes, "len": 8, "required": True},
+            "E":        {"type": bytes, "len": 32, "required": True},
+        }
+        self.AUTH_FORMAT = {
+            "api_key": {"type": str, "required": True}
+        }
+        # ------- session management ---------
+        self.activeSessions: dict[bytes,ActiveSession] = {}
+        self.keyAuthority = key_authority
+
+        # --------- rate limits --------
+        self.hsLimit = RateLimiter(limit=300, window=60)
+        self.authFails = RateLimiter(limit=50, window=300)
+        self.maxSessions = 200
+
+        # -------- other ---------
+        self.logger = logging.getLogger(__name__)
+
+        # ------- app --------
+        self.app = application
+        self.app.add_api_route("/health", self.Health, methods=["GET"])
+        self.app.add_api_route("/privet", self.Handshake, methods=["POST"])
+        self.app.add_api_route("/auth", self.Authenticate, methods=["POST"])
+
+    # --------- tool chain --------
+    def Log(self, message:str):
+        self.logger.info(message)
+
+    def Error(self, message:str):
+        self.logger.error(message)
+
+    def Parse(self, msg: dict, baseModel: dict)-> dict:
+        """
+        takes one dict and compares it to a template
+        :param msg:
+        :param baseModel:
+        :return:
+        """
+        if not isinstance(msg, dict) or set(msg) - set(baseModel): # turn the dict into a set(storing the keys) and compare with base model
+            raise ParsingError("msg inst a dict or has forbidden fields")
+        output = {}
+
+        for name , spec in baseModel.items():
+            if name not in msg:
+                if spec["required"]:
+                    raise ParsingError("msg is missing keys defined in template")
+                continue
+            value = msg[name]
+            if spec["type"] is bytes:
+                try:
+                    value = base64.b64decode(value, validate=True)
+                except Exception as e:
+                    raise ParsingError(f"{name} isn't bytes or the field is corrupted")
+
+                if len(value) != spec["len"]:
+                    raise ParsingError(f"{name} dosen't match length target")
+            elif not isinstance(value, spec["type"]):
+                raise ParsingError(f"{name} dosen't match type")
+            output[name] = value
+        return output
+
+    def Expire(self, max_age: float = 10.0):
+        now = time.monotonic()
+        for sid, s in list(self.activeSessions.items()):
+            if s.permsLevel == -1 and now - s.created > max_age:
+                del self.activeSessions[sid]
+
+
+    def Seal(self, msg:dict, method:str, path:str, sessionId:bytes, ref:int|None = None ):
+        """ Turns unencrypted JSON into request ready data
+
+        :param ref:
+        :param sessionId:
+        :param session:
+        :param msg:
+        :param method:
+        :param path:
+        :return:
+        """
+
+        try:
+            sec = self.activeSessions[sessionId].session
+        except KeyError:
+            raise KeyError("[ashtp] Tried using expired session")
+
+
+        plain = json.dumps(msg).encode()
+        tag = _aad(sessionId, method, path, ref=ref)
+        n, data = sec.Encrypt(plain,tag)
+
+        headers = {
+            "ashtp-Session": base64.b64encode(sessionId).decode(), # take session id make it into base64 and turn it into words
+            "ashtp-Counter": str(n),# the counter needed for encryption/decryption
+            "ashtp-Content": "json",# content type
+        }
+
+        return data, headers, n
+
+    def TearOpen(self, msg:tuple[bytes,dict[str,str]], method:str, path:str, clientCount:int, sessionId:bytes, ref:int|None = None) -> tuple[dict,dict]:
+        """
+        Turns encrypt byte data into (hopefuly) a readable JSON
+
+        :param ref:
+        :param serverCount:
+        :param msg:
+        :param method:
+        :param path:
+        :param session:
+        :param sessionId:
+        :return:
+        """
+        sec = self.activeSessions[sessionId].session
+
+        path = path if path.startswith("/") else "/" + path
+        n = clientCount
+        tag = _aad(sessionId, method, path, ref=ref)
+        plain  = sec.Decrypt(msg[0], n, tag)
+        plainJson = json.loads(plain.decode())
+        headers = plainJson["user_headers"] | msg[1]
+        body = plainJson.pop("user_headers", None)
+
+        return body , headers
+
+    def Endpoint(self, path:str, method:str, minPerms:int|None = None, baseModel:dict|None = None, maxBody:int = 16 * 1024):
+        method = method.upper()
+
+        def decorator(fn):
+            async def endpoint(req:Request):
+                # unpack the request
+                try:
+                    sid = base64.b64decode(req.headers["ashtp-Session"])
+                    active = self.activeSessions.get(sid)
+                    requiredPermissionLevel = self.keyAuthority.minPermissionLevel if minPerms is None else minPerms
+
+
+                    if active is None or not self.keyAuthority.ComparePermissions(active.permsLevel, requiredPermissionLevel):
+                        return Response(status_code=403)# forbidden request
+
+                    counter = int(req.headers["ashtp-Counter"])
+
+                    contents, headers = self.TearOpen(await _ReadBody(req, maxBody), method, path, counter, sid)
+                    if baseModel: contents = self.Parse(contents, baseModel)
+
+                except (KeyError, ValueError, ReplayError, InvalidTag) as e:
+                    self.Error(f"{path}: {e}")
+                    return Response(status_code=400) # broken request
+                except BodyTooLarge:
+                    return Response(status_code=413) # body too large
+
+                # handle request
+                try:
+                    if inspect.iscoroutinefunction(fn):
+                        result = await fn(active, contents, headers)
+                    else:
+                        result = await asyncio.to_thread(fn, active, contents, headers)
+                except Exception as e:
+                    self.Error(f"{path} handler failed: {e}")
+                    return Response(status_code=500) # random error
+                try:
+                    data, headers, _ = self.Seal(result, method, path, sid, ref=counter)
+                    return Response(content=data, headers=headers, media_type="application/octet-stream")
+                except KeyError as e:
+                    self.Log(str(e))
+                    return Response(status_code=401) # Unotorised
+
+            self.app.add_api_route(path, endpoint, methods=[method])
+            return fn
+        return decorator
+
+
+    # ------------ endpoints ---------------
+
+    async def Health(self):
+        return {"code": 200, "message": "ok"}
+
+    async def Handshake(self, request: Request):
+
+        if self.hsLimit.Blocked("*"):
+            return Response(status_code=429)# rate limit exceeded
+        self.hsLimit.Hit("*")
+        self.Expire() # remove old sessions to prevent overflow
+
+        try:
+            body = await _ReadBody(request, 1024)
+            raw = self.Parse(json.loads(body), self.HELLO_FORMAT)
+
+
+            proto = raw["protocol"]
+            key_id = raw["spk_hash"]
+
+            if proto not in SUPPORTED_SERVER_VERSIONS: # check that the version matches
+                raise ClientTooOldError("Client is not supported")
+            if key_id != hashlib.blake2b(self.Sb, digest_size=8).digest(): # check the key matches
+                raise HandshakeError("Wrong/old public key")
+
+            Eb = raw["E"] # clients public bytes
+
+            sE = self.s.exchange(X25519PublicKey.from_public_bytes(Eb))  # mix our const private with Clients public
+
+            f = X25519PrivateKey.generate()
+            F = f.public_key()
+            Fb = F.public_bytes(
+                encoding=serialization.Encoding.Raw,
+                format=serialization.PublicFormat.Raw
+            )
+
+            sessionId = secrets.token_bytes(16) # make a session id
+
+            fE = f.exchange(X25519PublicKey.from_public_bytes(Eb))
+
+            c2s, s2c = _DeriveKeys(sE + fE, proto.encode() + key_id + Eb + Fb + self.Sb + sessionId)
+            session = Session(s2c, c2s)
+
+            if len(self.activeSessions) >= self.maxSessions:
+                unauth = [(s.created, k) for k, s in self.activeSessions.items() if s.permsLevel < 0]
+                if not unauth:
+                    return Response(status_code=503) # if we have all aslots taken refuse service
+                del self.activeSessions[min(unauth)[1]]
+
+            self.activeSessions[sessionId] = ActiveSession(session=session)
+            n, ct = session.Encrypt(b"lets go", b"")
+            reply = {
+                "F":          base64.b64encode( Fb ).decode(),
+                "session_id": base64.b64encode( sessionId ).decode(),
+                "ok":         base64.b64encode( ct ).decode()
+            }
+            return reply
+        except BodyTooLarge as e:
+            return Response(status_code=413) #body to large
+        except (ValueError, ParsingError, HandshakeError) as e:
+            self.Error(str(e))
+            return Response(status_code=400) # bad request
+        except ClientTooOldError:
+            return Response(status_code=426, headers={"ashtp-Upgrade": PROTOCOL_VERSION})
+
+    async def Authenticate(self, request: Request):
+        try:
+            raw = await _ReadBody(request, 2 * 1024)
+
+            sid = base64.b64decode(request.headers["ashtp-Session"])
+            active = self.activeSessions.get(sid)
+            if active is None:
+                raise HandshakeError("unknown session")
+
+            count = int(request.headers["ashtp-Counter"])
+
+            req = self.TearOpen(raw, "POST", self.serverAuthEndpoint, count, sid)
+            req = self.Parse(req, self.AUTH_FORMAT)
+
+            apiKey = req["api_key"]
+            allowed, permissionLevel, name = await self.keyAuthority.CheckPerms(apiKey)
+            if allowed:
+                active.permsLevel = permissionLevel
+                active.name = name
+
+                data, headers, n = self.Seal({"ok": "ok"}, "POST", self.serverAuthEndpoint, sid, count)
+                return Response(content=data, headers=headers)
+            else:
+                self.activeSessions.pop(sid)
+                self.authFails.Hit("*")
+                await asyncio.sleep(min(1 + 0.2 * self.authFails.Count("*"), 10))
+                raise KeyLacksPermissionError("Key dosen't have enough permissions or dosen't match")
+
+
+        except BodyTooLarge:
+            return Response(status_code=413) # too large bish
+        except (KeyError, ValueError, ParsingError, HandshakeError, ReplayError, InvalidTag) as e:
+            self.Error(str(e))
+            return Response(status_code=400)# bad req
+        except KeyLacksPermissionError:
+            return Response(status_code=403)# no no perms

artystd-0.0.2/src/artystd/ashtp/IKeyAuthority.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+
+class IKeyAuthority(ABC):
+    @property
+    @abstractmethod
+    def minPermissionLevel(self) -> int: ...
+
+    @abstractmethod
+    async def CheckPerms(self, apiKey: str) -> tuple[bool, int, str]:
+        """
+        Look up an API key.
+        Defined as async because DB lookup is expected.
+
+        Returns:
+            bool : whether the key meets minimum permission limit,
+            int : permission level of the key,
+            name : the username under which the key is registered
+
+        :param apiKey: The key of the client used to identify it
+        :returns:
+        """
+
+    @abstractmethod
+    def ComparePermissions(self, clientPerm: int, requiredPerm: int) -> bool:
+        """
+        Decide whether a client's permission level satisfies a required level.
+
+        What "satisfies" means depends on the application, so subclasses define it.
+
+        :param clientPerm: The permission level of the client making the request.
+        :param requiredPerm: The permission level the action requires.
+        :return: True if the client is allowed, False if not.
+        """
+

artystd-0.0.2/src/artystd/ashtp/StaticKeyPairGenerator.py

@@ -0,0 +1,19 @@
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+
+from pathlib import Path
+
+path = Path(__file__).resolve().parent
+
+def Generate():
+    """Standalone utility. Not intended to be called from production code.
+
+    Generates a fresh key pair and writes the key files next to this file.
+    """
+    priv = X25519PrivateKey.generate()
+    privB = priv.private_bytes_raw()
+    pubB = priv.public_key().public_bytes_raw()
+
+    (path / "public_key.bin").write_bytes(pubB)
+    (path / "private_key.bin").write_bytes(privB)
+
+Generate()

artystd-0.0.2/src/artystd/ashtp/__init__.py

@@ -0,0 +1,5 @@
+from .ASHTPClient import ASHTPClient
+from .ASHTPServer import ASHTPServer
+from .IKeyAuthority import IKeyAuthority
+PROTOCOL_VERSION = "ashtp/1.3"
+SUPPORTED_SERVER_VERSIONS = [PROTOCOL_VERSION]

artystd-0.0.2/src/artystd/utilities/ArtysEventManager.py

@@ -0,0 +1,30 @@
+import asyncio
+import inspect
+
+class ArtysEventManager:
+    _events: dict[str, list] = {}
+    _getters: dict[str,list] = {}
+
+    @classmethod
+    def Subscribe(cls, eventName:str):
+        def decorator(func):
+            cls._events.setdefault(eventName, []).append(func)
+            return func
+        return decorator
+
+    @classmethod
+    def On(cls, eventName: str, func):
+        cls._events.setdefault(eventName, []).append(func)
+
+    @classmethod
+    def EmitEvent(cls, eventName:str, *args, **kwargs):
+        for func in cls._events.get(eventName, []):
+            if inspect.iscoroutinefunction(func):
+                asyncio.create_task(func(*args, **kwargs))
+            else:
+                func(*args, **kwargs)
+
+    def RegisterGetter(self, name, variable):
+        pass
+
+

artystd-0.0.2/src/artystd/utilities/ArtysLogger.py

@@ -0,0 +1,14 @@
+import logging
+
+class ArtysLogger:
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
+        filename="app.log"
+    )
+
+    @classmethod
+    def getLog(cls,name):
+        return logging.getLogger(name)
+

artystd-0.0.2/src/artystd/utilities/__init__.py

@@ -0,0 +1,4 @@
+from .ArtysEventManager import ArtysEventManager
+from .cap import Cap
+from .ArtysLogger import ArtysLogger
+__version__ = 0.1

artystd-0.0.2/src/artystd/utilities/cap.py

@@ -0,0 +1,66 @@
+import shlex
+from dataclasses import dataclass, field
+from typing import Callable, Any
+
+@dataclass
+class ParsedCommand:
+    name:str
+    args:list[str] = field(default_factory=list)
+    flags:dict[str,Any] = field(default_factory=dict)
+
+@dataclass
+class _Registered:
+    func: Callable
+    min_args: int = 0
+    help: str = ""
+
+class CommandError(Exception):
+    """user-facing error (unknown cmd, bad args, ...)."""
+
+class Cap:
+    def __init__(self):
+        self._commands: dict[str, _Registered] = {}
+
+    def command(self, name: str, min_agrs: int = 0, helpStr: str = ""):
+        def decorator(func: Callable):
+            self._commands[name] = _Registered(func, min_agrs, helpStr)
+            return func
+        return decorator
+
+    def parse(self, raw: str) -> ParsedCommand:
+        try:
+            tokens = shlex.split(raw,posix=False)
+        except ValueError as e:
+            raise CommandError(f"bad quoting: {e}")
+
+        if not tokens:
+            raise CommandError("empty command")
+
+        name, rest = tokens[0], tokens[1:]
+        args:list[str] = []
+        flags: dict[str, Any] = {}
+
+        i = 0
+        while i < len(rest):
+            tok = rest[i]
+            if tok.startswith("--"):
+                if "=" in tok:
+                    k, v = tok[2:].split("=", 1)
+                    flags[k] = v
+                else:
+                    flags[tok[2:]] = True
+            else:
+                args.append(tok)
+            i += 1
+
+        return ParsedCommand(name, args, flags)
+
+    def run(self, command: str):
+        parsed = self.parse(command)
+        reg = self._commands.get(parsed.name)
+        if reg is None:
+            raise CommandError(f"unknown command: {parsed.name}")
+        if len(parsed.args) < reg.min_args:
+            raise CommandError(f"'{parsed.name}' needs at least {reg.min_args} arg(s)")
+        return reg.func(parsed.args, parsed.flags)
+