GNServer 0.0.0.0.47__tar.gz → 0.0.0.0.49__tar.gz

{gnserver-0.0.0.0.47 → gnserver-0.0.0.0.49}/GNServer/GNServer/_app.py

@@ -7,7 +7,7 @@ import asyncio
 import inspect
 import traceback
 import datetime
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union, AsyncGenerator
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union, AsyncGenerator, Awaitable
 from aioquic.asyncio.server import serve
 from aioquic.asyncio.protocol import QuicConnectionProtocol
 from aioquic.quic.configuration import QuicConfiguration
@@ -24,6 +24,7 @@ from ._cors_resolver import resolve_cors
 
 from ._routes import Route, _compile_path, _ensure_async, _convert_value
 
+from .models import KDCObject
 
 
 try:
@@ -120,6 +121,13 @@ class App:
 
         self.domain: str = None # type: ignore
 
+        self.__allowed_modes = (1, 2, 4)
+
+        self._kdc: Optional[KDCObject] = None
+
+    def setKDC(self, kdc: KDCObject):
+        self._kdc = kdc
+
     def route(self, method: str, path: str, cors: Optional[CORSObject] = None):
         if path == '/':
             path = ''
@@ -158,7 +166,7 @@ class App:
 
 
     def addEventListener(self, name: str):
