[WIP] OPC UA

.gitignore

@@ -8,3 +8,8 @@ scapy/VERSION
 test/*.html
 .tox
 doc/scapy/_build
+
+.idea/
+/venv*/
+*.der
+*.pem

scapy/contrib/opcua/__init__.py

@@ -0,0 +1,3 @@
+"""
+Tools for handling OPC UA communication
+"""

scapy/contrib/opcua/binary/automaton.py

@@ -0,0 +1,111 @@
+# coding=utf-8
+"""
+This module contains an automaton prototype with methods that are used by both the client and server automaton.
+"""
+import copy
+import logging
+from scapy.automaton import Automaton, Message, _ATMT_Command, select_objects
+from scapy.contrib.opcua.helpers import UaConnectionContext
+import os
+
+
+class _UaAutomaton(Automaton):
+
+    def __init__(self, *args, **kwargs):
+        super(_UaAutomaton, self).__init__(*args, **kwargs)
+        self._stopped = False
+
+    def parse_args(self, debug=0, store=False, connectionContext=UaConnectionContext(), target="localhost",
+                   targetPort=4840, timeout=None, **kwargs):
+        super(_UaAutomaton, self).parse_args(debug, store, **kwargs)
+        self.target = target
+        self.targetPort = targetPort
+        self._connectionContextProto = copy.copy(connectionContext)
+        self._connectionContext = connectionContext
+        self._timeout = timeout
+        self.send_sock_class = lambda **x: None
+        self.recv_sock_class = lambda **x: None
+        self.send_sock = None
+        self.listen_sock = None
+
+    def __del__(self):
+        if not self._stopped:
+            super(_UaAutomaton, self).__del__()
+
+    def stop(self):
+        """
+        Stops the automaton.
+        This method is overridden to make sure the automaton is ended in a graceful manner.
+        This requires sending a message on the shutdown socket so that the automaton can
+        perform the necessary steps to correctly close the connection.
+        """
+        self.io.shutdown.send(None)
+        ended = self.started.acquire(timeout=2)
+        if ended:
+            self.started.release()
+        else:
+            self.cmdin.send(Message(type=_ATMT_Command.STOP))
+        with self.started:
+            # Flush command pipes
+            while True:
+                r = select_objects([self.cmdin, self.cmdout], 0)
+                if not r:
+                    break
+                for fd in r:
+                    fd.recv()
+            self._close_sockets()
+        self._stopped = True
+
+    def _close_sockets(self):
+        """
+        Closes all sockets used by the automaton.
+        The network sockets shall be closed by the automaton itself upon receiving the shutdown message.
+        """
+        for name in self.ionames:
+            try:
+                os.close(self.ioin[name].rd)
+            except OSError:
+                pass
+            try:
+                os.close(self.ioin[name].wr)
+            except OSError:
+                pass
+            try:
+                os.close(self.ioout[name].rd)
+            except OSError:
+                pass
+            try:
+                os.close(self.ioout[name].wr)
+            except OSError:
+                pass
+        try:
+            os.close(self.cmdin.wr)
+        except OSError:
+            pass
+        try:
+            os.close(self.cmdin.rd)
+        except OSError:
+            pass
+        try:
+            os.close(self.cmdout.wr)
+        except OSError:
+            pass
+        try:
+            os.close(self.cmdout.rd)
+        except OSError:
+            pass
+
+        self.send_sock.close()
+
+    def _flush_buffers(self):
+        fds = [self.cmdin, self.cmdout]
+        for name in self.ionames:
+            fds.append(self.ioin[name])
+            fds.append(self.ioout[name])
+
+        while True:
+            r = select_objects(fds, 0)
+            if not r:
+                break
+            for fd in r:
+                fd.recv()

scapy/contrib/opcua/binary/bindings.py

@@ -0,0 +1,14 @@
+# coding=utf-8
+"""
+This module contains bindings to bind the OPC UA layers to the TCP layer (note: OPC UA TCP is a layer on top of TCP)
+"""
+from scapy.contrib.opcua.binary.tcp import UaTcp
+from scapy.layers.inet import TCP
+from scapy.packet import bind_layers
+
+
+# Bind standard ports
+# TODO: Make better layer bindings that do not depend on port numbers.
+# TODO: investigate if possible to determine from MessageType
+bind_layers(TCP, UaTcp, dport=4840)  # We only need to bind UaTcp, since the dispatch_hook is used to determine
+bind_layers(TCP, UaTcp, sport=4840)  # whether we are dealing with UaTcp or UaSecureConversation