async def set_security( self, policy: ua.SecurityPolicy, certificate: Union[str, uacrypto.CertProperties], private_key: Union[str, uacrypto.CertProperties], private_key_password: Optional[Union[str, bytes]] = None, server_certificate: Optional[Union[str, uacrypto.CertProperties]] = None, mode: ua.MessageSecurityMode = ua.MessageSecurityMode.SignAndEncrypt, ): """ Set SecureConnection mode. Call this before connect() """ if server_certificate is None: # Force unencrypted/unsigned SecureChannel to list the endpoints new_policy = ua.SecurityPolicy() self.security_policy = new_policy self.uaclient.security_policy = new_policy # load certificate from server's list of endpoints endpoints = await self.connect_and_get_server_endpoints() endpoint = Client.find_endpoint(endpoints, mode, policy.URI) server_certificate = uacrypto.x509_from_der( endpoint.ServerCertificate) elif not isinstance(server_certificate, uacrypto.CertProperties): server_certificate = uacrypto.CertProperties(server_certificate) if not isinstance(certificate, uacrypto.CertProperties): certificate = uacrypto.CertProperties(certificate) if not isinstance(private_key, uacrypto.CertProperties): private_key = uacrypto.CertProperties( private_key, password=private_key_password) return await self._set_security(policy, certificate, private_key, server_certificate, mode)
def __init__(self, url: str, timeout: int = 4, loop=None): """ :param url: url of the server. if you are unsure of url, write at least hostname and port and call get_endpoints :param timeout: Each request sent to the server expects an answer within this time. The timeout is specified in seconds. Some other client parameters can be changed by setting attributes on the constructed object: See the source code for the exhaustive list. """ self.loop = loop or asyncio.get_event_loop() self.server_url = urlparse(url) # take initial username and password from the url self._username = self.server_url.username self._password = self.server_url.password self.name = "Pure Python Async. Client" self.description = self.name self.application_uri = "urn:freeopcua:client" self.product_uri = "urn:freeopcua.github.io:client" self.security_policy = ua.SecurityPolicy() self.secure_channel_id = None self.secure_channel_timeout = 3600000 # 1 hour self.session_timeout = 3600000 # 1 hour self._policy_ids = [] self.uaclient: UaClient = UaClient(timeout, loop=self.loop) self.user_certificate = None self.user_private_key = None self._server_nonce = None self._session_counter = 1 self.nodes = Shortcuts(self.uaclient) self.max_messagesize = 0 # No limits self.max_chunkcount = 0 # No limits self._renew_channel_task = None
def __init__(self, timeout=1, security_policy=ua.SecurityPolicy(), loop=None): """ :param timeout: Timeout in seconds :param security_policy: Security policy (optional) :param loop: Event loop (optional) """ self.logger = logging.getLogger(f"{__name__}.UASocketProtocol") self.loop = loop or asyncio.get_event_loop() self.transport = None self.receive_buffer: Optional[bytes] = None self.is_receiving = False self.timeout = timeout self.authentication_token = ua.NodeId() self._request_id = 0 self._request_handle = 0 self._callbackmap: Dict[int, asyncio.Future] = {} self._connection = SecureConnection(security_policy) self.state = self.INITIALIZED self.closed: bool = False # needed to pass params from asynchronous request to synchronous data receive callback, as well as # passing back the processed response to the request so that it can return it. self._open_secure_channel_exchange = None
def __init__(self, timeout=1, loop=None): self.logger = logging.getLogger(__name__ + '.UaClient') self.loop = loop or asyncio.get_event_loop() self._publish_callbacks = {} self._timeout = timeout self.security_policy = ua.SecurityPolicy() self.protocol: UASocketProtocol = None self._sub_cond = asyncio.Condition() self._sub_data_queue = []
def __init__(self, timeout=1): """ :param timeout: Timout in seconds """ self.logger = logging.getLogger(f'{__name__}.UaClient') self._subscription_callbacks = {} self._timeout = timeout self.security_policy = ua.SecurityPolicy() self.protocol: Optional[UASocketProtocol] = None self._publish_task = None
def __init__(self, internal_server: InternalServer, transport): self.iserver: InternalServer = internal_server self.name = transport.get_extra_info('peername') self.sockname = transport.get_extra_info('sockname') self.session: Optional[InternalSession] = None self._transport = transport # deque for Publish Requests self._publish_requests: Deque[PublishRequestData] = deque() # used when we need to wait for PublishRequest self._publish_results: Deque[ua.PublishResult] = deque() self._connection = SecureConnection(ua.SecurityPolicy())
def __init__(self, timeout=1, security_policy=ua.SecurityPolicy(), loop=None): self.logger = logging.getLogger(__name__ + ".UASocketProtocol") self.loop = loop or asyncio.get_event_loop() self.transport = None self.receive_buffer: bytes = None self.is_receiving = False self.timeout = timeout self.authentication_token = ua.NodeId() self._request_id = 0 self._request_handle = 0 self._callbackmap = {} self._connection = SecureConnection(security_policy) self.state = self.INITIALIZED
def __init__(self, timeout=1, security_policy=ua.SecurityPolicy(), loop=None): """ :param timeout: Timeout in seconds :param security_policy: Security policy (optional) :param loop: Event loop (optional) """ self.logger = logging.getLogger(f"{__name__}.UASocketProtocol") self.loop = loop or asyncio.get_event_loop() self.transport = None self.receive_buffer: Optional[bytes] = None self.is_receiving = False self.timeout = timeout self.authentication_token = ua.NodeId() self._request_id = 0 self._request_handle = 0 self._callbackmap: Dict[int, asyncio.Future] = {} self._connection = SecureConnection(security_policy) self.state = self.INITIALIZED
def test_message_chunk(): pol = ua.SecurityPolicy() chunks = MessageChunk.message_to_chunks(pol, b'123', 65536) assert len(chunks) == 1 seq = 0 for chunk in chunks: seq += 1 chunk.SequenceHeader.SequenceNumber = seq chunk2 = MessageChunk.from_binary(pol, ua.utils.Buffer(chunks[0].to_binary())) assert chunks[0].to_binary() == chunk2.to_binary() # for policy None, MessageChunk overhead is 12+4+8 = 24 bytes # Let's pack 11 bytes into 28-byte chunks. The message must be split as 4+4+3 chunks = MessageChunk.message_to_chunks(pol, b'12345678901', 28) assert len(chunks) == 3 assert chunks[0].Body == b'1234' assert chunks[1].Body == b'5678' assert chunks[2].Body == b'901' for chunk in chunks: seq += 1 chunk.SequenceHeader.SequenceNumber = seq assert len(chunk.to_binary()) <= 28