-        def decorator(fn: Callable[[Optional[dict]], Any]):
+        def decorator(fn: Callable[[Callable[[dict | None], Awaitable[Any]]], None]):
             events = self._events.get(name, [])
             events.append({
                 'func': fn,
@@ -323,13 +331,21 @@ class App:
                 # получаем длинну пакета
                 mode, stream, lenght = GNRequest.type(buf)
 
-                if mode not in (1, 2, 4): # не наш пакет
-                    logger.debug(f'Пакет отклонен: mode пакета {mode}. Разрешен 1, 2, 3')
+                if mode not in self._api._App__allowed_modes: # не наш пакет # type: ignore
+                    logger.debug(f'Пакет отклонен: mode пакета {mode}. Разрешен 1, 2, 4')
                     return
                 
                 if not stream: # если не стрим, то ждем конец quic стрима и запускаем обработку ответа
                     if event.end_stream:
-                        request = GNRequest.deserialize(buf, mode)
+                            
+                        if self._api._kdc is not None:
+                            buf = self._api._kdc.decode(buf)
+                        
+                        if buf is not None:
+                            request = GNRequest.deserialize(buf, mode)
+                        else:
+                            raise Exception('Не удалось расшифровать от KDC')
+
                         request.stream_id = event.stream_id  # type: ignore
                         asyncio.create_task(self._handle_request(request, mode))
                         logger.debug(f'Отправлена задача разрешения пакета {request} route -> {request.route}')
@@ -350,6 +366,9 @@ class App:
                 del buf[:lenght]
 
                 # формируем запрос
+                
+                if self._api._kdc is not None:
+                    data = self._api._kdc.decode(data)
                 request = GNRequest.deserialize(data, mode)
 
                 logger.debug(request, f'event.stream_id -> {event.stream_id}')
@@ -411,7 +430,7 @@ class App:
                 await self.sendResponse(request, response, mode)
                 logger.debug(f'Отправлен на сервер ответ -> {response.command} {response.payload if response.payload and len(str(response.payload)) < 200 else ''}')
             except Exception as e:
-                if isinstance(e, GNFastCommand):
+                if isinstance(e, GNRequest):
                     await self.sendResponse(request, e, mode)
                 else:
                     logger.error('GNServer: error\n'  + traceback.format_exc())
@@ -422,9 +441,14 @@ class App:
         
         async def sendResponse(self, request: GNRequest, response: GNResponse, mode: int, end_stream: bool = True):
             await response.assembly()
+            
+            blob = response.serialize(mode)
+
 
+            if self._api._kdc is not None:
+                blob = self._api._kdc.encode(blob)
 
-            self._quic.send_stream_data(request.stream_id, response.serialize(mode), end_stream=end_stream) # type: ignore
+            self._quic.send_stream_data(request.stream_id, blob, end_stream=end_stream) # type: ignore
             self.transmit()
 
     def run(

{gnserver-0.0.0.0.47 → gnserver-0.0.0.0.49}/GNServer/GNServer/_client.py

@@ -84,7 +84,7 @@ from KeyisBTools.ranges.positionRange import in_range
 from gnobjects.net.objects import GNRequest, GNResponse, Url
 
 from ._crt import crt_client
-
+from .models import KDCObject
 
 
 _log_levels: dict[str, int] = {
@@ -124,10 +124,6 @@ def devLog(request: GNRequest, point: str, level: int, log: str):
 
 
 
-
-
-
-
 async def chain_async(first_item, rest: AsyncIterable) -> AsyncGenerator:
     yield first_item
     async for x in rest:
@@ -151,6 +147,8 @@ class AsyncClient:
 
         self.__domain = domain
 
+        self._kdc: Optional[KDCObject] = None
+
         if server_key:
             if isinstance(server_key, bytes):
                 self.__server_key = server_key
@@ -162,6 +160,8 @@ class AsyncClient:
         else:
             self.__server_key = None
 
+    def setKDC(self, kdc: KDCObject):
+        self._kdc = kdc
 
     def addRequestCallback(self, callback: Callable, name: str):
         self.__request_callbacks[name] = callback
@@ -195,7 +195,7 @@ class AsyncClient:
             else:
                 return c
 
-        c = QuicClient()
+        c = QuicClient(self)
         c.status = 'connecting'
         self._active_connections[domain] = c
 
@@ -252,7 +252,7 @@ class AsyncClient:
             request = await self._resolve_requests_transport(request)
             try:
                 c = await self.connect(request, restart_connection, reconnect_wait, keep_alive=keep_alive)
-            except Exception as e:
+            except BaseException as e:
                 if isinstance(e, GNResponse):
                     return e
                 else:
@@ -606,15 +606,26 @@ class RawQuicClient(QuicConnectionProtocol):
     async def request(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]]):
         if isinstance(request, GNRequest):
             blob = request.serialize(2)
+
+            if self.quicClient._client._kdc is not None:
+                blob = self.quicClient._client._kdc.encode(request.url.hostname, blob)
+                
             sid = self._quic.get_next_available_stream_id()
-            devLog(request, '1.3.1', 10, f'Sending request on stream {sid}')
             self._enqueue(sid, blob, True, False)
             self._schedule_flush()
 
             
             fut = asyncio.get_running_loop().create_future()
             self._inflight[sid] = fut
-            return await fut
+            data = await fut
+            
+            if self.quicClient._client._kdc is not None:
+                data = self.quicClient._client._kdc.decode(request.url.hostname, data)
+
+            if data is not None:
+                return GNResponse.deserialize(data, 2)
+            else:
+                return GNResponse('gn:client:0')
         
         else:
             sid = self._quic.get_next_available_stream_id()
@@ -692,7 +703,8 @@ class RawQuicClient(QuicConnectionProtocol):
 class QuicClient:
     """Обёртка‑фасад над RawQuicClient."""
 
-    def __init__(self):
+    def __init__(self, Client: AsyncClient):
+        self._client = Client
         self._quik_core: Optional[RawQuicClient] = None
         self._client_cm = None
         self._disconnect_signal = None
@@ -768,9 +780,7 @@ class QuicClient:
             raise RuntimeError("Not connected")
         
         resp = await self._quik_core.request(request)
-        r = GNResponse.deserialize(resp, 2)
-        devLog(request, '1.4.1', 10, f'Response received: {r}')
-        return r
+        return resp
 
     async def asyncRequestStream(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]]) -> AsyncGenerator[GNResponse, None]:
         

gnserver-0.0.0.0.49/GNServer/GNServer/models.py

