# An Evaluation of the Security of Bare Machine Computing (BMC) Systems against Cybersecurity Attacks
## 2 Conventional Systems
### Conventional System Characteristics  
The following characteristics were obtained from our literature review of the security papers listed in this article. We have identified 20 conventional system characteristics as described below. This list is by no means exhaustive; however, it serves as a basis for comparison with BMC system characteristics. 1. OS/Kernel/Embedded: Most systems have an OS or kernel. They can also be embedded systems. Due to the complexity and size of modern OSs, lean operating systems were designed to improve security and reduce complexity. Some middleware (e.g., the OS) makes software systems easy to build and isolates programmers from hardware intricacies. Applications: Computer and information system applications are platform-centric and computing device-dependent. No proper abstractions have been used to build applications. Thus, applications are redundant on different platforms. A web browser on a smartphone is different from that on a PC. Email systems are also different on various platforms. Due to this redundancy and lack of proper abstractions, an end-user application may be duplicated many times, resulting in a large application space. * Programming Languages: Multiple programming languages are used in conventional systems. Different languages are often chosen based on the type of application, programmer's skills, convenience, and performance. Performance may not make much difference as current processor speeds are increasing in a short period. * Executables: Different operating systems support different executable formats. Some applications may have many executables, thus creating multiple address spaces. Inter-module communication may require message passing between modules. * Linking: Dynamic linking is used for many reasons. It reduces the executable sizes, as some modules can be linked at runtime. It is also convenient, as the compiler does not know where the system libraries and other modules are loaded in memory at compile-time. In addition, in multi-module design, the interfaces to other modules are not known at compile time. * Loading: Dynamic loading and linking are related. Dynamic loading at run time is also very convenient, as noted above for linking. In modern OSs, dynamic loading and linking (DLL) is commonly used to make the executables smaller and to enable use of external modules as needed at run time. * Multi-tasking: Multi-tasking or multi-programming is necessary for all computing systems, as the CPU cannot be kept busy all the time. Most programs need I/O; they cannot run when an I/O request is pending. In conventional systems, when one program is idle, other programs and the OS can run. A given program may not be running alone until its completion. * System Calls/API: OSs provide system calls to communicate with the hardware. OSs also provide APIs, enabling programmers to access hardware interfaces. System calls use interrupts to invoke OS services. * Sockets: Operating systems provide socket interfaces to communicate between processes within a node or with a remote node. * Open Ports: When a packet arrives at an OS, it uses the destination port number in the packet to deliver the packet to its application. A given application running in the machine uses a designated port number to communicate with other nodes. There may be some ports open in an OS to accommodate unexpected applications running in the machine. * During Execution: In an OS environment, a given application, other applications, and OS processes and threads run concurrently. Some of them may interact with others intentionally or unintentionally. * Event/Interrupt Driven: Most conventional systems use event-based and interrupt-based processing. * Shared Memory/Message Passing: Both are used for local communication, and message passing is used for remote communication. * Concurrency Control: Inter-process communication in an OS environment may require concurrency control mechanisms. Locking and semaphores are used to handle concurrency. * I/O: Most I/O is interrupt-driven in an OS.