GNServer 0.0.0.0.60__tar.gz → 0.0.0.0.61__tar.gz

{gnserver-0.0.0.0.60 → gnserver-0.0.0.0.61}/GNServer/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-0.0.0.0.60 → gnserver-0.0.0.0.61}/GNServer/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-0.0.0.0.60 → gnserver-0.0.0.0.61}/GNServer/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 → gnserver-0.0.0.0.61}/GNServer/GNServer.egg-info/PKG-INFO

@@ -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 → gnserver-0.0.0.0.61}/PKG-INFO

@@ -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 → gnserver-0.0.0.0.61}/setup.py

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