@@ -0,0 +1,69 @@
+
+from typing import List, Optional, Dict
+from KeyisBTools.cryptography.sign import s2
+from KeyisBTools.cryptography import m1
+
+from ._client import AsyncClient
+from ._app import GNRequest, GNResponse
+from gnobjects.net.objects import Url
+
+from KeyisBTools.cryptography.bytes import hash3
+
+class KDCObject:
+    def __init__(self, domain: str, kdc_domain: str, kdc_key: bytes, requested_domains: List[str]):
+        self._domain = domain
+        self._kdc_domain = kdc_domain
+        self._kdc_key = kdc_key
+        self._requested_domains = requested_domains
+
+        self._client = AsyncClient(domain)
+
+        self._servers_keys: Optional[Dict[str, bytes]] = None
+        self._servers_keys_hash_domain: Dict[bytes, str] = {}
+        self._servers_keys_domain_hash: Dict[str, bytes] = {}
+
+
+
+
+    async def init(self):
+        payload = self._requested_domains
+        r = await self._client.request(GNRequest('GET', Url(f'gn://{self._kdc_domain}/api/sys/server/keys'), payload=payload))
+
+        if not r.command.ok:
+            raise r
+        
+        self._servers_keys: Dict[str, bytes]  = r.payload
+
+        for domain in self._servers_keys.keys():
+            h = hash3(domain.encode())
+            self._servers_keys_hash_domain[h] = domain
+            self._servers_keys_domain_hash[domain] = h
+
+
+        self._servers_keys[self._kdc_domain] = self._kdc_key
+        h = hash3(self._kdc_domain.encode())
+        self._servers_keys_hash_domain[h] = self._kdc_domain
+        self._servers_keys_domain_hash[self._kdc_domain] = h
+
+
+    def encode(self, domain: str, request: bytes):
+        if domain not in self._servers_keys:
+            return request
+
+        sig = s2.sign(self._kdc_key)
+        data = m1.encrypt(self._domain.encode(), sig, request, self._kdc_key)
+        return sig + self._servers_keys_domain_hash[domain] + data
+    
+    def decode(self, response: bytes):
+        if len(response) < 164+64:
+            return response
+        
+        sig, domain_h, data = response[:164], response[164:164+64], response[164+64:]
+
+        if domain_h not in self._servers_keys_hash_domain:
+            return response
+
+        key = self._servers_keys[self._servers_keys_hash_domain[domain_h]]
+        if not s2.verify(key, sig):
+            return None
+        return m1.decrypt(self._domain.encode(), sig, data, key)

{gnserver-0.0.0.0.47 → gnserver-0.0.0.0.49}/GNServer/GNServer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GNServer
-Version: 0.0.0.0.47
+Version: 0.0.0.0.49
 Summary: GNServer
 Home-page: https://github.com/KeyisB/libs/tree/main/GNServer
 Author: KeyisB

{gnserver-0.0.0.0.47 → gnserver-0.0.0.0.49}/GNServer/GNServer.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ GNServer/GNServer/_crt.py
 GNServer/GNServer/_func_params_validation.py
 GNServer/GNServer/_routes.py
 GNServer/GNServer/_template_resolver.py
+GNServer/GNServer/models.py
 GNServer/GNServer.egg-info/PKG-INFO
 GNServer/GNServer.egg-info/SOURCES.txt
 GNServer/GNServer.egg-info/dependency_links.txt

{gnserver-0.0.0.0.47 → gnserver-0.0.0.0.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GNServer
-Version: 0.0.0.0.47
+Version: 0.0.0.0.49
 Summary: GNServer
 Home-page: https://github.com/KeyisB/libs/tree/main/GNServer
 Author: KeyisB

{gnserver-0.0.0.0.47 → gnserver-0.0.0.0.49}/setup.py

@@ -5,7 +5,7 @@ filesName = 'GNServer'
 
 setup(
     name=name,
-    version='0.0.0.0.47',
+    version='0.0.0.0.49',
     author="KeyisB",
     author_email="keyisb.pip@gmail.com",
     description=name,