GNServer 0.0.0.0.59__py3-none-any.whl → 0.0.0.0.61__py3-none-any.whl

GNServer/_app.py

@@ -249,6 +249,8 @@ class App:
                 return r.handler(**kw)
 
             result = await r.handler(**kw)
+            if result is None:
+                result = AllGNFastCommands.ok()
             if isinstance(result, GNResponse):
                 if r.cors is None:
                     if result._cors is None:
@@ -339,30 +341,7 @@ class App:
 
                 if not stream: # если не стрим, то ждем конец quic стрима и запускаем обработку ответа
                     if event.end_stream:
-                            
-                        if self._api._kdc is not None:
-                            buf, domain = self._api._kdc.decode(bytes(buf))
-                        else:
-                            domain = None
-                        
-                        if buf is not None:
-                            try:
-                                request = GNRequest.deserialize(buf, mode)
-                                if domain is not None:
-                                    request.client._data['domain'] = domain
-                            except:
-                                asyncio.create_task(self.sendRawResponse(stream_id, AllGNFastCommands.KDCDecryptRequestFailed().serialize(mode=mode)))
-                                self._buffer.pop(event.stream_id, None)
-                                return
-
-                        else:
-                            raise Exception('Не удалось расшифровать от KDC')
-
-                        request.stream_id = stream_id   # type: ignore
-                        logger.debug(f'Request: {request.method} {request.url}')
-                        asyncio.create_task(self._handle_request(request, mode))
-
-                        self._buffer.pop(event.stream_id, None)
+                        asyncio.create_task(self._resolve_raw_request(stream_id, buf, mode))
                     return
                 
                 # если стрим, то смотрим сколько пришло данных
@@ -378,6 +357,9 @@ class App:
                 del buf[:lenght]
 
                 # формируем запрос
+
+                asyncio.create_task(self.sendRawResponse(stream_id, AllGNFastCommands.NotImplemented().serialize(mode=mode)))
+                return
                 
                 if self._api._kdc is not None:
                     data, domain = self._api._kdc.decode(data)
@@ -420,9 +402,37 @@ class App:
                     request._stream = w  # type: ignore
                     asyncio.create_task(self._handle_request(request, mode))
 
-        async def _handle_request(self, request: GNRequest, mode: int):
+        async def _resolve_raw_request(self, stream_id: int, data: bytes, mode: int):
 
+            if self._api._kdc is not None:
+                data, domain = await self._api._kdc.decode(bytes(data))
+            else:
+                domain = None
+            
+            if data is None:
+                self._buffer.pop(stream_id, None)
+                raise Exception('Не удалось расшифровать от KDC')
+        
+            try:
+                request = GNRequest.deserialize(data, mode)
+                if domain is not None:
+                    request.client._data['domain'] = domain
+            except:
+                self._buffer.pop(stream_id, None)
+                await self.sendRawResponse(stream_id, AllGNFastCommands.KDCDecryptRequestFailed().serialize(mode=mode))
+                return
+
+            logger.debug(f'[<] Request: {request.method} {request.url}')
+            
             request.client._data['remote_addr'] = self._quic._network_paths[0].addr
+            request.stream_id = stream_id   # type: ignore
+
+            self._buffer.pop(stream_id, None)
+            await self._handle_request(request, mode)
+
+
+        async def _handle_request(self, request: GNRequest, mode: int):
+
 
             try:
                 response = await self._api.dispatchRequest(request)
@@ -457,13 +467,13 @@ class App:
             await response.assembly()
 
             
-            logger.debug(f'Response: {request.method} {request.url} -> {response.command} {response.payload if len(str(response.payload)) < 256 else ''}')
+            logger.debug(f'[>] Response: {request.method} {request.url} -> {response.command} {response.payload if len(str(response.payload)) < 256 else ''}')
             
             blob = response.serialize(mode)
 
 
             if self._api._kdc is not None:
-                blob = self._api._kdc.encode(request.client.domain, blob)
+                blob = await self._api._kdc.encode(request.client.domain, blob)
 
             await self.sendRawResponse(request.stream_id, blob=blob, end_stream=end_stream)
 
@@ -542,4 +552,4 @@ class App:
                 cert_path=cert_path,
                 key_path=key_path,
                 host=host
-            )
+            )

GNServer/_client.py

@@ -189,15 +189,11 @@ class AsyncClient:
   
     async def connect(self, request: GNRequest, restart_connection: bool = False, reconnect_wait: float = 10, keep_alive: bool = True) -> 'QuicClient':
         domain = request.url.hostname
-        devLog(request, '1.2.1', 10, f'Connect to {domain}: restart_connection={restart_connection}, reconnect_wait={reconnect_wait}, keep_alive={keep_alive}')
         if not restart_connection and domain in self._active_connections:
             c = self._active_connections[domain]
