Communication of entities (IPC)
KasperskyOS has only one way for entities to interact – through synchronous exchange of IPC messages: via a request and a response. In each interaction, there are two separate roles: client (the entity that initiates the interaction) and server (the entity that handles the request). Additionally, an entity that acts as a client in one interaction can act as a server in another.
The client and server use three system calls: Call(), Recv() and Reply():
- The client sends a request to the server. To do this, one of the client's threads calls
Call()and blocks until a response is received from the server or kernel (in the event of an error, for example). - A server thread calls
Recv()and waits for messages. When a request is received, this thread unblocks, handles the request, and sends a response by callingReply(). - When a response is received (or an error occurs), the client thread unblocks and continues execution.
Thus, in terms of the MILS model, the KasperskyOS kernel is a separation kernel, because all entity interactions happen through it.
Exchanging messages as method calls
An entity's IPC request to a server is a call to one of the interfaces implemented by the server. The IPC request contains input arguments for the called method, the ID of the interface implementation (RIID), and the ID of the called method (MID). Upon receiving a request, the server entity uses these identifiers to find the method's implementation. The server calls the method's implementation, passing in the input arguments from the IPC request. After handling the request, the server entity sends the client a response that contains the method's output arguments.
The Kaspersky Security Module can analyze all components of an IPC message in order to decide whether the message complies with the system's security policy.
IPC channels
To enable two entities to exchange messages, an IPC channel, also referred to as a "channel" or "connection", must be established between them. The channel specifies the entities' roles, i.e. "client" and "server". Additionally, an entity can have several channels in which it is the client, and several channels in which it is the server.
KasperskyOS has two mechanisms for creating IPC channels:
- The static mechanism involves creating a channel when the entity is started (when the solution is started). Channels are created statically by the initializing Einit entity.
- The dynamic mechanism allows started entities to establish a channel between one another.