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

GNServer/_app.py

@@ -341,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
                 
                 # если стрим, то смотрим сколько пришло данных
@@ -380,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)
@@ -422,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)
@@ -465,7 +473,7 @@ class App:
 
 
             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)
 

GNServer/_client.py

@@ -617,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)
@@ -629,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
 
-        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 servers_keys is not None:
             for i in self._requested_domains:
                 if i in servers_keys:
@@ -43,39 +37,50 @@ 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))
 
-    def encode(self, domain: str, request: bytes):
+    
+        if not r.command.ok:
+            print(f'ERROR: {r.command} {r.payload}')
+            raise r
+        
+        self._servers_keys.update(r.payload)
+        self._update()
+
+
+    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 r, None
@@ -83,8 +88,12 @@ class KDCObject:
         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 r, 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.60.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.60
+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.60.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=ffr4Ar-hV5m0ED-dGDQw5RYymmpUWF5Uzp3k2ZCV1wk,19414
-GNServer/_client.py,sha256=Rp5INEVFfeD3rdm0tppjyGKqNT6yLe_STEVVNDJUpKw,32410
+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=QkDVNUvRhm3k_z1GSzQ8xGPcFhi9LbzWDrZnO33cHso,3289
-gnserver-0.0.0.0.60.dist-info/licenses/LICENSE,sha256=_rN-sb3LemR3cKsEqjJRdXkdt7mME1mkW1BwWEn-zAw,1309
-gnserver-0.0.0.0.60.dist-info/METADATA,sha256=poKkvSjNlosNVlL5sMaLV_AHnhDjf_gS60N76clzTIk,830
-gnserver-0.0.0.0.60.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gnserver-0.0.0.0.60.dist-info/top_level.txt,sha256=-UOUBuD4u7Qkb1o5PdcwyA3kx8xCH2lwy0tJHi26Wb4,9
-gnserver-0.0.0.0.60.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,,