-            devLog(request, '1.2.2', 10, f'Connection to {domain} found: status={c.status}')
             if c.status == 'connecting':
-                devLog(request, '1.2.3', 10, f'Waiting for connection to {domain}...')
                 try:
                     await asyncio.wait_for(c.connect_future, reconnect_wait)
-                    devLog(request, '1.2.4', 10, f'Connected to {domain}: status={c.status}')
                     if c.status == 'active':
                         return c
                     elif c.status == 'connecting': # если очень долго подключаемся, то кидаем ошибку
@@ -206,7 +202,6 @@ class AsyncClient:
                     elif c.status == 'disconnect':
                         raise GNExceptions.ConnectionError.client.connection
                 except:
-                    devLog(request, '1.2.5', 10, f'Connection to {domain} failed or timed out.')
                     await self.disconnect(domain)
                         
             else:
@@ -216,9 +211,7 @@ class AsyncClient:
         c.status = 'connecting'
         self._active_connections[domain] = c
 
-        devLog(request, '1.2.6', 10, f'Connecting to {domain}...')
         data = await self.getDNS(domain, raise_errors=True)
-        devLog(request, '1.2.7', 10, f'Got DNS for {domain}: {data}')
 
         data = data.split(':')
 
@@ -229,7 +222,6 @@ class AsyncClient:
 
         c._disconnect_signal = f # type: ignore
         c._domain = domain # type: ignore
-        devLog(request, '1.2.8', 10, f'Creating QuicClient for {domain}...')
         await c.connect(data[0], int(data[1]), keep_alive=keep_alive)
         await c.connect_future
 
@@ -625,7 +617,7 @@ class RawQuicClient(QuicConnectionProtocol):
             blob = request.serialize(_sys_s_mode)
 
             if self.quicClient._client._kdc is not None:
-                blob = self.quicClient._client._kdc.encode(request.url.hostname, blob)
+                blob = await self.quicClient._client._kdc.encode(request.url.hostname, blob)
                 
             sid = self._quic.get_next_available_stream_id()
             self._enqueue(sid, blob, True, False)
@@ -637,7 +629,7 @@ class RawQuicClient(QuicConnectionProtocol):
             data = await fut
             
             if self.quicClient._client._kdc is not None:
-                data, domain = self.quicClient._client._kdc.decode(data)
+                data, domain = await self.quicClient._client._kdc.decode(data)
 
             if data is not None:
                 r = GNResponse.deserialize(data, _sys_s_mode)

GNServer/models.py

@@ -1,5 +1,5 @@
 
-from typing import List, Optional, Dict
+from typing import List, Optional, Dict, Union
 from KeyisBTools.cryptography.sign import s2
 from KeyisBTools.cryptography import m1
 
@@ -9,12 +9,13 @@ 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]):
+    def __init__(self, domain: str, kdc_domain: str, kdc_key: bytes, requested_domains: List[str], active_key_synchronization: bool = True):
         self._domain = domain
         self._domain_hash = hash3(domain.encode())
         self._kdc_domain = kdc_domain
         self._kdc_key = kdc_key
         self._requested_domains = requested_domains
+        self._active_key_synchronization = active_key_synchronization
 
         from ._client import AsyncClient
         self._client = AsyncClient(domain)
@@ -28,13 +29,6 @@ class KDCObject:
 
     async def init(self, servers_keys: Optional[Dict[str, bytes]] = None): # type: ignore
 
-
-        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
-
-
         if servers_keys is not None:
             for i in self._requested_domains:
                 if i in servers_keys:
@@ -43,47 +37,63 @@ class KDCObject:
             servers_keys = {}
 
         if len(self._requested_domains) > 0:
-            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:
-                print(f'ERROR: {r.command} {r.payload}')
-                raise r
-            
-            if servers_keys is None:
-                print(f'ERROR: {r.command} {r.payload}')
-                raise r
-            
-            servers_keys.update(r.payload)
-
-
-        self._servers_keys.update(servers_keys)
+            await self.requestKDC(self._requested_domains) # type: ignore
 
+    
+    def _update(self):
         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
 
+    async def requestKDC(self, domain_or_hash: Union[str, bytes, List[Union[str, bytes]]]):
+        if self._kdc_domain not in self._servers_keys:
+            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
+
 
+        if not isinstance(domain_or_hash, list):
+            domain_or_hash = [domain_or_hash]
+        
+        r = await self._client.request(GNRequest('GET', Url(f'gn://{self._kdc_domain}/api/sys/server/keys'), payload=domain_or_hash))
 
+    
+        if not r.command.ok:
+            print(f'ERROR: {r.command} {r.payload}')
+            raise r
+        
+        self._servers_keys.update(r.payload)
+        self._update()
 
