GNServer 0.0.0.0.60__tar.gz → 0.0.0.0.62__tar.gz

{gnserver-0.0.0.0.60 → gnserver-0.0.0.0.62}/GNServer/GNServer/_app.py

@@ -18,14 +18,15 @@ from typing import Any, AsyncGenerator, Union
 from gnobjects.net.objects import GNRequest, GNResponse, FileObject, CORSObject, TemplateObject
 from gnobjects.net.fastcommands import AllGNFastCommands, GNFastCommand
 
+from KeyisBTools.cryptography.bytes import userFriendly
 
 from ._func_params_validation import register_schema_by_key, validate_params_by_key
 from ._cors_resolver import resolve_cors
-
 from ._routes import Route, _compile_path, _ensure_async, _convert_value
-
 from .models import KDCObject
+from ._client import AsyncClient
 
+from pathlib import Path
 
 try:
     if not sys.platform.startswith("win"):
@@ -122,6 +123,8 @@ class App:
 
         self._kdc: Optional[KDCObject] = None
 
+        self.client = AsyncClient()
+
     def setKDC(self, kdc: KDCObject):
         self._kdc = kdc
 
@@ -341,30 +344,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 +360,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 +405,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 +476,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)
 
@@ -479,21 +490,50 @@ class App:
         port: int,
         cert_path: str,
         key_path: str,
+        server_key: Optional[Union[str, Path]] = None,
         *,
         host: str = '0.0.0.0',
         idle_timeout: float = 20.0,
         wait: bool = True,
-        run: Optional[Callable] = None
+        run: Optional[Callable] = None,
+        kdc_passive_key_sync_domains: List[str] = [],
+        kdc_active_key_synchronization: bool = True
     ):
         """
         # Запустить сервер
 
         Запускает сервер в главном процессе asyncio.run()
+
+        server_key:  `:kdc.core:<...>:<...>:`
         """
 
         self.domain = domain
 
 
+        if server_key is not None:
+            if isinstance(server_key, Path):
+                server_key = server_key.read_text('utf-8')
+
+            if server_key[0] == ':' and server_key[0] == ':':
+                kdc_domain, dns_key, kdc_key = server_key.split(':')
+            
+                dns_key = userFriendly.decode(dns_key)
+                kdc_key = userFriendly.decode(kdc_key)
+                    
+                kdc = KDCObject(self.domain, kdc_domain, kdc_key, kdc_passive_key_sync_domains, active_key_synchronization=kdc_active_key_synchronization)
+                self.setKDC(kdc)
+
+                if self.client._domain is None:
+                    self.client._domain = domain
+                if self.client._dns_key is None:
+                    self.client.setDNSkey(dns_key)
+
+
+
+
+
+
+
         self._init_sys_routes()
 
         cfg = QuicConfiguration(

{gnserver-0.0.0.0.60 → gnserver-0.0.0.0.62}/GNServer/GNServer/_client.py

@@ -161,20 +161,26 @@ class AsyncClient:
         self.__dns_client: Optional[AsyncClient] = None
         self._dns_cache: TTLDict = TTLDict()
 
-        self.__domain = domain
+        self._domain = domain
 
         self._kdc: Optional[KDCObject] = None
 
+        
         if server_key:
-            if isinstance(server_key, bytes):
-                self.__server_key = server_key
+            self.setDNSkey(server_key)
+
+
+    def setDNSkey(self, key: Union[bytes, str]):
+        if key:
+            if isinstance(key, bytes):
+                self._dns_key = key
             else:
-                if os.path.exists(server_key):
-                    self.__server_key = open(server_key, 'rb').read()
+                if os.path.exists(key):
+                    self._dns_key = open(key, 'rb').read()
                 else:
-                    self.__server_key = userFriendly.decode(server_key)
+                    self._dns_key = userFriendly.decode(key)
         else:
-            self.__server_key = None
+            self._dns_key = None
 
     def setKDC(self, kdc: KDCObject):
         self._kdc = kdc
@@ -348,10 +354,10 @@ class AsyncClient:
         if self.__dns_client is None:
             self.__dns_client = AsyncClient()
 
-        if self.__server_key is not None:
-            s = s2.sign(self.__server_key)
-            data = m1.encrypt(s, domain.encode(), serialize({'domain': domain}), hash(self.__server_key))
-            payload = {'sign': {'alg': 'KeyisB-c-s-m1', 'data': s, 'domain': self.__domain}, 'data': data}
+        if self._dns_key is not None:
+            s = s2.sign(self._dns_key)
+            data = m1.encrypt(s, domain.encode(), serialize({'domain': domain}), hash(self._dns_key))
+            payload = {'sign': {'alg': 'KeyisB-c-s-m1', 'data': s, 'domain': self._domain}, 'data': data}
         else:
             payload = None
         
@@ -617,7 +623,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 +635,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.62}/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,49 @@ 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 domain is None or 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,10 +87,14 @@ 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 domain_h is None or 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):
             return None, None
-        return h + m1.decrypt(self._domain.encode(), sig, data, key), d
+        return h + m1.decrypt(self._domain.encode(), sig, data, key), d

{gnserver-0.0.0.0.60 → gnserver-0.0.0.0.62}/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.62
 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.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GNServer
-Version: 0.0.0.0.60
+Version: 0.0.0.0.62
 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.62}/setup.py

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