-    def encode(self, domain: str, request: bytes):
+
+    async def encode(self, domain: str, request: bytes):
         if domain not in self._servers_keys:
-            return request
+            if not self._active_key_synchronization:
+                return request
+            else:
+                await self.requestKDC(domain)
+
         key = self._servers_keys[domain]
         sig = s2.sign(key)
         data = m1.encrypt(domain.encode(), sig, request[8:], key)
         return request[:8] + sig + self._domain_hash + data
 
-    def decode(self, response: bytes):
+    async def decode(self, response: bytes):
+        r = response
         if len(response) < 8+164+64:
-            return response, None
+            return r, None
         h = response[:8]
         response = response[8:]
         sig, domain_h, data = response[:164], response[164:164+64], response[164+64:]
         if domain_h not in self._servers_keys_hash_domain:
-            print(domain_h, 'not in', self._servers_keys_hash_domain)
-            return response, None
+            if not self._active_key_synchronization:
+                print(domain_h, 'not in', self._servers_keys_hash_domain)
+                return r, None
+            else:
+                await self.requestKDC(domain_h)
+                
         d = self._servers_keys_hash_domain[domain_h]
         key = self._servers_keys[d]
         if not s2.verify(key, sig):

{gnserver-0.0.0.0.59.dist-info → gnserver-0.0.0.0.61.dist-info}/METADATA

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

{gnserver-0.0.0.0.59.dist-info → gnserver-0.0.0.0.61.dist-info}/RECORD

@@ -1,14 +1,14 @@
 GNServer/__init__.py,sha256=QmvIIE5RWIv040_l216aWtYuiIPtLasdsFbH0Fya2SI,1793
-GNServer/_app.py,sha256=bf5sXwimwgsSq51bK3YVq0e46p-0Hr9NY5wME2Okh54,19328
-GNServer/_client.py,sha256=MDAVnMGc5QNweOt8Tbas7OF9d_0Z3upxtrA7PmIttVs,33163
+GNServer/_app.py,sha256=VaQFxnIOC7xXnsbNP6UeknsJMLRAcqaNjrB1z7S8Oqg,19468
+GNServer/_client.py,sha256=J8dkXBlehb23FVM9dq6OX5xUxpAGX_DWX5abD0SfFe0,32422
 GNServer/_cors_resolver.py,sha256=aDxk4ItaEK-6vlDbkno8FJZEjczGEe8vkOui6_kz5-Y,5950
 GNServer/_crt.py,sha256=SOmyX7zBiCY9EhVSekksQtBHgTIZVvdqNZ8Ni-E5Zow,1390
 GNServer/_func_params_validation.py,sha256=pDXRzPVTdPnDHFMMmKd014SConBjFOuaLeJTY0vldlM,11412
 GNServer/_routes.py,sha256=bJnmQ8uEhPVQgy2tTqE5TEIM8aFXV-lVI7c2nG0rQwk,3384
 GNServer/_template_resolver.py,sha256=vdJYb_7PjIeTWq-Clr7jyj7QIvPBxplU7EqeOuMJ64c,1409
-GNServer/models.py,sha256=CXBJR_g3clIKKaMJ_zsUFLEG0EBa3g_Ik10te7whd30,3211
-gnserver-0.0.0.0.59.dist-info/licenses/LICENSE,sha256=_rN-sb3LemR3cKsEqjJRdXkdt7mME1mkW1BwWEn-zAw,1309
-gnserver-0.0.0.0.59.dist-info/METADATA,sha256=8x6eFAgjqAlpnOR29WUGyFwtj78jLfU0UARWXZMqTwM,830
-gnserver-0.0.0.0.59.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gnserver-0.0.0.0.59.dist-info/top_level.txt,sha256=-UOUBuD4u7Qkb1o5PdcwyA3kx8xCH2lwy0tJHi26Wb4,9
-gnserver-0.0.0.0.59.dist-info/RECORD,,
+GNServer/models.py,sha256=OlXrV823qaeL2oClodC_AC2r5S9CCZeCN_t8-sMgs2Y,3781
+gnserver-0.0.0.0.61.dist-info/licenses/LICENSE,sha256=_rN-sb3LemR3cKsEqjJRdXkdt7mME1mkW1BwWEn-zAw,1309
+gnserver-0.0.0.0.61.dist-info/METADATA,sha256=gUzbJhdOIambAewKEY17QWX1pcMqdogsk2faorIQRmU,830
+gnserver-0.0.0.0.61.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gnserver-0.0.0.0.61.dist-info/top_level.txt,sha256=-UOUBuD4u7Qkb1o5PdcwyA3kx8xCH2lwy0tJHi26Wb4,9
+gnserver-0.0.0.0.61.dist-info/RECORD,,