Cross-domain solution (CDS) collaborate-access-browse (CAB) and assured file transfer (AFT)

[0001] This application claims priority from U.S. Provisional Patent Application Ser. No. 60/771,901, filed Feb. 10, 2006, and from U.S. Provisional Patent Application Ser. No. 60/897,246, filed Jan. 25, 2007, both of the disclosures of which is hereby incorporated by reference in their entirety.

[0002] 1. Field of the Invention

[0003] The invention relates generally to a secure, cross-domain information exchange capability. The Collaborate-Access-Browse (CAB) Cross-Domain Solution (CDS) component enables high-side users to browse low-side material with the same privileges as any other low-side user. The Assured File Transfer (AFT) CDS allows the high-side user to initiate file transfers from the low side to the high side so the browser-found data can be manipulated on the high side if needed. AFT provides for a bi-directional file exchange. High-side users can also initiate a file exchange from their high side to the low side, assuming the file contains only the appropriately classified information.

[0004] 2. Description of Related Art

[0005] In the late 1990s, the Joint Chiefs of Staff (JCS) procured a Cross-Domain Solution (CDS) to permit users on the Joint Staff Integrated Network-Top Secret (JSIN-T) to communicate with users on the Joint Staff Integrated Network-Secret (JSIN-S). This component-based solution, termed CyberShield, provided JCS with operational functionality to permit connectivity. In early 2005, the CyberShield device became inoperative. Other component-based solutions that have been identified as possible replacements have failed to provide the needed security functionality for the overall system. The JCS challenged the National Security Agency (NSA) with providing a solution to furnish the applicable security while not impinging on current business practices (e.g., unrestricted browsing using HTTP and sharing files between domains).

[0006] Systems and methods for providing a cross-domain, remote terminal secure browse capability are disclosed. In one embodiment, the Collaborate-Access-Browse (CAB) Cross-Domain Solution (CDS) component enables high-side users to browse low-side material with the same privileges as any other low-side user. In one embodiment, a second component, the Assured File Transfer (AFT) CDS allows the high-side user to initiate file transfers from the low side to the high side so the browser-found data can be manipulated on the high side if needed. AFT provides for a bi-directional file exchange. High-side users can also initiate a file exchange from their high side to the low side, assuming the file contains only the appropriately classified information.

[0007] One embodiment includes a cross-domain information exchange system comprising a client, a translator, a guard associated with the client and the translator, and a terminal server associated with the translator. The guard is configured to communicate with the client and the translator over a first protocol and the translator is configured to communicate with the terminal server over a second protocol. The first protocol is a Virtual Desktop Protocol (VDP) that is configured to provide remote, securable virtualization of a graphical user desktop to the client and the second protocol may be a commercially available standard desktop protocol.

[0008] Another embodiment is a cross-domain file exchange system comprising a first client, a second client and a guard associated with the first client and second client. The guard is configured to provide secure bi-directional file transfer between the first client and second client.

[0009] As will be realized, this invention is capable of other and different embodiments, and its details are capable of modification in various obvious respects, all without departing from this invention. Accordingly, the drawings and descriptions are to be regarded as illustrative in nature and not as restrictive.

[0047] This section provides a high-level description of the CAB Browse system, identifying what functionality is provided to users. It provides an overview of the major components of the CAB Browse system: the high-side Client, the Guard, the Translator, the Terminal Server and the Virtual Desktop Protocol (VDP). Descriptions of the individual components that make up the CAB system are covered in their respective sections below.

[0048] In this embodiment, FIG. 1 shows an example of a high-level functional view of the CAB system. CAB is a cross-domain solution that reflects the need for communications among different security level domains. For example, as the number of joint coalition efforts in which the US participates continues in increase, the number of different classification levels and networks to which users need access continue to grow. CAB, as the leading CDS solution, offers technology that is directed at addressing the needs of U.S. warfighters and the Intelligence community.

[0049] In this embodiment, a CDS solution preferably requires that content, services and applications of a lower clearance domain be available to users on a domain of a higher security clearance (high-side users). This need is in conflict with present system designs, whose security features were designed to make sharing of information across domains virtually impossible. While unidirectional communication from lower to higher domain networks is possible, a CDS solution should address the bi-directional communications needs of today's environment. Careful control of cross-domain communications should ensure that only appropriate content is exchanged.

[0050] In this embodiment, accomplishing this requires a set of mechanisms to ensure that high-side users are protected from low-side threats and malicious intent. Not only must the system protect the high-side users, but it should also make certain that of higher-level domain's information does not unintentionally reach the low-side domain

[0051] Referring to FIG. 2, at the highest level of one embodiment, CAB may consist of five primary system components:

• • [0052] CAB Client Application
  • [0053] CAB Browse Guard
  • [0054] CAB Translator
  • [0055] Terminal Server
  • [0056] Virtual Desktop Protocol (VDP)
    These primary components work together to present a high-side user with a virtualized low-side presence.

[0057] In this embodiment, the CAB Client may be designed to run as an application or applet on an existing high-side workstation. Using this Client, and no additional hardware or network infrastructure, each user can obtain access to a low-side CAB Terminal Server session. Once a high-side user has authenticated through the Guard and established a session, they can access all low-side applications, resources and services that have been configured for use on the Terminal Server. It is the role of the CAB Client to present the virtual low-side session in a manner that closely resembles a native low-side session, and supports intuitive and responsive interaction with that session.

[0058] In this embodiment, in order to virtualize the low-side session, the Client is responsible for:

• • [0059] Rendering the low-side screen shots that are received from the Translator/Terminal Server (via the Guard)
  • [0060] Capturing mouse events from the high-side mouse and conveying them to the Translator/Terminal Server (via the Guard)
  • [0061] Capturing keyboard input from the high-side keyboard and conveying it to the Translator/Terminal Server (via the Guard).

[0062] In this embodiment, at the same time, the CAB Client preferably implements methods to isolate the high-side desktop environment from the Client process, i.e., sandboxing technology. For example, the CAB Client preferably does not have write access to the high-side workstation hard drive, and preferably does not receive inadvertent mouse and keyboard events intended for other high-side applications.

[0063] In one embodiment, the CAB Browse Guard is preferably a cross-domain high-assurance device designed to enforce secure communications between a high-side CAB Client and a low-side Translator/Terminal Server. The Guard may be designed to communicate only over the VDP protocol, and may not accept communications over any other. The Guard can receive new VDP connections preferably only from the high-side network, preventing any unsolicited communications from the low side.

[0064] In this embodiment, the primary steps taken by the Guard to ensure secure communications can preferably include:

• • [0065] Support authentication and control of all connections and user accounts
  • [0066] Perform format validation of all VDP messages, to ensure that only VDP-compliant communications are passed
  • [0067] Perform further validation of VDP content—to ensure, for example, that image data is free of extensible fields, and mouse coordinates are within the expected range
  • [0068] Perform stateful validation of all VDP messages, to pass only those VDP messages, which are appropriate at that stage of a VDP session. (Ensure, for example, that authentication occurs before mouse clicks are sent.)
  • [0069] Perform a dirty word/clean word search of all text-based content that passes from high-to-low
  • [0070] Perform anomaly detection and pattern detection to identify possible security issues
  • [0071] Log all security-related events and anomalies
  • [0072] Support auditing of sessions, to include the ability to record and play back sessions.

[0073] In this embodiment, the CAB Translator is responsible for proxying and converting between the commercial desktop protocol and the VDP protocol. Because of the differences between the two protocols, proper translation preferably consists of more than simple semantic and format substitutions. The Translator can incorporate the required logic to behave as a commercial desktop protocol Client when speaking to other commercial desktop protocol components (i.e., the Terminal Server) and may behave as a VDP server when speaking to other VDP components (i.e., the CAB Browse Guard).

[0074] In this embodiment, the CAB Terminal Server component preferably provides a low-side multi-user platform on which all of the low-side presences will physically reside. It may consist of a commercial off-the-shelf (COTS) platform that supports remote thin-client connections.

[0075] The Terminal Server platform is preferably connected to the low-side network. This means that the Terminal Server can be configured—without any CAB-specific training- to support any applications, resources and protocols natively available on that network.

[0076] In this embodiment, because native commercial terminal server protocols are not suitable for high assurance, cross-domain communications, the Virtual Desktop Protocol (VDP) may be used. VDP—developed to meet the needs of CAB—may be is an application-level protocol for remote, securable virtualization of a graphical user desktop on to a distant computer Client. VDP is a more secure replacement for standard commercial remote desktop protocols. VDP may be designed to be a very lightweight, yet extensible protocol, without most of the risks inherent in the more complex remote desktop protocols. Because the VDP protocol preferably provides no channels for risky activities such as file sharing and portable code execution, it can be easily secured through simple protocol enforcement and anomaly detection. The simplicity of the VDP protocol may also support real-time content inspection for such purposes as dirty word searches.

[0077] In this embodiment, the VDP may be comprised primarily of a small set of pre-defined data channels each handling specific tightly formatted message types. Messages may generally be transmitted using fixed-format messages, with some support for Type, Length, Value (TLV) encoding to ensure a common exchange format that is well formed, flexible and extensible. The concept of virtual channels may also be integrated into VDP to ensure that custom channels can be later defined and plugged into the protocol as it matures and grows based on foreseen and unforeseen new requirements and features.

[0078] Next, each of the components will be described in more detail.

[0079] CAB Client

[0080] In this embodiment, the CAB Client may be an application that is resident on a high-side user's workstation that provides access to a session on a low-side CAB Terminal Server. In a preferred embodiment, the main functionality of the CAB Client is to provide the high-side user with ability to interact with all of the low-side Terminal Server applications as seamlessly as possible. The Client preferably supports all native functionality provided by those low-side applications.

[0081] In this embodiment, the Client may accomplish this by only displaying graphical duplications of low-side applications. The Client itself does not run any direct applications on the Terminal Server (all interaction is transmitted to the Guard using VDP). Instead, the screen graphics of the low-side session may be transmitted to the high-side monitor and are interpreted and displayed by the Client.

[0082] In this embodiment, another function that the Client may provide is a final layer of defense in protecting the high-side computer. While, the Guard and Translator provide the majority of the security functionality of CAB, the Client may be a final stopgap for high-side users from low-side threats.

[0083] In this embodiment, in providing all of these functions, the Client preferably has a minimal amount of impact on the high-side platform in the areas of performance, configuration and maintenance.

[0084] An example of a high-level architecture of one embodiment of the CAB Client is shown in FIG. 3. FIG. 4 shows a more detailed example of the CAB Client architecture in this embodiment.

[0085] In this embodiment, fundamental features desired for the CAB Client were support for user-friendly interfaces, strong security and low development, and deployment overhead. CAB preferably uses Java as the Client's development platform. Java offers a rich set of development features that are beneficial in using it for Client development.

[0086] First, there is Java's platform independence. Java runs on all relevant operating systems, including Windows, MacOS, UNIX and Linux. While one embodiment of the Client may be targeted at the Windows platform, using Java means that other embodiments can support other platforms with minimal porting. The pervasive nature of Java adoption also supports the goal of minimizing deployment issues. Most workstations already have some version of a Java Virtual Machine (JVM) loaded, thus maximizing technical acceptance and minimizing technical difficulties.

[0087] Second, Java offers many advanced Graphical User Interface (GUI) components and graphical capabilities. For example, the Swing toolkit, a GUI component kit used in the development of windowing components, is a core Java API. Swing is one of the most comprehensive GUI frameworks available and it comes packaged with the Java Development Kit (JDK). Swing provides a complete set of GUI components ranging from buttons and text fields to tables, trees and styled text editors. Swing also maintains a clean separation between the GUI components and model objects that are viewed on screen. The Swing components do not rely on the native graphical elements (called widgets) of the operating system; instead, Swing components are painted using graphic primitives such as lines, rectangles and text. The painting is delegated to a look and feel plug-in that can imitate the operating system's native look and feel. Java GUIs can look the same on all operating systems or they can emulate the native look.

[0088] Security was also a component in the selection of Java. Java was designed with security in mind, with security checking built into the libraries and virtual machine. While trust is placed in the high-side user, the Java sandbox restricts code from performing many activities that allow access to sensitive areas of the computer. Java security relies on three prongs of defense to perform load- and run-time checks to restrict file-system and network access as well as access to browser internals. A more complete discussion on security will be presented in later sections.

[0089] In addition to the above, Java has many inherent functions that lends it to being used as the Client's foundation language. Such functions include automatic memory management and strong typecasting.

[0090] In this embodiment, one decision that has ramifications on the development of the Client is the choice of the Java Development Kit (JDK). JDK is the software package that enables a programmer to make use of the Java language. All known versions of JDK contain compilers, interpreters, and a host of class libraries called packages. Packages are essentially directories of subprograms (called classes) that are grouped according to their functionality.

[0091] For one embodiment of CAB development, JDK 1.5.0 (also known as JDK 5.0) was chosen. JDK 1.5 is a feature release of the Java platform and was released in November 2004. It contains many bug fixes and additional features and enhancements in many functional areas.

[0092] The decision to select Java makes support for various operating systems and hardware platforms much easier than any other programming technology. However, as with any other application, there are differences in the way programs behave among varieties of even the same operating system. Thus, in various, non-limiting embodiments, the Client may be supported and tested against the following high-side user operating systems: Windows XP (SP1) or higher, Windows 2000, MacOS, UNIX and Linux.

[0093] In this embodiment, the CAB client software may be partitioned into two libraries. The common library contains software of a general purpose that may be used in multiple applications, such as in both the client GUI and the administration GUI(s). The client library contains software specific to the CAB Client, such as code supporting the specification of client preferences.

[0094] In this embodiment, within each library, the software is further divided into packages of related components. For example, all of the custom software that manages client security may reside in the security package.

[0095] Examples of the main packages in both libraries are shown in FIG. 5, and are described in subsequent sections. The arrows in FIG. 5 show the use of one package by another. For example, the “ui package” uses software from both the Client and the common libraries' components packages.

[0096] In this embodiment, within each main package may be sub-packages, which may be grouped according to functionality. Some reallocation of the various packages and the classes within them may occur during implementation.

[0097] In this embodiment, the Client package may contain sub-packages and classes whose functionalities are specific to the client application. An exemplary embodiment is shown in FIG. 6.

[0098] In this embodiment, descriptions of each of the sub-packages contained in the main Client package are shown below:

[0099]

Client Package And Subpackages
Package	Description
ui	This package contains the main class of the Collaboration and
	Browse client, which can be run from the command line via the Java
	command and provides controlled access from a high-side user to a
	low-side system.
ui.actions	Provides actions for the CAB client. Actions are implementations of
	javax.swing.Action (created by extending javax.swing.AbstractAction)
	that encapsulate the attributes of actionable display elements
	(such as UI buttons) and the processing performed as a result of
	clicking those elements. Actions in this package implement the
	following pattern: If an action in this package requires data from
	the initiating component, the action should define an Initiator interface
	that the initiating component can use to provide that data.
ui.components	Provides custom UI components for the CAB client. These
	components group related elements, such as configuration settings,
	which can then be assembled into pages, which are in turn defined in
	package client.ui.pages.
ui.pages	Provides custom display pages for the CAB client. These pages are
	largely assembled from components in package client.ui.components.
Security	Provides classes for supporting CAB security by plugging in to the
	Java Authentication and Authorization Service (JAAS). JAAS
	provides a framework for implementing custom login mechanisms,
	security policies, et al.
memory	Provides memory management for the CAB application. Display
	elements such as fonts are cached on the Client the first time they are
	received from the server and for efficiency, subsequent requests from
	the server reference the cached elements.
env	Provides classes for accessing attributes of the CAB client
	application's environment, such as to which guard the application is
	making requests and what are the preferences in effect for that guard.

[0100] In this embodiment, descriptions of the classes and interfaces contained in main Client package are given in the table below:

[0101]

Classes of the Client Package
Class/Interface	Description
CABClient	The CAB client application class.
ChangePasswordAction.Initiator	Interface for a class which initiates the
	ChangePasswordAction action, such as a UI component
	containing a button to which this action is an
	ActionListener.
GetHelpAction.Initiator	Interface for a class which initiates the GetHelpAction
	action, such as a UI component containing a button to
	which this action is an ActionListener.
SendCABTextAction.Initiator	Interface for a class which initiates the
	SendCABTextAction action, such as a UI component
	containing a button to which this action is an
	ActionListener.
ChangePasswordAction	Implementation of javax.swing.Action that responds to user
	requests to change their password.
GetAboutAction	Implementation of javax.swing.Action that responds to user
	request for information about the CAB client.
GetHelpAction	Implementation of javax.swing.Action that responds to user
	requests for help.
SendCABTextAction	Implementation of javax.swing.Action that sends a text
	string (as opposed to individual keystrokes) to the Guard.
CABMenuBar	The menu bar for the main CAB Client window.
ColorDepthSelector	UI component for choosing the color depth for the CAB
	Client.
DimensionRenderer	Renders a java.awt.Dimension to the screen.
RemoteDesktopTextInput	Provides a field for entering text and a button for
	requesting that the text be sent to the VDP server.
ScreenDimensionsSelector	Display component for selecting the screen dimensions.
StatusIndicator	Indicator of the status of the connection to the Guard.
CabTextKeyAdapter	Manages key input on the remote desktop frame when
	CAB-style text input is enabled.
ClientKeyAdapter	Responds to key events when the remote desktop has focus.
ClientMouseAdapter	Class for handling mouse events when the
	RemoteDesktopPage has focus.
ClientWindowAdapter	Repaints the remote desktop if the client window is
	reactivated, and cleans up when the window is closed.
OptionsDialog	Display component for selecting display options.
RemoteDesktopPage	The window that displays the remote desktop.
CABPolicy	Implements the security policy for the CAB Client.
CACCallbackHandler	Implementation of a
	javax.security.auth.callback.CallbackHandler to interact
	with a CAC card to get user credentials for login.
GuardLoginModule	Implementation of javax.security.auth.spi.LoginModule,
	which delegates authentication of a user to a CAB Guard.
LoginConfiguration	Concrete implementation of
	javax.security.auth.login.Configuration that improves
	security by defining the login configuration in code instead
	of in a JAAS configuration file.
BitmapCache	A cache of bitmaps received from the Guard.
CABRuntime	Provides access to dynamic attributes of the CAB
	environment.
GuardPreferences	Extension of java.util.pref.Preferences that provides access
	to user preferences retrieved from the Guard.
GuardPreferencesFactory	Implementation of java.util.prefs.PreferencesFactory that
	supports the use of the guard as the store for user
	preferences.

[0102] Shown in FIG. 7, for example, the Common package may contain sub-packages and classes whose functionality are not specific to the client application, and so may eventually be used by other applications.

[0103] In this embodiment, descriptions of each sub-package contained in the main Client package are shown below:

[0104]

Client Common Package and Subpackages
Package	Description
guard	Contains classes that provide an abstract representation of interfaces
	with the Guard. The Guard class represents the Guard itself,
	whereas the GuardLogHandler and LoggerFactory classes plug into
	the java.util.logging framework to provide a mechanism to send log
	messages to the Guard.
net.vdp	Provides classes for a Java protocol handler supporting VDP.
net.vdp.messages	Classes representing the messages exchanged between the CAB
	Client and VDP server. All request messages contain constructors
	and/or mutators that allow the message elements, such as username
	and password in a login request, to be set. All request messages also
	implement the IRequestMessage interface to provide a toBytes
	method that expresses the message as a byte array in the format
	used by the VDP protocol for that request type. All response
	messages contain a constructor that takes a byte array in the format
	sent by the VDP server, and provide accessors for accessing the
	message elements.
ui	Provides user interface classes of general value (i.e., that are not
	specific to a particular application, such as the CAB Client, but may
	be used by multiple UI applications).
ui.components	Classes that provide abstractions on top of the Java AWT/Swing
	classes.
ui.swing	Provides classes that wrap Swing components to standardize display
	attributes such as text fonts.
ui.util	Provides utility classes for constructing user interfaces.
util	Provides general utility classes.
resource	Provides classes for accessing resources, including support for
	localized/internationalized resources such as text strings in
	java.util.ResourceBundles. In order to accommodate the possibility
	that the storage location (such as flat file, database, or remote
	server) for resources may change (if not now, possibly in the
	future), we use a factory ResourceAccessorFactory to create a
	concrete class (implementing the ResourceAccessor interface) for
	the storage mechanism in use. For example, resource definitions for
	the CAB Client initially exist as properties files, so the
	ResourceAccessorFactory will instantiate a PropertiesAccessor
	object, which implements ResourceAccessor, for accessing those
	resource definitions. However, if the future resource definitions
	were to reside on the Guard, a GuardResourceAccessor class, which
	would also implement ResourceAccessor, could be created for
	accessing those resources, and ResourceAccessorFactory would be
	configured to create and provide a GuardResourceAccessor object.
exceptions	Defines custom exceptions for the Collaboration and Browse
	software.
memory	Provides memory management for the CAB application

[0105] In this embodiment, descriptions of the classes and interfaces contained in the Common package are given in the table below:

[0106]

Classes of the Client Common Package
Classes/Interface	Description
Guard	A Collaboration and Browse guard.
GuardLogHandler	Sends log entries to the Guard.
LoggerFactory	Singleton factory that provides java.util.Logger instances to
	support logging and auditing for the Collaboration and
	Browse software.
ConnectionStatistics	Statistics about a VDP connection.
Handler	Extension of java.net.URLStreamHandler that provides
	connections to Virtual Desktop Protocol servers.
HandlerFactory	Implementation of java.net.URLStreamHandlerFactory that
	allows access to a VDP protocol handler without requiring
	that the java.protocol.handler.pkgs system property be
	modified.
VDPConfiguration	The configuration supported by the VDP server.
VDPConnection	Extension of java.net.URLConnection for a connection to the
	VDP server.
VDPPreferences	VDP settings for the user
IRequestMessage	Interface for any message to be sent to a VDP server.
LoginRequest	A request to log in to a guard.
LoginResponse	The response to a VDP login.
LogMessage	A log message to send to the guard.
SetOptionsRequest	Sends a request to set user-selectable VDP options.
VDPPreferences	The VDP settings for the user.
KeyLayout	Key layouts for various languages.
CompactSpringGrid	A JPanel that is laid out as a spring grid of 2 columns by n
	rows, with column one being a label for a component and
	column 2 being the component.
ListSelector	UI component for displaying a list of selections in a
	scrollable JList.
NamedRenderer	Displays to a cell an object that implements Named.
ProgressScreen	UI containing a busy indicator (with message) and a Cancel
	button to display, and an action to perform during the display
	(and the completion of which results in the end of the
	display).
StandardDialog	This class implements a standard data entry dialog with “Ok”
	and “Cancel” buttons.
CABButton	JButton wrapper that standardizes various attributes such as
	label font.
CABComboBox	JComboBox wrapper that standardizes display attributes such
	as text font.
CABLabel	JLabel wrapper that standardizes display attributes such as
	text font.
CABList	Wrapper for a javax.swing.JList which standardizes display
	attributes such as text font.
CABOptionPane	JOptionPane wrapper that standardizes display attributes
	such as text font.
CABPasswordField	Wrapper for JPasswordField to standardize attributes such as
	fonts.
CABProgressBar	Wrapper for JProgressBar to standardize attributes for
	display.
CABTextField	JTextField wrapper that standardizes display attributes such
	as text font.
BorderUtilities	Utility methods for working with Swing borders.
FrameUtilities	Utility methods for working with frames.
GeneralUtilities	Miscellaneous UI utility methods;
ImageUtilities	Utility methods for working with images.
SpringUtilities	A 1.4 file that provides utility methods for creating form- or
	grid-style layouts with SpringLayout.
ValidationUtilities	Utility methods for validating user input.
Named	Interface for any UI component that has a name that can be
	rendered to a display.
Debug	Utility methods supporting debugging.
Debug.StackFrameText	Provides access to the components of the string describing
	the stack frame.
FileUtilities	Utility methods for manipulating files.
ResourceAccessor	Interface for classes that provide access to resources such as
	property files.
AbstractResourceAccessor	Abstract class providing access to resources such as property
	files.
PropertiesAccessor	Configuration settings defined in properties files.
ResourceAccessorFactory	Provider of an AbstractResourceAccessor appropriate to the
	storage mechanism in use for resources.
InvalidValueException	Exception indicating that an invalid value was used.
NotFoundException	Exception indicating that something was not found.

[0107] The following sections describe relationships among the classes. Complete descriptions of all class interrelationships are not presented, but would be readily apparent to one of skill in the art.

[0108] FIGS. 8 and 9 show examples of the primary classes involved in displaying the client UI application in one embodiment.

[0109] In this embodiment, the CABClient class may contain the main method that is used to run the application. It orchestrates the display of the initial screens that allow the user to select the Guard to connect to and the display options to use (a screen to enter username and password is displayed as a result of using the JAAS framework as discussed in a subsequent section. Once the user is authenticated, the RemoteDesktopPage is instantiated and assumes responsibility for all interaction with the user.

[0110] In one embodiment, the RemoteDesktopPage (FIG. 9) presents a screen containing the following elements:

• • [0111] A menu bar that allows the selection of functions such as changing the password or displaying help.
  • [0112] A classification banner showing the classification of the low-side system to which the application is connected.
  • [0113] The bulk of the remote desktop page is comprised of the desktop on the low-side system. The classes involved in managing the desktop include various adapters that intercept user actions such as mouse clicks and send them to the low-side system.
  • [0114] A bar at the bottom of the page contains the text box and send button for CAB-style input (if enabled), and a status indicator that shows a summary status of the connection and which, if clicked, pops up a more detailed status display.

[0115] Security Architecture

[0116] Java's security model is one of the language's architectural features that make it an appropriate technology for the CAB Client, as disclosed in one embodiment. Java provides a customizable “sandbox” in which each Java program runs. A Java program must operate only inside its sandbox. An application can do many things within the boundaries of its sandbox, but it cannot take any action outside those boundaries. The sandbox can prohibit many activities. Examples of prohibited actions include:

• • [0117] Reading or writing to the local disk
  • [0118] Making a network connection to any host, except those allowed
  • [0119] Creating new processes
  • [0120] Loading a new dynamic library
  • [0121] Directly calling a native method.

[0122] To make sure the sandbox has no leaks, Java's security model involves every aspect of its architecture. The fundamental components responsible for Java's security are:

• • [0123] Java Virtual Machine—By enforcing structured access to memory, the Java Virtual Machine yields programs that prohibit the use of unstructured memory access (a requirement for malicious intent such as buffer overflows). Thus, a hacker cannot predict where in memory data is being stored by looking at the class file. Other functions of the JVM, type safe reference casting, automatic garbage collection and arrays bounds checking, all contribute to stronger security.
  • [0124] Class Verifier—Enables code to be verified up front, rather than on the fly as the code is executed, which prevents uncontrollable crashes.
  • [0125] Class Loader—Responsible for importing binary data that defines the running program's classes and interfaces, the Class Loader architecture has the capability to prevent the loading of untrusted classes that declare themselves to be part of a trusted library.
  • [0126] Security Manager—Enables a custom security policy for Java applications.
  • [0127] Of the four major security tenants list above, only the last two, Class Loader and the Security Manager, are customizable to address specific security concerns.
  • [0128] Based on the initial threat model with which we are working, customization of the security policy are sufficient.

[0129] Security Policy

[0130] In this embodiment, a security policy defines restrictions such as what system resources an application can access. The Java API may enforce the custom security policy by asking the security manager for permission to take any action before it does something that potentially is unsafe. For each potentially unsafe action, there is a method in the security manager that defines whether that action is allowed by the sandbox. The implementation of these methods is what defines the custom security policy of the application.

[0131] In this embodiment, the main objective of the CAB Client security policy may be to prevent the following events:

• • [0132] Reading from unspecified host-based files
  • [0133] Writing to any host-based file
  • [0134] Deleting any unauthorized host-based files
  • [0135] Accessing or modifying system properties
  • [0136] Thread modifications (change priority, stopping)
  • [0137] Opening connections to only a specified set of Guard addresses and port numbers
  • [0138] Creation of a new class loader
  • [0139] Creating new processes
  • [0140] Causing the application to exit
  • [0141] Loading any dynamic libraries
  • [0142] Waiting for a connection on a specified local port number (client should never accept CAB requests).

[0143] In this embodiment, the java.security.Policy class may support a security policy that can be specified via a configuration file. Placing this policy in a file raises the possibility that if the file system is compromised then the policy can be compromised. For one embodiment of CAB, this may be avoided by implementing a security policy in a custom extension of java.security.Policy. This may also provide extensibility in that a custom security policy class may also loaded the policy from a trusted source, such as from the Guard.

[0144] Authentication

[0145] In this embodiment, in addition to utilizing the features inherent of the Java security architecture, CAB may also leverage other built-in mechanisms that Java provides for authenticating users.

[0146] JAAS is a pluggable framework that allows, among other things, the specification of a customized authentication mechanism. JAAS authentication may be performed in a pluggable fashion. This permits Java applications to remain independent from underlying authentication technologies. New or updated authentication mechanisms can be plugged in without requiring modifications to the Client application itself. JAAS authorization extends the existing Java security architecture that uses a security policy to specify what access rights are granted to executing code.

[0147] In this embodiment, since authentication of the CAB high-side user occurs at the Guard, we can effectively leverage JAAS in the Client implementation.

[0148] JAAS may also allow for flexible support of potential high-side user's Common Access Cards (CAC).

[0149] In this embodiment, there are three elements in the use of JAAS:

• • [0150] GuardLoginModule implements javax.security.auth.spi.LoginModule, which provides a standard API for authenticating a user. For CAB this module can delegate the authentication to the Guard.
  • [0151] LoginConfiguration extends java.security.auth.login.Configuration, which lets us specify which LoginModule implementations we support (in our case, GuardLoginModule).
  • [0152] CACCallbackHandler implements j avax.security.auth.callback.CallbackHandler, which defines a standard API for accessing user credentials. For non-certificate-based login (i.e., interactive entry of a username and password by a user and verified directly by the Guard), no custom CallbackHandler implementation is needed because a UI callback handler is provided by Sun.

[0153] FIG. 10 shows examples of the elements that the CAB Client uses.

[0154] GUI Design

[0155] In this embodiment, a goal of the GUI design is to make the CAB Client application as familiar to the user as possible, employing the techniques of other windows-based applications. This familiarity aids the user in successful use of the application and decreases learning time.

[0156] An exemplary embodiment for the CAB Client screen design, after a user has successfully logged in, is shown in FIG. 11. The larger inner frame of the Client is the remote desktop running on the low-side Terminal Server. The intention is to minimize any other frames around this inner frame to maximize the screen size of the remote desktop. The parameters of the Remote Desktop frame (such as screen resolution, color depth) may be user-selectable during the login process.

[0157] In one embodiment, the Client's lower frame is where an optional text entry box would be displayed if this option is enabled by the Guard during Client startup. The intent of the text box is act as a typing area for all user interactions. Anything typed, or cut and pasted, appears in the text box and allows the user to visually review the content before it is sent to the Guard for inspection. This is a measure to prevent inadvertent disclosure. The user sends the text by using the send button next to the text box.

[0158] Also on the lower frame may be a connection health monitor/indicator. In one embodiment, while there is an active connection to the Guard, the indicator light is green. If connectivity to the guard is disconnected, the indicator is red. For more detailed information, a user can click on the indicator to pop open another window that contains more statistics.

[0159] The upper frame of the Client may show the classification banner of that Client session. The text and the banner color are configurable items received from the Guard during the start-up process.

[0160] In this embodiment, located on top of the classification banner may be the main Client menus. The main menu can house most functions that can be performed by the user. The first Client menu is the Session menu, shown, for example, in FIG. 12.

[0161] In one embodiment, the three options for this menu are Disconnect, Reconnect and Logout. If the user selects Disconnect, only the Client is closed, but the session remains open. If Reconnect is selected, a disconnected session can be resumed. This supports the requirement for a user to use the same session at a different workstation. If the user selects Logout, the user is logged out from both the high and low side and the session; the session is completed and torn down.

[0162] In this embodiment, the second Client menu addresses the functionality of changing passwords and is shown, for example, in FIG. 13. The user can change both high side and low-side passwords. When the user wants to change the guard password, the user selects the first menu. This changes the password on the Guard. Because the Guard supports password aging, this same mechanism is used when a user is requested to update a password. In either case, the Guard will determine if the password is accepted or denied and send a notification back to the Client. This menu option is only valid when Guard passwords are used, not when a directory service or PKI is being used on the high side. For those cases, to change their password, the user would change it through the directory service and the menu will either be grayed out or not shown.

[0163] In this embodiment, the second function of the password menu may be used if the user wants to notify the Guard of a change in the Terminal Server password. Since users may update their password directly on the Terminal Server (if policy allows), it is the responsibility of the high-side user to inform the Guard that the Terminal Server password has changed. The function of the “change low-side password” button is to push the new Terminal Server password to the Guard by having the user enter the Terminal Server password again. This enables a single high to low sign-on capability. If the user does not push the update to the Guard, the user will still be able to log into the Terminal Server (through the regular Windows login screen on the Terminal Server). However, it will not be automatic after logging on to the high side.

[0164] In this embodiment, an example of a third menu, Configuration, is shown in FIG. 14. Configuration displays the current configuration settings for display, sound and video. Many of these options are set as Guard configuration items and may not be user-definable.

[0165] In one embodiment, the last menu present is Help, shown in FIG. 15. The CAB Client Help can shows various help topics associated with the CAB Client. The About CAB Client may show the software version of the Client.

[0166] In one embodiment, another feature is the mechanism in which the users apply Windows key combinations to the Terminal Server session. For instance, if a user wishes to display the task manager in the remote session, pressing ALT-CTRL-DEL in the Client application, or anywhere else for that matter, only brings up the Task Manager on the local host.

[0167] Configuration and Deployment

[0168] In one embodiment, each Client application may be installed in the Java Archive (JAR) file format. This enables the bundling of multiple files into a single archive file. The JAR file can contain all of the class files and auxiliary resources associated with the Client application. The JAR file format provides many benefits:

• • [0169] Security: digitally signing the contents can prevent the tampering of the JAR file
  • [0170] Compression: for efficient storage
  • [0171] Package Sealing: Packages stored in JAR files can also be sealed so the package can enforce version consistency. Sealing a package within a JAR file means that all classes defined in that package must be found in the same JAR file
  • [0172] Package Versioning: A JAR file can hold data about the files it contains, such as vendor and version information
  • [0173] Portability: The mechanism for handling JAR files is a standard part of the Java platform's core API.

[0174] Client Distribution

[0175] In this embodiment, for high-side administrators, there may be two scenarios for distributing the Client: manually or automatically. In the manual case, the high-side administrator would have to install the Client on each high-side workstation. This leads to long installation and is prone to the wrong version being used.

[0176] In this embodiment, in the automatic situation the admin, can push out the Client with an application management system such as Microsoft SMS.

[0177] In this embodiment, the Client application can also be written as an applet. Changing the Client to an applet allows the Client to be included in an HTML page (located on the Guard). When a high-side user uses a Java technology-enabled browser to view a page that contains the Client applet, the applet's code is transferred to the high-side user's system and is executed by the browser's JVM. This eliminates the need for distribution and assures that high-side users get the most current copy every time the program is used. In order for the Client applet to work, browser support is needed from the Guard.

[0178] In this embodiment, the installation of the Client on a high-side workstation may be accomplished using an installer. The installer may include the proper version of the JRE.

[0179] Configuration

[0180] In this embodiment, the CAB Client software may access site-specific configuration data needed by the Client, such as text for a login banner and the network addresses of the CAB Guards from files with specified format and with a known filename that resides in a known location for each user.

[0181] In this embodiment, this file may be configurable by an administrator and will be part of the configuration process.

[0182] Guard Component

[0183] In one embodiment, the primary purpose of the CAB Browse Guard is to enforce the security policy of the CAB system, and to securely pass valid VDP data between domains. The Guard is located at the boundary point between the high-side domain and the low-side domain. When a user on the high side wants to browse to resources on a low-side domain, the Guard creates a connection between the high-side user and the CAB Translator on the low side. The result is a connection to the low-side Terminal Server where the user can run applications (e.g., Web browser) on the low side and view the output in the high-side domain. FIG. 16 shows a functional view of the Guard Component.

[0184] In this embodiment, because the Guard preferably only passes well-formed VDP messages, and preferably only after strictly enforcing the format and content of each message, the data reaching the high-side Client should be free of any high-threat content. The only content preferably passing upward through the Guard is a graphical representation of the low-side desktop. Mobile code and malicious content are preferably not sent to the high side.

[0185] In this embodiment, the only data preferably transferred from the high side to the low side of the Guard preferably consists of well-formed keyboard events and mouse events. The Guard performs “dirty word” searches upon all entered text. In addition, the Guard can be configured to allow certain words or phrases based upon a “clean word” list. This content-checking capability greatly reduces the inadvertent leaking of sensitive data into the low-side domain.

[0186] Guard Component Architecture

[0187] In this embodiment, an example of the CAB Guard architecture is illustrated in FIG. 17. The Guard may include many interconnected major subcomponents and subsystems such as:

• • [0188] Operating System and Environment Subcomponents
    • [0189] System Initialization Process (labeled “Init”)
    • [0190] Operating System (not shown)
    • [0191] SELinux Security Policy (not shown)
    • [0192] Heartbeat Monitor
    • [0193] Performance Monitor
    • [0194] Shutdown Monitor
    • [0195] Wire Protocol/IPC mechanisms (represented by the arrows)
  • [0196] Audit and Event Management Subcomponents
    • [0197] Audit Subcomponent
    • [0198] Flight Recorder Subcomponent
  • [0199] Authentication Subsystem
    • [0200] High-Side TLS Authentication (“TLS Auth H”)
    • [0201] High-Side Interface Listener Subcomponent (“Listener”)
    • [0202] High-Side User Authentication Subcomponent (“VDP Auth H”)
    • [0203] High-Side User Preferences Subcomponent (“VDP Prefs”)
    • [0204] High/Low User Mapper Subcomponent (“H-L User Mapper”)
    • [0205] Low-Side User Authentication Subcomponent (“VDP Auth L”)
    • [0206] Low-Side TLS Authentication Subcomponent (“TLS Auth L”)
    • [0207] Low-Side Interface Listener Subcomponent (“Listener”)
    • [0208] Cryptographic Accelerators (“Crypto Accelerator”)
  • [0209] Inspection and Filter Subcomponents
    • [0210] Dirty Word Search Filter (“DWS Filter”)
    • [0211] Keyboard Filter
    • [0212] Mouse Filter
    • [0213] Image Filter
    • [0214] Sound Filter
  • [0215] VDP Communications Subsystem
    • [0216] VDP Router (high-side and low-side)
    • [0217] VDP Forwarder (high-side and low-side)
  • [0218] Administration and Configuration Subcomponent (not shown).

[0219] Each of these subsystems and subcomponents will be addressed below following the same organizational structure used above.

[0220] Operating System and Platform-Related Considerations

[0221] In this embodiment, as in most software systems, the Operating System is responsible for interfacing with system hardware and resources, and controls access to objects and resources running within the system. In high-assurance and security-centric devices and environments, such as the CAB Guard and Translator, the Operating System may become a component in securing the flow of information while maintaining the separation of sensitive data. The CAB system may make use of the SELinux Operating System, with its Mandatory Access Controls, to enforce process and data separation and least privilege concepts.

[0222] In this embodiment, the CAB system's SELinux platform may be based on a custom installation of Red Hat Enterprise Linux 4 Advanced Server (RHEL 4 AS) with SELinux in order to secure each component of the system. The inclusion of SELinux into RHEL 4 AS allows the operating system to have fine-grained control over every component in the system allowing the operating system to grant least privilege to every component in the system. The Operating System used by CAB may contain only a subset of the standard packages, as required specifically for CAB. This minimalist install eliminates excess code and possible exploits in the system.

[0223] Performance-Related Design Considerations

[0224] In this embodiment, Guard subcomponents may be designed to be thread-safe with minimal contention. Because real-world performance bottlenecks are often not understood until code is tested, the design makes heavy use of loose coupling, or reducing the degree to which subcomponents depend on one another. Loose coupling facilitates performance tuning by enabling new, better implementations of components and Interprocess Communications (IPCs) to be introduced. Loose coupling is a common best practice during system and component design.

[0225] Safety, Security, and Privacy Design Considerations

[0226] In this embodiment, the Guard component may be responsible for enforcing the extensive set of cross-domain security requirements applied to the CAB system. All subcomponents of the Guard may be designed with these requirements in mind. It is not possible to present a concise discussion of security considerations; this entire component has been designed specifically to meet a broad set of security requirements. Instead, security considerations are discussed throughout this document. In the simplest form, the highest-level security goals for the Guard are:

• • [0227] Sensitive information should not be inappropriately disclosed.
  • [0228] The integrity of the environments, particularly the high-side environment, should not be compromised.

[0229] In this embodiment, these overall security goals may be met by a combination of the Guard operating system and the Guard applications, each of which has a set of security requirements and a security policy. Some aspects of security are enforced by both the operating system and the applications, while other aspects are enforced only by one.

[0230] In this embodiment, the guard-application security goals, which may be primarily enforced through the correct functioning and configuration of the guard applications, are preferably that:

• • [0231] Only well-formed VDP packets may pass through the guard.
  • [0232] Only authorized users may connect to the Guard.
  • [0233] Information passing through the Guard is filtered to prevent inadvertent disclosure of information.

[0234] In this embodiment, the guard applications' security goals can be enforced by the guard applications; while the operating system security policy indirectly supports the goals by ensuring that data flows through the system only in the permitted manner.

[0235] Subcomponents

[0236] The following sections describe the various subcomponents of the CAB Guard. As will be shown later, many of these same subcomponents are shared with the CAB Translator. FIG. 18 presents an example of an organized view of one embodiment of the CAB Guard subcomponents, identifying which subcomponents are shared with the Translator.

[0237] As stated above, the operating system may play a role in security data flows in any cross-domain solution. Additionally, the cross-domain data flow operations are preferably built upon a foundation of supporting services. This section addresses many of those services and the Guard subcomponents that provide them.

• • [0238] System Initialization
  • [0239] Heartbeat Monitor
  • [0240] Performance Monitor
  • [0241] Shutdown Monitor.

[0242] System Initialization Subcomponent

[0243] In this embodiment, the System Initialization subcomponent (also referred to as the CABInit process) may work with the system monitoring subcomponents (heartbeat monitor, performance monitor, and shutdown monitor) to establish, maintain and monitor the state of the Guard and Translator system components. The System Initialization subcomponent may consist of system integrity checks, file integrity checks and the startup sequence.

[0244] In this embodiment, this subcomponent may be primarily responsible for verifying that the system is in a trusted state at startup. During the boot sequence, the System Initialization subcomponent may perform a series tests, including:

• • [0245] Inspect the integrity of key files on the system using cryptographic checksums
  • [0246] Verify that all required devices—and no others-have been created
  • [0247] Verify that no unknown processes are running on the system
  • [0248] Ensure that there are no rollback logs from the Configuration File Commit utility.

[0249] In this embodiment, once the tests have verified that the Guard or Translator is in a trusted state, the CABInit process may start all Guard-specific processes. In one embodiment, once all processes required by the system are launched, the System Initialization subcomponent is no longer required; the CABInit process exits, leaving the monitoring subcomponents to monitor system health.

[0250] Design Decisions and Considerations

[0251] In one embodiment, the Initialization subcomponent is charged with verifying that the system is in a trusted state before activating the CAB components. If the system detects an anomaly such as a file that fails an integrity check, the system preferably immediately aborts initialization. Initialization halts all processing and then either puts the system into a maintenance mode or completely shuts the system off by powering it down. Because an anomaly of this sort should never happen while the system is booting, there is no attempt to automatically repair or recover the process or file. Such recoveries preferably are done manually by an administrator.

[0252] Performance-Related Design Considerations

[0253] In this embodiment, preferably, the operating system and environment subcomponents are designed to be as efficient as possible. However, security is a greater concern and many of the elements only run during startup and shutdown, making performance less critical. The file integrity check, for example, verifies that critical system files have not been tampered with by computing a cryptographic checksum—a somewhat resource-expensive operation. Because the file integrity check only runs at startup, performance is not a critical concern.

[0254] Security and Privacy Design Considerations

[0255] In this embodiment, establishing and verifying a secure, known system state is a goal of the System Initialization subcomponent. Because the initialization process may include the invocation and coordination of most of the CAB subcomponents, it is very powerful. The principle of minimality dictates that the most powerful components should preferably be the smallest. Therefore, initialization has been decomposed into several pieces to mitigate the risk of complexity. In one embodiment, the decomposition consists of creating multiple small initialization elements and assigning each one the absolute minimum of privileges needed and by limiting communication with other components using the underlying SELinux security policy. For example, the file integrity checks preferably need to read files spanning multiple security domains, and therefore execute in a separate domain from the CABInit process from which they are invoked. In one embodiment, the domain in which the CABInit process executes does not require all of the privileges required by the file integrity checks; instead the integrity checks perform domain transfers upon execution, and complete their execution with the appropriate privileges.

[0256] Subcomponent Details

[0257] In one embodiment, the CABInit process subcomponent is the first CAB subcomponent to start during system boot. Its tasks include verifying integrity by checking the signatures of all CAB-related files in the system, verifying that/dev contains only the device files needed for CAB, and verifying that only necessary processes are running in the system. If any of the verification tasks return a failure error code or detect an anomaly, then CABInit preferably notifies Audit (if available, otherwise, it logs to a file) and shuts the system down. Once the integrity checks have verified that the system is in a trusted state, it is safe to start up the remainder of the CAB processes. Each CAB process may be executed by CABInit, thereby causing a SELinux domain transition allowing each process to transition into its domain. In one embodiment, when all CAB processes have been started successfully, the CABInit process uses the common Wire Protocol to send the shutdown monitor all of the process IDs of the processes it has initialized. Once CABInit has delivered the process IDs, it has completed all of its responsibilities and exits leaving the heartbeat monitor, performance monitor and shutdown monitor to monitor system health.

[0258] In one embodiment, the file integrity verification mechanism used by CAB is supplied by the open-source file integrity tool Samhain. Additional integrity checks performed by CABInit may be developed to meet the very specific needs of CAB.

[0259] In one embodiment, CABInit initializes the Guard processes in the following order:

[0260] 1. Samhain and other Integrity Checks

[0261] 2. Heartbeat Monitor

[0262] 3. Audit Subsystem

[0263] 4. Shutdown Monitor

[0264] 5. Performance Monitor

[0265] 6. High-Side Listener

[0266] 7. Low-Side Listener

[0267] 8. High-Side VDP Router

[0268] 9. Low-Side VDP Router

[0269] 10. High-Side VDP Authentication

[0270] 11. Low-Side VDP Authentication

[0271] 12. High/Low User Mapper

[0272] 13. VDP Preferences

[0273] 14. Dirty Word Search Filter

[0274] 15. Keyboard Filter

[0275] 16. Mouse Filter

[0276] 17. Image Filter.

[0277] In this embodiment, as an implementation point, because the CABInit child processes preferably remain functioning after their parent process exits, each CAB process preferably becomes a process group leader. This may be achieved by calling the setsid( ) function after CABInit has forked the new process, but before that process calls execv( ). The setsid( ) function makes the calling process into a process group leader and ends the parent-child relationship with the CABInit process, allowing it to become autonomous.

[0278] Operating System

[0279] In this embodiment, the operating system may interface with system hardware and control objects and resources running in the system. For example, in a self-protected environment, such as the CAB Guard, the operating system may be a component in securing the flow of information and maintaining the separation of sensitive data. In one embodiment, the CAB Guard and Translator are based on a custom installation of Red Hat Enterprise Linux 4 Advanced Server (RHEL 4 AS), with SELinux enforcement enabled. The inclusion of SELinux into RHEL 4 AS enables the operating system to have fine-grained control over every subcomponent within the system and permits the operating system to enforce least privilege. The operating system used by CAB may contain only the subset of standard packages that are required for CAB-specific functions, thereby eliminating excess code and greatly reducing the potential for system exploits.

[0280] In this embodiment, the Linux iptables firewall may be a CAB operating system subcomponent. It secures the CAB network interfaces, providing the first line of defense against unauthorized use. Linux iptables may use the Netfilter framework inside the Linux kernel to determine which packets are allowed into the system based on their source and target addresses, ports and network protocol. The iptables configuration may limit inbound and outbound connections to those needed for CAB subcomponents.

[0281] Design Decisions and Considerations

[0282] In this embodiment, security is an important aspect of the operating system subcomponent because the operating system allocates and controls resources. A failure in the operating system could violate the integrity of the CAB security model, resulting in contamination or unauthorized disclosure of data. Because the CAB system can processes highly sensitive data, when unexpected behavior occurs, the system may enter a maintenance mode so that the system can be verified. Once an administrator has corrected any problems and verified system integrity, CAB can resume production mode.

[0283] Installation Considerations

[0284] In one embodiment, the CAB system employs a custom installation of RHEL 4 AS having only the packages required for CAB. The installation process uses a modified Red Hat Kickstart script. After the system has been installed, a hardening script executes. The script addresses the specific Guard and Translator needs.

[0285] Firewall Selection

[0286] In one embodiment, Linux iptables serves as CAB's software firewall because it is a secure and configurable tool, tightly integrated into the Linux kernel. Enabling iptables requires no kernel or system modifications. Only the rules must be configured, and those rules can be readily optimized specifically for CAB.

[0287] Interface-Related Design Considerations

[0288] In one embodiment, in order to function correctly, the CAB components depend on services provided by the operating system, such as domain separation and control over data flows. In addition, CAB may use the operating system's boot and initialization procedure to start the CAB Initialization process, which in turn starts the various Translator or Guard components. When the CAB system shuts down or transitions into maintenance mode the CAB shutdown process preferably invokes the operating system's power management subsystem to enable the machine to physically turn off or reboot.

[0289] Performance-Related Design Considerations

[0290] In this embodiment, a customized version of RHEL 4 AS built specifically for an embodiment of CAB is a stripped down version containing the minimum set of packages and processes. In addition to providing security, it improves performance. The CAB operating system may also use a standard SELinux kernel, performance-tuned for the CAB system.

[0291] Safety, Security, and Privacy Design Considerations

[0292] In one embodiment, RHEL 4 AS with SELinux may be the primary mechanism for enforcing separation of system objects into protected domains, thereby providing safety, security and privacy. Objects in one domain can only access objects in another domain if those are explicitly permitted to do so. Therefore, information cannot be transferred between domains except through well-known mechanisms specified in the system's policy.

[0293] Flexibility, Availability, and Maintainability Design Considerations

[0294] In this embodiment, the CAB operating system is designed for high availability. Excluding scheduled maintenance time, a properly configured and maintained CAB system should preferably sustain uptimes in excess of 99.95%.

[0295] In this embodiment, in order for the system to be maintainable there preferably is a mechanism for installing and updating the packages on the system. For example, RHEL 4 AS uses the RPM package management system for maintaining groups of files on the system. RPM on the CAB system can preferably only be accessed by a system administrator in the CAB maintenance mode policy.

[0296] Directory Layout

[0297] In this embodiment, to facilitate system administration, CAB may use the standard Linux directory structure. Configuration files, executables, and log files are stored in intuitive locations within the/etc,/usr, and/var directories.

[0298] Configuration Files

[0299] In one embodiment, CAB configurations files are in/etc/cab. This methodology follows the UNIX convention of placing configuration files in the/etc directory. Inside the /etc/cab directory are the subdirectories “active” and “staging.”

[0300] Executable Files

[0301] In one embodiment, CAB executable files that do not perform administrative tasks are located in/usr/cab/bin. This includes all Guard and Translator binary components.

[0302] Administrative Executables

[0303] In one embodiment, CAB administration executable files are in/usr/cab/sbin (e.g., any applications that modify or commit changes to configuration files).

[0304] Libraries and Headers

[0305] In one embodiment, CAB libraries files are in/usr/cab/lib, and all CAB header files are in/usr/cab/include. Source and header files may only be available on development CAB systems and may not be included in any production systems.

[0306] Temporary Files

[0307] In this embodiment, CAB temporary files may be in the/var/cab/tmp directory. Each CAB application may have a separate subdirectory accessible only to its domain.

[0308] Firewall Configuration

[0309] In one embodiment, the CAB firewall restricts incoming traffic and outgoing traffic to allow only VDP traffic and time-synchronization where appropriate. In one embodiment, the Guard firewall rules support Client VDP traffic, Translator VDP traffic and high-side-trusted Network Time Protocol. In another embodiment of the CAB Guard, which includes client-certificate support, it may have access to a high-side Certificate Authority (CA) certificate revocation lists (CRL). Preferably, all other traffic is implicitly blocked. Exemplary Guard rules are presented below:

[0310]

Guard Firewall Rules
Interface	Direction	Protocol	IP Addresses	Notes
High	Inbound TCP	VDP TLS	Individual Client IP	Prescribed by site policy;
			addresses or networks	single IP address more
				restrictive but harder to
				maintain
High	Inbound/Outbound	Network Time	Single NTP server	Necessary for time
	UDP	Protocol (NTP)		synchronization;
				recommended deployment on
				secure switched network
High	Outbound TCP	TLS	Certificate Authority	Future - for support of
				certificate revocation lists
				(CRL)
Low	Outbound TCP	VDP TLS	Only available translators	Likely direct connections

[0311] SELinux Security Policy

[0312] In one embodiment, the CAB system enables secure transfer of information between separate domains of differing classifications. Any failure in the security of the system could expose sensitive data to an adversary, or inadvertently allow a valid user to gain increased privileges. The SELinux operating system security policy may be an element in preventing security failures and providing a secure data flow. The security policy may limit the damages caused by the possible failure of any one of the components by following the principle of least privilege to separate and contain each process into an individual domain with only the privileges that it requires to perform its task.

[0313] In this embodiment, the operating system security policy enforces a set of security goals that protect the operating system and guard applications. These security goals may be distinct from the application security considerations discussed above. The security policy, at the highest level, provides basic protection for the system, hardens the CAB application environment, and supports the security policy of the guard applications. It may be constrained by the overall system requirements for both security and functionality. In one embodiment, exemplary operating system security goals (OS-1 through OS-6) are that:

• • [0314] 1. All operating system security goals are enforced solely by operating system security mechanisms.
  • [0315] 2. Information cannot flow between the high-side and low-side networks except through the guard applications.
  • [0316] 3. Information flowing between the high-side and low-side networks must pass through the appropriate guard applications in the correct order.
  • [0317] 4. There is appropriate assurance of security of the operating system and guard applications.
  • [0318] 5. The administrative functions require a minimum of privilege and are separated into appropriate roles.
  • [0319] 6. The operating system, particularly the security enforcement mechanism, must protect itself from tampering and bypass.

[0320] In this embodiment, such exemplary security goals support overall CAB security requirements and the security policy of the guard applications. These security goals will be met primarily through a custom SELinux policy. The SELinux policy may consist, conceptually, of two components: the base policy and application policy. The base policy may provide policy covering the operating system and associated resources and services. The application policy may provide policy covering the CAB-specific applications and services. These two components are combined to create the overall SELinux policy for the system. The following paragraphs will describe how the operating system security goals will be met by the operating system security policy. In one embodiment, in addition to the SELinux policy, best practices for Linux security configuration will be used, including a standard Linux discretionary access control policy, iptables firewall configuration, and other common security features of Linux.

[0321] OS Security Goal 1

[0322] In this embodiment, the first exemplary operating system security goal is a security meta-goal, stating that all operating system security goals should be met by operating system security mechanisms. The SELinux policy will attempt to enforce all of the subsequent security goals without relying on the correct functioning of user-space applications. This greatly reduces the trust placed in the applications, potentially simplifying application code. Additionally, this provides a stronger enforcement of the security goals and removes the need to consider application code when evaluating the system for the operating system security policy. The application code is still security-critical and should be evaluated in terms of the application security policy and overall system security.

[0323] OS Security Goal 2

[0324] In this embodiment, the separation of the high-side and low-side networks should be maintained by the Guard except through the appropriate guard applications. This goal directly supports the overall security requirements of CAB. The SELinux policy will prevent the flow of information between the two networks except as allowed through OS-3. SELinux provides effective, fine-grained control over the overt flow of information through the system, allowing a policy to be created that controls what applications can communicate with the network interface and how information can flow between applications.

[0325] OS Security Goal 3

[0326] In this embodiment, in order to enforce the guard-application security policy, it is preferably that information flowing between the high-side and low-side networks pass through the correct guard applications in the correct order. The combination of this security goal and OS-2 allows the SELinux policy to guarantee that no information can flow between the two networks that has not passed through the guard applications, allowing the guard applications to correctly enforce the transfer security policy. The SELinux policy language is uniquely suited to enforce this type of security goal.

[0327] OS Security Goal 4

[0328] In this embodiment, in addition to supporting the security policy of the guard application, the operating system security policy may provide appropriate assurance for the overall security of the system. This may be accomplished primarily through the creation of a strict least-privilege SELinux policy for all components of the system including the guard applications. A least-privilege policy provides assurance that the security goals of the system will be met, even in the event of application errors or compromise. In particular, a least-privilege policy may limit the potential damage from a compromise, including reducing or removing the possibility of privilege escalation. A carefully crafted least-privilege policy may limit an application to only those actions required to function correctly, regardless of whether the application is correctly functioning or has been compromised.

[0329] OS Security Goal 5

[0330] In this embodiment, system administration, by definition, requires additional privileges beyond those needed for normal operation. The creation of secure administrative functions is, therefore, challenging. The operating system security policy may separate the administrative functions into a set of appropriate roles, which each have the minimum privileges required. The SELinux policy language has support for role-based access control (RBAC). Though different from other RBAC mechanisms, the SELinux RBAC policy may allow the creation of the administrative roles and strongly limit them to the minimum privilege required. Additionally, SELinux policies can include runtime configuration, allowing the creation of two policy configurations: production and maintenance. Transition between these configurations can be securely controlled. In the production configuration, used during normal operation, many or all of the administrative functions may be disabled. In contrast, the maintenance configuration may disable network access and the guard applications, preventing the flow of information through the system, but allow access to administrative functions.

[0331] OS Security Goal 6

[0332] In this embodiment, the final exemplary operating system security goal is self-protection. In order to effectively enforce the other security goals, the system preferably should protect itself from both tampering and bypass. The SELinux policy may protect important operating system resources, including the SELinux policy, the kernel image and boot loader, configuration files, kernel configuration interfaces and raw device files.

[0333] Design Decisions and Considerations

[0334] In one embodiment, because the CAB system uses SELinux and its strong mandatory access control (MAC) mechanism, the security policy is written in the SELinux policy language. There may be two major modes for the CAB security policy: a production mode and a maintenance mode. When the system is in production mode, it inspects traffic, and allows valid traffic to cross domains. When the system is in maintenance mode, there are administrative components operating with special privilege. Because some administrative components could compromise system robustness and policy and because a remote attacker would want to use these components to bypass security mechanisms, it is important that powerful components are out of reach during live system operation. During production mode, all CAB traffic-related components are preferably operational, but most administrative tools are preferably disabled.

[0335] In this embodiment, likewise, when CAB is in administrative mode, an administrator might need to modify configuration that can only be reading during production mode. Moreover, the administrator has no need for network traffic to flow across the network interfaces or for traffic-related components to execute. To accomplish this separation the CAB Guard and CAB Translator may each have two partitioned policies, each configured specifically for the tasks necessary to perform in either production or maintenance mode.

[0336] In this embodiment, the SELinux Security Policy is not a piece of software—it is a configuration that defines how the SELinux operating system protects the CAB Guard and Translator components. The policy is a manifestation of the architectural design of the system; subcomponents can preferably communicate only with those subcomponents necessary for to perform their function. Subcomponents may rarely be granted read and write operations to individual resources. Subcomponents may rarely have bi-directional communication with other subcomponents—and those that do may be minimal and among the most trusted.

[0337] Interface-Related Design Considerations

[0338] In this embodiment, the Security Policy may use SELinux policy Booleans to enable the Initialization component to enable or disable core communications capabilities, such as access to the network interface cards. In one embodiment, the Security Policy enforces one-way IPC channels between processes by defining unique types for each IPC. For example, the domain sending the IPC message only has write; the domain receiving the IPC message has only read.

[0339] Flexibility, Availability, and Maintainability Design Considerations

[0340] In this embodiment, the CAB Guard and Translator components may each contain two separate security policies, one for maintenance mode and one for production mode. The production policy has two states, enabled and disabled, controlled by the value of an SELinux Boolean. When the Boolean is TRUE, the network interfaces may be permitted to send and receive data. This virtual switch allows the CAB system to complete the startup of all CAB processes and to verify that the system is ready to handle sessions before traffic can flow through the system.

[0341] In this embodiment, when the SELinux operating system first boots up, it may load the production policy with the Boolean set to the default value, FALSE. The maintenance policy, on the other hand, preferably does not permit the network Boolean to be TRUE, thereby disabling the operational system startup. This allows that the system can be administered in the absence of any cross-domain traffic or traffic-passing processes. The following table shows available states in an exemplary security policy:

[0342]

Security Policy - Available States
	Network Boolean = False	Network Boolean = True
Production	Enables CAB subcomponents to	Enables traffic during normal run-
Mode	initialize in a secure state. Network	time operations. This state allows
	activity is disabled, preventing any	CAB subcomponents to
	outside dataflow before all	interoperate, and allows selected
	subcomponents are confirmed	subcomponents to access the
	operational. Most maintenance	network. Most maintenance
	operations are prevented.	operations are prevented.
Maintenance	The Network Boolean is always false	Not applicable. Network activity
Mode	in Maintenance Mode. Most of the	cannot be enabled.
	CAB subcomponents cannot operate.
	Only those subcomponents required
	for maintenance and forensics are
	permitted. Network activity is
	disabled.

[0343] Subcomponent Details

[0344] In one embodiment, a set of primary security domains for the Guard and the Translator have been identified. Those primary security domains within the Guard include:

• • [0345] Filter domains (containing each of the content filter processes)
  • [0346] VDP2RDP domain (contains VDP2RDP processes)
  • [0347] Audit domains (several domains containing audit-related processes)
  • [0348] Administrative domains (several domains containing administrative and configuration processes)
  • [0349] Heartbeat Monitor domain (containing the system-monitoring functions)
  • [0350] Performance Monitor domain (containing the system-monitoring functions)
  • [0351] Other domains to be added, as needed.

[0352] In one embodiment, at some point during the SELinux boot cycle the policy is loaded by the kernel. From that point on, policy is enforced. The system then continues with the startup process, including a set of integrity checks and the startup of each CAB-specific process. If at any point an error is detected, the system may transition into maintenance mode for the administrator's inspection. After all of the CAB processes have started, the SELinux Boolean for networking is switched to TRUE, and the system is ready for sessions to be processed through the system. When the system is ready to shut down or enter maintenance mode, either as the result of an error or an administrator's initiation, the system transitions the security policy accordingly.

[0353] Heartbeat Monitor

[0354] In this embodiment, the Heartbeat Monitor, along with the Performance Monitor, may be responsible for ensuring that processes on the CAB system are functioning properly and have the resources required to function effectively.

[0355] In one embodiment, the Heartbeat Monitor is the first process started by the CAB Initialization Process because it needs to be available when each of the other CAB processes starts running. The heartbeat monitor may be capable of receiving three types of messages:

• • [0356] A message stating that a process has just started running
  • [0357] A message reporting that the process is still running
  • [0358] A message notifying the heartbeat monitor that the process is shutting down.

[0359] In this embodiment, once a message is received, the heartbeat monitor can update a table that records the state of processes. The table may consist of two fields, a field for the current state of the process and a field for the last time it was updated. Periodically, the heartbeat monitor can check its table to preferably make sure that every running process has an entry in the table with a recent timestamp. Once a process starts up, it preferably notifies the heartbeat monitor that the process is running and that it should start expecting to receive heartbeats periodically. While the system is running, the heartbeat monitor preferably monitors the table, and if a process has a timestamp that exceeds the defined heartbeat period, it may be assumed that the process is no longer able to function. In the case where a process chooses to exit cleanly, the process preferably sends a shutdown message that notifies the heartbeat monitor that the process is explicitly exiting and that it should no longer expect to receive heartbeats. If however, a heartbeat is received after the process has sent a shutdown message, then that may be an indication that something has gone wrong and the process was unable to shutdown. Not receiving a heartbeat in a reasonable time period and receiving a heartbeat from a process that should have shutdown may be events that will result in the system being shut down.

[0360] Design Decisions and Considerations

[0361] Performance-Related Design Considerations

[0362] In one embodiment, the heartbeat monitor process can use IPC, via the shared Wire Protocol, to receive the heartbeat from the CAB processes. The IPC used by the heartbeat monitor preferably limits blocking so that performance hits resulting from sending and receiving heartbeats will have minimal impact on overall system performance.

[0363] Subcomponent Details

[0364] In one embodiment, after the basic CAB processes are up and running and the system is ready to start accepting connections, it is the heartbeat monitor's job to notify audit that the system is ready. Audit will create a record in the audit log and based on the policy notify the shutdown monitor to change the Boolean value and allow access to the network interfaces.

[0365] In this embodiment, the heartbeat monitor can consist of two threads in addition to the CAB control threads. The first thread may block on an IPC mechanism and wait for messages to process. Once a message is received, the thread may update the state table with the information conveyed in the message. The IPC method used for the heartbeat may be wrapped within the common Wire Protocol. Monitored process are able to send messages without needing to block and wait for the heartbeat monitor to process the message. The second thread may be responsible for monitoring the state table and ensuring that all processes contain heartbeat entries that are current. If a problem is detected, this thread may be responsible for notifying the audit subsystem of an error resulting in the shutdown of the system.

[0366] In one embodiment, the heartbeat monitor starts up and enters the running state where it receives messages from processes announcing that they have started up. Once processes have started up, the system waits to receive heartbeats. If a heartbeat is not received within the specified time, the message is overdue and a message is sent to audit. Once audit is notified, the heartbeat monitor waits for a message from the Shutdown Monitor instructing the process to shutdown. The heartbeat monitor then transitions to shutdown and exits. Otherwise, when the shutdown monitor receives a shutdown message, the heartbeat monitor transitions from the receiveHeartbeat state to the shutdown state and exits.

[0367] Interfaces

[0368] In one embodiment, the heartbeat monitor may be used by the Guard and Translator system components. In each case, the heartbeat monitor can receive data from numerous processes on the system via the shared Wire Protocol. The first message sent to the heartbeat monitor may be a message containing the process id and the process type. This may be one-way communication channel, where the heartbeat monitor will only receive data.

[0369] In this embodiment, in addition to receiving heartbeat messages, the heartbeat monitor can also interface with the Audit and Shutdown subcomponents. The table below identifies each heartbeat monitor interface in one exemplary embodiment:

[0370]

Heartbeat Monitor - Interfaces
Subcomponent	Interface Description
Audit	This subcomponent sends audit messages directly to the Audit
	subcomponent, using the common Wire Protocol. This is one-way
	communication.
Shutdown	Upon execution, this subcomponent registers with the Shutdown Process,
Process	using the common Wire Protocol. Once registered, the heartbeat monitor
	listens (using the Shutdown Thread and a blocking read) for shutdown
	commands from the shutdown process. This is one-way communication.
All Monitored	Upon execution, each monitored process uses the common Wire Protocol
Processes	to provide regular heartbeat messages to the heartbeat monitor. This is
	one-way communication.

[0371] Performance Monitor

[0372] In this embodiment, the purpose of the performance monitor process in one embodiment is to monitor system performance and to verify that the system remains within operating parameters. If a system component runs out of resources and is unable to run properly, the system preferably shuts down. If the performance monitor detects a problem, it may notify Audit, which can generate an audit record, and Audit may inform the shutdown monitor that it needs to shut down the system.

[0373] In this embodiment, the Performance Monitor may be executed as part of the Initialization Process, and enters its running state. The performance monitor may be divided into two threads. One thread may receive performance statistics from processes and store them in a table, while another thread may periodically process information provided by other processes along with information it collects from the system. The data may then be compared to a threshold. If the system is running above the system limits, audit may be notified of a failure and the system preferably shuts down. Under normal conditions, where no thresholds are exceeded, the Performance Monitor may continue to execute until it receives a shutdown message from the Shutdown Monitor.

[0374] Design Decisions and Considerations

[0375] Performance-Related Design Considerations

[0376] In this embodiment, the Performance Monitor process may use IPCs, by means of the shared Wire Protocol, to receive the performance messages from CAB processes. The IPCs used by the monitor preferably limits blocking so that performance hits resulting from sending and receiving messages will have minimal impact on overall system performance.

[0377] Subcomponent Details

[0378] In one embodiment, the performance monitor obtains its information from system utilities and from session data sent to it by the audit event dispatcher. The system and kernel facilities used by the top and ps command line utilities may be used to report most of the system's information. The performance monitor may query for system statistics that include CPU utilization, real and virtual memory utilization, the number of processes and their state, and load averages. The kernel network interface ioctls may be used to report on information such as the number of packets sent and received, the number of errors, and the number of dropped packets over the high and low interfaces.

[0379] In this embodiment, information about sessions may be received from the Audit Event Dispatcher. When session-specific Audit events occur (such as a user beginning a new session, etc.), the Audit Event Manager may be alerted and information about that event may be passed to the performance monitor. In one embodiment, it is the monitor's responsibility to store information about each event so that it can derive statistics such as the number of sessions currently on the system, the total number of sessions, and which users are associated with which session. The performance monitor may contain various variables and data structures to maintain these statistics. There may be a variable that represents the current number of sessions. This number may be incremented each time a new session event is received and decremented each time a session end event is received. Another variable may contain the total number of sessions since startup. This variable may be incremented each time a new session event is received.

[0380] In one embodiment, these statistics may periodically be written to file for later analysis. The file format may consist of a series of numbers in csv format, for example, with one line representing one period of time. The numbers may represent statistics from CPU utilization to the number of sessions. Information about the current mapping of users to sessions is intended for administrative purposes and may not need to be exported to the file.

[0381] In one embodiment, the Performance Monitor may contain three threads in addition the CAB control threads like the heartbeat monitor. One thread may receive data from the Audit Event Dispatcher and update the statistic variables, while the second thread may periodically write the data in the variables to the data file. The third thread may wait for requests for information from the administration tools that require information about users, and which sessions are associated with those users.

[0382] Interfaces

[0383] In this embodiment, the Performance Monitor may be used by the Guard and Translator system components. In both cases, the Performance Monitor may receive data from many of the other processes within the system component. The processes may use the shared Wire Protocol to connect to the Performance Monitor and begin sending messages containing performance data. Each message may have a type associated with it identifying what type of performance data the message contains. In the case of sessions, the message may contain a session id and a session event and session statistics. The session event may specify if a new session has started up or shut down. In some cases, the session statistics may remain blank, such as in the case when a session starts up. In other cases, such as when a session shuts down, the session statistics may contain information about the session such as bytes of information passed, or length of the session. This is preferably a one-way communication channel through which the Performance Monitor will receive data.

[0384] In this embodiment, in addition to receiving performance messages, the Performance Monitor may also interface with the Audit and Shutdown subcomponents. The table below identifies each Performance Monitor interface in one exemplary embodiment:

[0385]

Performance Monitor - Interfaces
Subcomponent	Interface Description
Audit	The Audit subcomponent relays performance data to the performance
(receiving	monitor, using the common Wire Protocol. This is one-way
performance	communication, over an IPC independent from that used to send Audit
data)	data. Through this interface, monitored processes communicate indirectly
	with Performance Monitor, with Audit as the intercessor.
Audit (sending	This subcomponent sends audit messages directly to the Audit
Audit data)	subcomponent, using the common Wire Protocol. This is one-way
	communication.
Heartbeat	Upon execution, this subcomponent utilizes the common Wire Protocol to
Monitor	provide regular heartbeat messages to the heartbeat monitor. This is one-
	way communication.
Shutdown	Upon execution, this subcomponent registers with the Shutdown Process,
Process	using the common Wire Protocol. Once registered, the heartbeat monitor
	listens for shutdown commands from the shutdown process. This is one-
	way communication.

[0386] Shutdown Monitor

[0387] In one embodiment, the Shutdown Monitor is responsible for making changes to the state of the system. It may constantly wait for a state change event, arriving through the common Wire Protocol, and then responds to it.

[0388] In this embodiment, the state change message may contain a number signifying to what state the system should transition.

[0389] In this embodiment, the Shutdown Monitor may initiate transitions to one of four system states:

• • [0390] Production Policy with Network Boolean set to TRUE
  • [0391] Production Policy with Network Boolean set to FALSE
  • [0392] Maintenance Policy
  • [0393] Power Off.

[0394] In one embodiment, the Production policy state grants privileges to the CAB components allowing them to run while the policy restricts the abilities of maintenance and configuration utilities. Certain configuration tasks cannot and should not be run while the system is processing sessions and this policy ensures this. The Production policy also may have two states controlled by a SELinux Boolean, which determine when to activate networking.

[0395] In this embodiment, the Network Boolean may be an SELinux-related policy switch that either permits (TRUE state) or denies (FALSE state) network connectivity for the system. The default value for the Network Boolean is FALSE, which allows for the CAB processes to start up safely before allowing connections. In one embodiment, only after the system has verified that it is ready to receive connections does the Boolean value get changed and network connectivity is permitted.

[0396] In one embodiment, the Maintenance policy state may be designed to allow privileges that are required for performing maintenance on the system. The system may transition into Maintenance mode when initiated by an authorized administrator, or when directed by policy in response to specific error conditions. The Shutdown Monitor may receive messages instructing it to transition into maintenance mode from the Audit subsystem or the administrator's shutdown utility.

[0397] In one embodiment, the Power Off policy state shuts the system down completely without transitioning into maintenance mode. When a severe error occurs, the Audit Subsystem preferably sends a message to the Shutdown Monitor instructing it to power the system off. The administrative shutdown command can also send a power-off message to the Shutdown Monitor when an administrator would like to completely shut down the system.

[0398] In one embodiment, if the system is transitioning into maintenance mode or powering off, the Shutdown Monitor preferably sends messages indicating to each process that they are to shut down and the monitor will send them though each processes' IPC connection to the Shutdown Monitor.

[0399] In one embodiment, the initialization phase starts out by initializing variables and verifying that the system has adequate resources to start up the process.

[0400] In this embodiment, after initialization, two threads may be created. The first thread receives a list of process IDs from CABInit that the monitor needs to notify in the event of a shutdown. Certain processes associated with sessions may start up and shut down while the system is running. In order for these processes to work with the Shutdown Monitor, a process ID preferably will have to be added and removed from the Shutdown Monitor while the system is running. If another process in the system creates processes, it is the responsibility of that process to make sure that Shutdown is told what processes it needs to shut down. Likewise, when a process shuts down, Audit notifies the shutdown monitor and based on the message, the shutdown monitor either removes the ID of that process, or shuts down the system.

[0401] In one embodiment, the processes that require shutdown notification may be placed into a notification table (or “process vector”). The order in which the processes are shut down is not critical; however, the audit subsystem preferably needs to be shut down last so that it can continue to receive audit events as long as possible. Note that the security policy's Network Boolean is set to FALSE before shutdown commences, preferably ensuring that no data enters or exits the system during shutdown.

[0402] In this embodiment, the second thread that may be created after initialization is a thread that waits for state change messages. If a “shutdown” or “change to maintenance mode” message is received, the monitor preferably sets the Network Boolean, notifies the Audit Process that the Boolean has been changed, and then proceeds to notify all processes in the notification table to shut down.

[0403] In this embodiment, if the state change message simply requests a change of the Network Boolean, the change may be made, Audit is notified and it continues waiting for messages.

[0404] In one embodiment, once the processes have been notified, the system shuts down the system by transitioning into maintenance mode or running/sbin/init and powering the system off.

[0405] Design Decisions and Considerations

[0406] Implementation Decisions

[0407] In this embodiment, for processes to be able to interact with the Shutdown Monitor, each process will preferably have been linked to a library that contains special functions for setting up the mechanisms that interface with the initialization subsystem. The library may contain functions that a program will call while it is starting up. The functions will create and control threads and setup IPC communication between the process and the Shutdown Monitor. The shutdown control thread establishes an IPC channel with the Shutdown Monitor, and blocks on read waiting for a message from the Shutdown Manager informing the process that it needs to shut down. When such a message is received, the process may call a shutdown function, which will clean up the Shutdown Monitor thread allowing the process to then return normally.

[0408] Subcomponent Details

[0409] In this embodiment, changing the Network Boolean value is straightforward. In one embodiment, the process can open the appropriate Boolean file in the/selinux partition and set the value to 1 or 0 depending on the context. The shutdown process may run in a domain that allows write access to the Boolean file.

[0410] In this embodiment, transitioning to maintenance mode and powering off may be more complicated. In one embodiment, first it sets the network interface Boolean to FALSE so that no data can move through the session as components are shutting down. If the Boolean is not set to FALSE, it may result in partially processed data going through the system and interface. Second, the Shutdown Monitor preferably sends a message to every process in the system informing them that the system is shutting down and that they must terminate.

[0411] In this embodiment, the shutdown monitor may be aware of every process because it preferably receives a list of process IDs from any process that execs new processes. As stated in the Initialization section, the CABInit process may send all of the process IDs of the processes it has created to the shutdown monitor before exiting. If another process in the system creates processes, it can be the responsibility of that process to make sure that shutdown is told what processes it needs to shutdown.

[0412] In one embodiment, after the CAB processes have terminated, the system may either transition into maintenance mode or continue the shutdown process to turn off the system. If the system is transitioning into maintenance mode, it may first wait for all of the CAB processes to terminate. The shutdown monitor may then execute the load_policy command which will load the maintenance policy on to the system. If the system is shutting down, the shutdown monitor may execute/sbin/init and switch to runlevel 0 instead of calling the load_policy command.

[0413] Interfaces

[0414] In this embodiment, the Shutdown Monitor may be used by both the Guard and Translator system components. In both cases, the Monitor can accept an IPC connection from, and send data to, many of the other processes within the system component. Each process can utilize the shared Wire Protocol to connect to the Shutdown Monitor and begin listening for a shutdown message. This preferably is a one-way communication channel, where the Shutdown Monitor preferably only sends data. The processes monitored by the Shutdown Monitor may include:

• • [0415] Heartbeat Process
  • [0416] Audit Subsystem
  • [0417] Performance Monitor
  • [0418] High-Side Listener
  • [0419] Low-Side Listener
  • [0420] High-Side VDP Router
  • [0421] Low-Side VDP Router
  • [0422] High-Side VDP Authentication
  • [0423] Low-Side VDP Authentication
  • [0424] High/Low User Mapper
  • [0425] VDP Preferences
  • [0426] Dirty Word Search Filter
  • [0427] Keyboard Filter
  • [0428] Mouse Filter
  • [0429] Image Filter.

[0430] In this embodiment, in addition to sending shutdown messages to monitored processes, the Shutdown Monitor may also interface with the Audit and Heartbeat Monitor subcomponents. The table below identifies Shutdown Monitor interface in one exemplary embodiment:

[0431]

Shutdown Monitor - Interfaces
Subcomponent	Interface Description
Audit (receiving	Shutdown Monitor receives shutdown messages from the Audit subsystem, via
shutdown	the common Wire Protocol. More specifically, the Audit Event Manager
messages)	determines when a shutdown should be initiated, and sends the appropriate
	shutdown event to the Shutdown Monitor. This is one-way communication.
All Monitored	Upon execution, each monitored subcomponent registers with the Shutdown
Processes	Process, using the common Wire Protocol. Once registered, Shutdown Monitor
	is able to send shutdown commands to the subcomponents. This is one-way
	communication.
Audit (sending	This subcomponent sends audit messages directly to the Audit subcomponent,
audit messages)	using the common Wire Protocol. This is one-way communication.
Heartbeat Monitor	Upon execution, this subcomponent uses the common Wire Protocol to provide
	regular heartbeat messages to the heartbeat monitor. This is one-way
	communication.

[0432] Wire Protocol/IPC Mechanisms

[0433] In one embodiment, a Wire Protocol may define the format of messages passed via interprocess communication. Major RPC systems (e.g., CORBA, DEC RPC, Java RMI, and COM) define a wire protocol. The CAB system may use a wire protocol to define the binary message format for IPC calls between components, so that each component writer need not define a new message format for passing traffic or control messages. A good wire protocol implementation for CAB has the properties listed in the table below (additional desirable properties less important to CAB are language and platform neutrality).

[0434]

Wire Protocol - Desired Implementation Properties
Property	Notes
Transport-independence	Enable transport design decisions based on other criteria,
	such as performance and security
Lightweight	Do not perform unnecessary operations, such as conversion
	to a neutral format, when calls remain resident on the same
	hardware
Code generation support	Minimize development effort
Synchronous/asynchronous	Support one-way calls to disable mutual dependencies
calls	between sender and receiver
Robust	Ensure that data and semantic errors are detectable

[0435] In this embodiment, the CAB CDS system also prefers tightly controlled interaction between system components, and assured one-way IPC paths. Therefore, the transport used by the wire protocol preferably is one-way and securable via SELinux security policy. Many RPC systems include a global registry application, i.e., an intermediary, and often require two-way communication. A global registry may conflict with the design goals of one-way communications and minimal coordination between subcomponents. Another aspect of the wire protocol implementation in one embodiment is that it provides automatic encoding and decoding of message data, or “marshalling.”

[0436] Design Decisions and Considerations

[0437] In one embodiment, the wire protocol framework may include an Interface Definition Language (IDL) and an IDL compiler. The IDL compiler produces client proxy code and server-side stub code that the developer can customize. The client proxy code may perform marshalling and sends the one-way, asynchronous message to the server. The server-side framework receives the message, unmarshalls all parameters, and makes a call to the server-side function implementation.

[0438] Details of IDL and Marshalling (Encoding and Decoding)

[0439] In this embodiment, marshalling consists of representing data in a format independent of the address space, network and system where it originates. In one embodiment, address-space independence is preferred—each process preferably has a separate, private address space to ensure one-way data flows.

[0440] In this embodiment, the marshalling process defines the way in which those higher-level data objects are encoded by the sender (client) application and decoded by the receiver (server) application. A developer may complete several to use IPC:

• • [0441] Create an Interface Definition Language (IDL) File.
  • [0442] Compile the IDL File into client proxy and server stub code (.h and .c files).
  • [0443] Add client code to invoke the proxy functions.
  • [0444] Add server code to the server stub code to service the messages.
  • [0445] Specify the transport for messages.

[0446] In this embodiment, IDL may consist of definitions for interfaces, procedure calls and structured data. The interfaces group procedure calls in to a logical, uniquely identifiable container. Each procedure call may consist of a list of parameters and a return value. Each parameter has a data flow direction (in, out, or in/out) and generic type, such as integer, floating point, or text string, or structure data type. There might also be additional modifiers, such as “one-way,” to indicate one-way call semantics. Structured data groups multiple data elements into one entity (such as a “C struct”).

[0447] In one embodiment, although CAB uses an RPC framework defined in several standards, such as CORBA's IIOP, OSF DCE, RMI, and COM, it may not include classic RPC return-value semantics. In classic RPC, calls are synchronous and can include return values and output parameters. CAB subsystems may not use return values or output parameters because of one-way data security restraints. Instead, CAB IDL may define strictly one-way data flow using the IDL procedure keyword “one-way,” “void” return values, and only “in” parameter modifiers. To enforce run-time one-way communication, the SELinux Policy may require that IPCs are unidirectional. Taken together, data flow from a client application to the servicing application (server) may travel in one direction, and there is preferably not a response data flow.

[0448] In one embodiment, once the IDL compiler generates the proxy and stub code and the developer has implemented the server-side code, the application can be built. The actual binding between client and server preferably occurs at runtime. In one embodiment, in a directory readable by the client, the server creates an IPC file writable only to that client, as defined by the SELinux Security Policy. The wire protocol library provides a function for the client application to obtain write-access to the IPC and a function for the server application to create and obtain read-access to the same IPC. The IPC file name and path may be configured in the CAB configuration directory.

[0449] In this embodiment, at run-time, the wire protocol library may perform the copying of marshalled data to the transport on the client side, and copying and unmarshalling the data in the server's address space.

[0450] Interfaces

[0451] In one embodiment, the CAB Wire Protocol implementation interfaces directly with the selected IPC/RPC transport. UNIX-style domain sockets may be the candidate IPC because they have a high throughput and because the SELinux policy language defines fine-grained control over them.

[0452] Preferably, almost every subcomponent and element within the CAB Guard and Translator uses the Wire Protocol.

[0453] Audit and Event Management Subcomponents

[0454] This section covers the full-time audit functions and the on-demand “flight recording” capabilities of CAB. In one embodiment, the Audit and Event Management subcomponents define the audit interface, security event management processing, event management policy, audit data recording and analysis, and system forensic capability.

[0455] Audit Subcomponent

[0456] In this embodiment, the Audit subcomponent supports diagnostic logging and security event auditing. In one embodiment, it primarily consists of a client interface element, various persistent repositories, and a central server element for aggregating and correlating all Guard events. (The Translator may implement the same Audit subcomponent, configured to properly handle Translator events.) The elements of Audit may be broken into multiple packages.

[0457] In this embodiment, diagnostic logging is preferred to develop CAB components. It also can provide wellness metrics not captured by security requirements, but necessary for overall system maintenance. Diagnostic logging may be tightly associated with an application's security domain, as generally, a holistic system view is not necessary.

[0458] In this embodiment, security event auditing, on the other hand, preferably provides a complete picture of system security events, as observed by all system components. Event auditing satisfies security requirements for a secured, tamperproof record of security-relevant system events. In one embodiment, there is no requirement for event correlation.

[0459] Design Decisions and Considerations

[0460] Interface-Related Design Considerations

[0461] In this embodiment, there are several considerations for the Audit interface:

• • [0462] Simplicity for clients
  • [0463] Extensibility for new events and types
  • [0464] Extensibility for new destinations
  • [0465] Extensibility for new transports
  • [0466] Concurrency for multiple threads and processes
  • [0467] Support for administrative tools.

[0468] In this embodiment, to simplify client usage, the core auditing interface may offer three levels of data abstraction: data element, generic event record, and specialized event record. Orthogonal concerns such as event destination may be separated from the data interface.

[0469] In this embodiment, the Audit interface may be designed to cooperate with other common system components, such as session management and common processing. Audit clients do not need to carry out synchronization of data, as the client interface may provide synchronization under the covers.

[0470] Performance-Related Design Considerations

[0471] In this embodiment, all Audit elements may be designed to be thread-safe with minimal contention. Because real-world performance bottlenecks are often not understood until code is tested, the design makes use of loose coupling. Loose coupling facilitates performance tuning by enabling new, better implementations of components and IPCs to be introduced.

[0472] Database Design Decisions

[0473] In one embodiment of the Audit subcomponent, it uses a simple text-oriented output file, with custom-delimited fields. To support future analysis and visualization, the Audit Store employs data normalization. One embodiment supports normalization and indexing by using strong typing and unique identifiers of events.

[0474] Security and Privacy Design Considerations

[0475] One embodiment of the Audit subcomponent is designed for partitioned security domains. The primary security issues include:

• • [0476] Integrity of audit data
  • [0477] One-way transmission of audit data from multiple, partitioned client security domains to a single audit server
  • [0478] Configuration of client diagnostic policy by a system administrator
  • [0479] Configuration of audit server policy by a system administrator
  • [0480] Viewing of audit data by a different security administrator
  • [0481] Separation of event management from data store recording.

[0482] In this embodiment, some design principles to meet these security issues include least privilege and minimality. The audit server's audit store writer may operate in a security domain that enables it to write persistent data to disk with an “audit data type.” The Log and Forensic administrators are permitted to read the persistent data having “audit data type.” In one embodiment, a separate “audit configuration” type identifies configuration files modifiable solely by a Policy Administrator.

[0483] Flexibility, Availability, and Maintainability Design Considerations

[0484] In this embodiment, the Audit subcomponent may be instrumental in system maintainability. Security event and diagnostic data support developers and administrators who need to understand the system function.

[0485] In this embodiment, the Audit subcomponent may be flexible. It may support in-process and inter-process aggregated logging. The design also supports future development by enabling different persistent stores and transports to be incorporated without affecting the overall implementation.

[0486] In this embodiment, the Audit subcomponent may have implications for system availability. Audit trails are preferably tamperproof and guaranteed to occur for security-relevant events. Therefore, the Audit component may become a bottleneck that can affect availability or a target for a denial-of-service attack. Audit components may be designed to be contention-free as much as possible so that multiple clients can simultaneously record their events asynchronously.

[0487] Subcomponent Details

[0488] The following sections describe the elements of the Audit subcomponent.

[0489] Audit Data

[0490] In this embodiment, the Audit Data element may provide the essential data model for Audit events and the operations to manipulate it. In one embodiment, the data model consists of data types, core kinds of data present in Audit records, and the taxonomy of events. The operations may consist of functions for manipulating fields, accessing common fields, and working with field types. It depends on session data defined in the Common::Session package and the safe, portable common types defined in the Common::Types package. The core objects are AuditField and AuditRecord. Helper objects include AuditRecordWrapper and AuditRecordlterator.

[0491] In this embodiment, an Audit Record may be essentially a container of multiple fields, some always present, some frequently used, and some specific to the component generating the record. The table below presents examples of the varying level of commonality. The Container and Wrapper interfaces facilitate levels of commonality of fields while supporting software reuse.

[0492]

Audit Event Fields - Commonality
Commonality	Example
Always	process ID, component ID, timestamp, status code
Frequently	session ID, inspection success value
Used
Specific	Dirty Word Search matching word, Authenticator user
	name

[0493] Audit Client

[0494] In one embodiment, the AuditClient package may provide the core client capabilities for any system application or component to provide diagnostic logging and event auditing. Both diagnostic logging and event auditing require the capture of different types of values and persistence. Diagnostic logging may be provided only on development systems, and may not be included on production systems. Diagnostic logging need only be local to a specific application—however, a consolidated log could be useful for diagnosing cross-process issues. Security-event auditing should be consolidated to provide a system-wide view of security-related issues. In one embodiment, these crosscutting concerns are addressed by a single client interface, following the Proxy and Bridge patterns, that allows different event categorization (i.e., diagnostic vs. security) and modular destination (i.e., local file vs. audit server via IPC).

[0495] In this embodiment, the AuditClient may implement an abstract interface that defines the behavior of any Guard component that needs user session state. In one embodiment, it may consist of the following operations:

• • [0496] CreateRecord: create a simple record with or without user session data
  • [0497] AuditClient: initialize the subsystem, invoked at application startup
  • [0498] InitSession: associate user session data necessary for AuditRecord creation
  • [0499] CloseSession: release resources associated with user session data
  • [0500] GetName: return the name of the component, i.e., “AuditClient”
  • [0501] GetSession: get the session state.

[0502] In this embodiment, the AuditClient may also rely on an IAuditDestination interface, implemented as a logging capability or security-event destination.

[0503] Record Wrappers

[0504] In this embodiment, writing code to generate logging and auditing events may be repetitive. The code also can appear as noise because it appears so frequently. Record Wrappers may address both concerns, and are preferably used by the CAB Audit subcomponent.

[0505] Audit Format

[0506] In this embodiment, audit events written to unstructured text files may have a format independent of the destination to which they are written. One embodiment of the Guard can support binary or XML format. To separate format from structure, the Audit Format element may delegate formatting to encoders. One embodiment of the Guard supports ASCII, with a custom delimiter. The delimiter may be configured as a comma, for compatibility with Comma Separated-Value (CSV) format files. The ASCIIEncoder encodes the multiple types, encoding binary data types in Base-64 (MIME) format.

[0507] Event Destinations

[0508] In this embodiment, system events are preferably logged locally in their domain to facilitate early development, to a centralized repository for one embodiment, and to multiple guards in other embodiments. In order to support multiple destinations, there may be a single destination interface to be realized through local and inter-process destinations. The Destinations component may define the interface for writing an audit destination in the IAuditDestination interface.

[0509] One embodiment of the Guard need only provide text-based persistence of Audit data. Other embodiments may feature audit reduction and analysis, and therefore, a more structured persistent store may be implemented. The TextPersistentStore supports server persistence for auditing and client-side-only persistence for logging.

[0510] In this embodiment, in order to support session administration, the Audit Repository process also may maintain the live session list, including user name, session ID, priority, logon time, and other relevant data. The format may be in XML, to enable access from administrative utilities, using the CAB Configuration File capabilities.

[0511] Audit Repository/Audit Persistence

[0512] In this embodiment, the Audit Repository may be the CAB process that writes audit messages to the persistent audit data store. Audit messages may be received from the Event Manager.

[0513] Event Manager/Event Dispatch

[0514] In one embodiment, the Event Manager is the CAB process that receives audit messages from Audit Clients throughout the system. Once an audit message is received, it is the responsibility of the Event Manager to perform Event Dispatch.

[0515] In this embodiment, the Event Dispatch function provides a policy-driven capability to respond to security-relevant events. When an Audit Client (any CAB process with audit capabilities) detects an auditable event, it may send the event to the Event Manager, without regard for how that event should be treated. The Event Manager may perform Event Dispatch by applying its Event Policies to the new event and determining which actions should occur. The table below identifies the types of actions that may occur in one exemplary embodiment:

[0516]

Audit Event Action Objects
Action Object	Purpose	Service
LogoutAction	Terminate the active session.	High-Side VDP
		Sender
GuardShutdownAction	Shutdown the Guard.	Shutdown
ConsoleAlertAction	Display an alert for	Console Alert
	administrator.
MetricAction	Capture a performance metric.	Performance
		Monitor
AccountLockoutAction	Lock a user's account.	Authentication
AuditAction	Record an event persistently.	Audit
		Repository

[0517] In this embodiment, the Audit Event Manager may constitute the server element in the audit client to audit server relationship. Audit clients can include any CAB process that uses the Audit Client libraries to send audit messages to the Event Manager.

[0518] Audit Alerts

[0519] In this embodiment, the Alert element may provide an interface for generating alerts to an administrator. One embodiment provides a console-based alerter. Another embodiment may define additional alerts, such as those to pop-up windows, alarms, etc.

[0520] Administration

[0521] In this embodiment, initial administration of the Audit subcomponent may consist of specifying parameters in appropriate configuration files.

[0522] Flight Recorder Subcomponent

[0523] In one embodiment, the Flight Recorder subcomponent records user sessions when a user performs a suspicious action, or at other times as specified by the policy. When a suspicious event occurs, the Audit Event Manager notifies the interface listener to begin sending copies of session packets to the Flight Recorder. An Administrator will then have the opportunity to watch the session live (shadowing) or replay the session later. In one embodiment of the CAB system, there may be no built-in shadow or replay mechanism. In another embodiment, these features may be present.

[0524] Design Decisions and Considerations

[0525] Decision to Develop or Reuse

[0526] In this embodiment, because VDP is a completely new protocol, there is currently no software package that knows how to record VDP sessions and play them back. As a result, the Flight Recorder is newly developed. The Flight Recorder may use the VDP library to interpret VDP packets.

[0527] Interface-Related Design Considerations

[0528] In one embodiment of the CAB system, Flight Recorder may only interact with the Interface Listener and Audit subsystems. When a security event warrants flight recording, the Listener receives a message from the Audit Event Dispatch subcomponent indicating that a session must be recorded. The Interface Listener sends all packets associated with a session to the Flight Recorder to be recorded.

[0529] In this embodiment, when a packet with a matching session ID enters the Interface Listener, a copy of the packet is sent to the Flight Recorder. The Flight Recorder writes the packet into its data store. In another embodiment, an administrative interface enables the Forensic Administrator to replay the session directly on the Guard.

[0530] Performance-Related Design Considerations

[0531] In this embodiment, the Guard may not be able to record all user sessions while maintaining acceptable performance. Therefore, in one embodiment, the Flight Recorder is intended to record a session when an event has triggered the recording of data. The main performance concern is that every packet of a graphics-intensive session is preferably recorded to disk. The Flight Recorder may use tunable memory buffers to store packets and then periodically write the buffers to the data store to prevent overwhelming the disk with write requests.

[0532] Safety, Security, and Privacy Design Considerations

[0533] In this embodiment, the Flight Recorder and Session Data Store may be isolated in individual security domains so that other processes are prevented from accessing the recorded session data. In one embodiment, the Flight Recorder process may write to the Session Data Store, and the forthcoming playback and offloading tools may read the session data. In one embodiment, additional backup and cleanup functions receive appropriate access.

[0534] Subcomponent Details

[0535] In one embodiment, once the Flight Recorder starts up, it waits for session packets from the High-Side Listener. Once a packet is received, the Flight Recorder processes it and goes back to waiting for another packet. The Flight Recorder receives both inbound and outbound messages from the High-Side Listener. If the wait for packets is interrupted or the receive fails, the Flight Recorder enters an error state and shuts down. During healthy operation, the Flight Recorder waits for a system shutdown event.

[0536] Flight Recorder Timing

[0537] In one embodiment, the Flight Recorder includes a timestamp with each recorded packet. Timing may be a part of the Flight Recorder, because without a concept of when packets were received, the session playback function would not include the natural pauses, and the entire session would pass in a matter of seconds.

[0538] The Data Store

[0539] In this embodiment, the Flight Recorder may store recorded sessions into the /var/cab/flightrecorder directory. Inside of this directory, each session may be contained in an individual file. Each file's name may consist of the session id, date, and time that the recording of the session began allowing the administrator to quickly locate the correct session for replay. In order to maintain performance and prevent lost packets, the Flight Recorder may buffer all writes using a tunable memory buffer. If the buffer cannot handle the packet flow, an event may be logged so that the Guard can make a policy-driven response.

[0540] Interfaces

[0541] In this embodiment, within the Guard system component, the Flight Recorder may interface with several other subcomponents. The table below provides a description of these interfaces in one exemplary embodiment:

[0542]

Flight Recorder - Internal Guard Interfaces
Subcomponent	Interface Description
High-Side	When initialized, Flight Recorder connects to the High-Side Listener (via
Listener	the common Wire Protocol). While recording is active, the Listener sends
	a copy of inbound and outbound VDP traffic to Flight Recorder. This is
	one-way communication.
Hard Disk	This subcomponent writes directly to the hard disk, creating and
(write)	appending to session-specific recorder files.
Initialization	Initialization Process launches this subcomponent, using an ‘exec’ call.
Process	No communications are established between this subcomponent and the
	Initialization Process.
Heartbeat	Upon execution, this subcomponent uses the common Wire Protocol to
Monitor	provide regular heartbeat messages to the heartbeat monitor. This is one-
	way communication.
Shutdown	Upon execution, this subcomponent registers with the Shutdown Process,
Process	using the common Wire Protocol. Once registered, the heartbeat monitor
	listens for shutdown commands from the shutdown process. This is one-
	way communication.
Audit	This subcomponent sends audit messages directly to the Audit
Subsystem	subcomponent, using the common Wire Protocol. This is one-way
(sending	communication.
audits)

[0543] Authentication Subsystem

[0544] This section describes the CAB authentication subcomponents, with an emphasis on the Guard. In this embodiment, there may be two aspects of authentication: user-to-Guard and user-to-Terminal Server (through the Translator). User-to-Guard authentication can occur in two phases: TLS authentication (performed during the TLS handshake) and user authentication (performed after the TLS handshake). These two phases are handled by two separate groups of components.

[0545] In this embodiment, the Guard may provide a certificate that the Client uses to authenticate the Guard. In one embodiment, the Guard may not perform TLS Client authentication, i.e., the Guard does not require a client certificate. In another embodiment, CAB may be configurable to preferably require the user to supply a valid certificate, such as from a Comman Access Card (CAC) or certificate held in a client workstation.

[0546] In one embodiment, the Guard user authentication subsystem may consist of three subcomponents: the High-Side Authentication subcomponent, the Low-Side Authentication subcomponent, and the High/Low Authentication Mapper. The High-Side Authentication subcomponent authenticates the Client user to the Guard via a user ID and password pair. Additional authentication mechanisms may be included in other embodiments. The High/Low Authentication Mapper may map the high-side user ID to the low-side user ID presented to the Terminal Server (through the Translator). The Low-side Authentication subcomponent manages and passes the low-side password necessary to authenticate to the Terminal Server on behalf of the Client user.

[0547] In one embodiment, in order to perform the complete low-side authentication, the Guard maintains low-side Client user credentials and settings. The settings include screen resolution, color depth, keyboard layout, and any other settings presented during normal Terminal Server authentication. The Guard also can maintain password and connection statistics (e.g., last successful login and password expiration).

[0548] Design Decisions and Considerations

[0549] Component Design Decisions

[0550] In this embodiment, user authentication to the Guard is preferably to ensure that only authorized users can use the CAB system. Furthermore, confidentiality services are preferable to protect session traffic from eavesdropping. In order to address these issues, one embodiment of CAB uses a two-phase authentication process.

[0551] In one embodiment of CAB, TLS provides confidentiality services for session traffic and authentication of the Guard for the Client user (i.e., that the Guard “is who it says it is.”). In another embodiment, the Guard may support the use of TLS to authenticate the Client users, via certificates. The encryption algorithms for confidentiality and authentication services may be implemented through dedicated cryptographic accelerator cards on the Guard and Translator.

[0552] In this embodiment, in addition to TLS handshaking, one embodiment of CAB preferably has the high-side user provide a user ID and password to complete the authentication process. In other embodiments, CAB may include other user authentication techniques, such as the use of biometric data. In one embodiment that does not use PKI, user IDs and passwords are preferably used to authenticate Client users to the Guard. In other embodiments, the use of passwords may not be necessary.

[0553] Interface-Related Design Considerations

[0554] In this embodiment, the Authentication subsystem may communicate with other components via one-way, asynchronous IPC, keeping with the overall Security Policy.

[0555] In this embodiment, the Authentication subsystem may use Commercial off-the-shelf (COTS) APIs to communicate with the crypto accelerator cards. The decision on which API to use depends on what is provided with the crypto card selected for CAB. The crypto card API used may, for example, either be one supplied by the accelerator card vendor or RSA's PKCS #11 (also known as Cryptoki).

[0556] Performance-Related Design Considerations

[0557] Operations involving asymmetric cryptography are very computationally-intensive, and performing such computations in software may put an excessive burden on the Guard and Translator CPUs. Furthermore, symmetric cryptography may be used for connections into and out of the Guard and Translator. In this embodiment, given the volume of data being encrypted, it is preferable to have optimized hardware perform the cryptography. As is common practice in high-load network servers, CAB may be designed to take advantage of specialized cryptographic hardware.

[0558] Database Design Considerations

[0559] In this embodiment, the Authentication subsystem may maintain certificates, user IDs, passwords, user settings, and user preferences. Because of the sensitivity of the data in question, it is preferably to store the data securely and efficiently.

[0560] In this embodiment, user passwords may be encrypted to protect them from compromise. For example, strong password requirements stipulate that passwords may not be reused over certain periods of time and that a new password must be sufficiently different from previous passwords (e.g., a rule might be “no more than four characters are the same from a previous password”). These stronger rules require that new passwords be compared in plain text form, and therefore, it is not possible to use of one-way cryptographic hashes. Therefore, the Guard preferably uses encryption and has an encryption key. In order to have secure key management, the Guard preferably maintains a password decryption key, which is preferably loaded on to the Guard at boot time.

[0561] In this embodiment, session encryption occurring at both the high- and low-side interfaces is transient, and therefore need not be persisted in a cryptographic database.

[0562] Safety, Security, and Privacy Design Considerations

[0563] In this embodiment, because the Guard and Translator authentication components control access to the system and manage highly sensitive data, they are preferably in tightly controlled security domains. The SELinux Security Policy may provide domain separation and control over the direction of data flows between components.

[0564] In this embodiment, separate cryptographic operations may take place at the high-side and low-side interfaces, each interface transmitting data at a different level of security. For this reason, the Guard preferably has one cryptographic accelerator card for each security level. To protect the sensitivity of data, these cards are preferably certified to the FIPS140-2 standard.

[0565] One embodiment of CAB supports at a minimum 1024-bit RSA for key exchange and digital signatures, SHA-256 for hashing, and AES for confidentiality (128 bit blocks in CBC mode). Another embodiment may be “Suite B” compliant.

[0566] In this embodiment, because TLS supports virtual connections, it is possible for the Guard and Translator to have one TLS network connection for multiple virtual user sessions.

[0567] Flexibility, Availability, and Maintainability Design Considerations

[0568] In this embodiment, the Authentication subcomponent may generate “heartbeat” signals at regular intervals, as defined by the heartbeat monitor subsystem. In one embodiment, if any subcomponent of the authentication subsystem were to terminate, the heartbeat signals would cease, thereby indicating a serious problem to the heartbeat monitor. Likewise, if any authentication subcomponent detects a condition rendering it unable to continue processing, it would shut down immediately, triggering the heartbeat monitor to initiate system shutdown.

4.2.3.2 Subsystem Details

[0569] In this embodiment, FIG. 19 shows an example of the Authentication subsystem and its interactions within the Guard. The arrows in the figure represent the data pathways used for authentication-related messages and events.

[0570] High-Side TLS Authentication Subcomponent

[0571] In one embodiment, the High-Side TLS Authentication subcomponent comprises the code performing the TLS authentication for the high-side Client connection (via the TLS handshake). In one embodiment, this subcomponent may simply maintain access to the Guard's certificate, as no Client certificates may be supported. In another embodiment, this subcomponent may become an active process, maintaining Client certificates and authenticating Client TLS authentication requests.

[0572] High-Side Interface Listener Subcomponent

[0573] In one embodiment, the High-Side Interface Listener subcomponent implements the TLS protocol on the high-side network interface. It performs TLS handshakes, encrypts and decrypts VDP packets, and creates cryptographically strong unique session identifiers for each connection.

[0574] High-Side User Authentication Subcomponent

[0575] In one embodiment, the High-Side User Authentication subcomponent processes VDP authentication packets. It may receive packets from the high-side VDP router, verifies user IDs and passwords, and sends responses to the high-side VDP forwarder for transmission to the Client. After a user's credentials are authenticated, it transmits available session settings (e.g., available screen resolutions and color depths) to the Client and awaits an acceptable response. In order to read user settings and update data such as last logon time, it preferably has bi-directional communications with the User Preferences subcomponent, which maintains preferences and policy settings.

[0576] In one embodiment, once the negotiation of settings has been completed and the other Guard components are ready to process session traffic, the High-Side User Authentication subcomponent notifies the High/Low User Mapper, which initiates the low-side authentication process by sending a low-side user ID number to the High/Low User Mapper.

[0577] In this embodiment, if the client user wishes to change the low-side password stored on the Guard, this subcomponent may send a message containing the user ID number and the new low-side password to the High/Low User Mapper.

[0578] High-Side User Preferences Subcomponent

[0579] In one embodiment, the High-Side User Preferences subcomponent supports the High-Side User Authentication subsystem by providing a persistent store of client user preferences and settings. Settings can include screen resolution, color depth, keyboard layout, language, and any other VDP-specific preferences. In addition, this subcomponent may store the classification string and banner color associated with the low-side Terminal Server, which is displayed in the client window.

[0580] In this embodiment, the High-Side User Preferences subcomponent may also manage the “profiles” associated with users. A profile represents a grouping of preferences and policy settings to associate with a class of users. It can define the permissible preference values, such as screen resolution, color depth, and keyboard type; the priority of the user's session; and the policy for security-relevant events, such as how to respond to a dirty word entered by the user (e.g., “enable flight recorder” or “lock account”).

[0581] In one embodiment, when a user initiates a session, there is a negotiation over preferences. If no preferences are associated with a given user, the default values are used. The preferences are sent back to the Client, which either accepts them or sends back its new preferences. If the Client's chosen preferences are consistent with the profile assigned to the user, the process of low-side authentication may begin.

[0582] High/Low User Mapper Subcomponent

[0583] In one embodiment, the High/Low User Mapper subcomponent maintains the non-attributable relationship between high-side and low-side user identities. It maps the high-side user IDs to low-side user IDs, using, for example, a lookup table. For each high-side user ID number, there may be a one-to-one mapping to a distinct low-side user ID number. The Mapper, therefore enables high and low Authentication subcomponents to translate from high-side to low-side user identity, while remaining unaware of the user IDs themselves.

[0584] In one embodiment, the Mapper receives authentication-related messages from the High-Side User Authentication subcomponent, and sends authentication-related messages to the Low-Side User Authentication subcomponent.

[0585] Low-Side User Authentication Subcomponent

[0586] In one embodiment, the Low-Side User Authentication subcomponent performs authentication with the Terminal Server by way of the Translator. It receives messages from the High/Low User Mapper, and forwards VDP messages through the Low-Side VDP Forwarder subsystem.

[0587] In one embodiment, when the High/Low User Mapper sends an authentication message, the Low-Side User Authentication subcomponent begins the process of low-side authentication by sending a VDP message containing the low-side user ID and password to the Low-Side VDP Forwarder. This VDP Forwarder sends the message to the Low-Side Interface Listener, which in turn 1) initiates a TLS connection with the Translator and 2) sends the VDP authentication message to the Terminal Server.

[0588] In this embodiment, while the Low-Side User Authentication subcomponent is similar to the High-Side User Authentication subcomponent, it differs in that its authentication with the low-side Terminal can fail without terminating all session communication (in fact, terminal service COTS protocols do not always provide sufficient notification). If the password is not valid, the client user simply sees a login dialog, which requires a second, manual authentication via standard VDP keyboard events.

[0589] Low-Side TLS Authentication Subcomponent

[0590] In one embodiment, the Low-Side TLS Authentication subcomponent provides the authentication support for the Low-Side Interface Listener. It is analogous to the high-side interface Listener. It communicates bi-directionally with the Low-Side Interface Listener, maintaining the Guard low-side certificate supplied in the TLS handshake. Every low-side session will have a separate TLS connection with the Translator.

[0591] Low-Side Interface Listener Subcomponent

[0592] In one embodiment, the Low-Side Interface Listener subcomponent implements the TLS protocol on the low-side network interface. It performs TLS handshakes, encrypts and decrypts VDP packets, and initiates new network sessions with the Translator.

[0593] Cryptographic Accelerator

[0594] In one embodiment, the CAB system uses TLS to provide confidentiality, integrity, non-repudiation, and authentication services between high-side Clients and the Guard, and between the Guard and the Translator. Under the expected network loads the Guard is responsible for communicating across a large number of encrypted links. Given that asymmetric cryptography is computationally expensive and that numerous symmetric cryptographic operations would further burden the Guard CPU(s), the CAB Guard may employ specially designed cryptographic accelerator cards to free up core Guard processing for VDP protocol inspection.

[0595] In this embodiment, the Guard may have separate Interface Listener processes on the high side and low side interfaces because each process must have its own cryptographic accelerator. Additionally, the differing security domains of the connected networks make it preferably that no single process is permitted to communicate with both interfaces.

[0596] In this embodiment, cryptographic accelerator cards perform the cryptographic portions of TLS authentication. In order to determine which accelerator best meets the needs of the Guard, the following exemplary criteria can be used for evaluation:

• • [0597] Performance—Support hundreds of simultaneous sessions
  • [0598] Support—Sold by a vendor that provides timely technical support, driver updates, and new firmware releases
  • [0599] Algorithm support—AES, 1024-bit RSA (1024-bit), and SHA-256
  • [0600] Extensible—Programmable or firmware-upgradeable to support new algorithms in the future (e.g., Suite B algorithms)
  • [0601] Price—A price point that supports numerous Guard and Translator instances.

[0602] The following table shows exemplary cryptographic accelerators:

[0603]

Authentication Subsystem - Candidate Cryptographic Accelerator Cards
Card	Vendor	Features	Notes
ProtectServer	Eracom	RSA (4096-bit), DSA, DH, AES,	Tamper-resistant
Orange		3DES, IDEA, CAST-128, RC2,	FIPS 140-1 level 3
		RC4, RNG, HMAC	Linux support
nForce PCI	nCipher	RSA/DSA (1024-bit, maybe	FIPS 140-2 level 2
1600		more?), DH, 3DES, CAST,	Linux support
		AES-Rijndael, ARC4	Suite B supported with
			firmware update
S2010 PCI-X	Corrent	RSA (1024-bit), DH, HMAC,	OpenSSL support
accelerator		RNG, 3DES, AES	PCI-X slot required
			Linux support
Nitrox XL	Cavium	RSA/DSA (1024-bit), DH, RNG,	OpenSSL supported
NPB	Networks	3DES, AES	w/Cavium's TurboSSL
Accelerator			mods
(CN1230-			Linux support
350-NBP)

[0604] Data Sequence Diagrams

[0605] In this embodiment, the TLS protocol and VDP authentication may both have complicated handshakes. This section presents the interactions between the Guard subsystems and the operations in the TLS protocol.

[0606] In this embodiment, the TLS protocol may allow for either the creation of new TLS sessions or the resumption of old sessions. During session creation, both sides can exchange keys, perform mutual authentication, and negotiate the cipher suite (encryption and hashing algorithms) that both sides use to protect communications. Client authentication in TLS may be optional, and one embodiment of CAB may not support Client TLS authentication to the Guard.

[0607] In one embodiment, the Client may not supply a certificate to the Guard, as no PKI infrastructure may exist for verifying the certificate. In another embodiment, however, the Client can use its certificate to authenticate to the Guard. FIG. 20 shows a TLS Handshake protocol sequence.

[0608] In one embodiment, Client authentication would take place after the Client sends its certificate to the Guard. The Guard would first check to see that the Client's certificate was properly signed by a valid certificate authority. Next, the Client would sign a hash of all TLS handshake messages sent up to that point, and then send that signature to the Guard. Using the certificate supplied by the Client, the Guard would verify the signature. If the signature fails verification, the Guard would not proceed with the connection, and a message is logged to the audit subsystem.

[0609] In this embodiment, TLS supports session resumption, which would permit the Client to reconnect to the Guard using a previously used session ID. If the Guard supports this capability, it is recommended that session IDs have a short life span, so as to limit the time period in which a session may be resumed. FIG. 21 presents the TLS Handshake session resumption sequence.

[0610] An example of the overall process of authenticating a Client user for one embodiment is presented in FIG. 22. There may be two parts to Client authentication: TLS and user. For one embodiment, the Guard utilizes the user's ID and password for authentication. Other embodiments may use other authentication mechanisms, such as PKI and biometric data, for example.

[0611] Interfaces

[0612] In this embodiment, the Authentication Subsystem may consists of multiple subcomponents that communicate internally and externally. Examples of subcomponents and their message flow are presented in the table below:

[0613]

Authentication Process - Interfaces
Subcomponent	Messages From	Message To
High-Side TLS	High-Side Interface	High-Side Interface Listener
Authentication	Listener
Low-Side TLS	Low-Side Interface	Low-Side Interface Listener
Authentication	Listener
High-Side User	User Preferences,	User Preferences (reply), High-
Authentication	High-Side	Side VDP Forwarder, High/Low
	VDP Router	User Mapper
Low-Side User	High/Low User	Low-Side VDP Forwarder
Authentication	Mapper
High/Low User	High-Side User	Low-Side User Authentication
Mapper	Authentication

[0614] In this embodiment, the multi-step authentication process may consist of multiple message flows internal to the Guard. Once a high-side user has authenticated to the Guard, messages may be sent to each of the Guard components to notify them that the user has successfully authenticated.

[0615] In one embodiment, for complete authentication, it is preferably that a user's desired preferences are compatible with the user's assigned profile. Once the high-side user has valid selected settings (screen resolution, color depth, etc.), the High-Side User Authentication subcomponent stores these preferences in the User Preferences subcomponent for subsequent logons. Next, the High-Side User Authentication subsystem sends a “new session established” message with the user preferences to the High-Side VDP Forwarder, which, in turn forwards the message on to the High-Side Interface Listener.

[0616] In one embodiment, the High-side Interface Listener sends a VDP session-initiated message to the Client, which waits for final VDP traffic from the Translator (by way of the Guard). The Listener also forwards the “new session established” message to the High-Side VDP Router, and then on to each of the inspection engines (Dirty Word Search, Keyboard Filter, and Mouse Filter). The message continues to the Low-Side VDP Forwarder, Low-Side Interface Listener, then to the Low-Side inspection engines (Image). Once all subcomponents are ready for the new session, as communicated by the round-robin IPC internal to the Guard, the final stage of session initialization occurs.

[0617] In one embodiment, the High-Side Authentication subcomponent sends a message to the High/Low Mapper. The Mapper forwards a message to the Low-Side Authentication subcomponent, which crafts a VDP packet consisting of the low-side user ID and password. The VDP packet is forwarded to the Low-Side VDP Forwarder. The Forwarder sends the packet to the Low-Side Interface Listener, which initiates the TLS connection with the Translator.

[0618] Inspection and Filter Subcomponents

[0619] Common Inspection Engine Framework

[0620] In one embodiment, the CAB Guard employs a small set of individual filter subcomponents, each designed to inspect a specific type of VDP content: mouse events, keyboard events, and image-related content. While each filter specializes in its intended content, they share a set of core functionality. To provide efficient development, system-wide interoperability, each filter may use the Common Inspection Engine Framework. Common operations such as threading, audit event generation, and heartbeat monitoring are handled by the framework.

[0621] Design Decisions and Considerations

[0622] Interface-Related Design Considerations

[0623] In this embodiment, the Common Inspection Framework may provide the shell for inspection functions. In one embodiment, it receives control and data messages from the VDP Router and sends control and data messages to the VDP Forwarder. It hides these and other details from the inspection engine algorithms, permitting the inspection developer to focus on the inspection algorithms.

[0624] Performance-Related Design Considerations

[0625] In this embodiment, the Common Inspection Framework may provide a high-performance invocation mechanism for inspection algorithms. It maintains dedicated reader and writer threads to reduce IO latency between external subsystems and a pool of worker threads through which actual inspection occurs. Because performance characteristics are difficult to deduce during design, the interface is flexible to hide threading details from inspection functions. By using thread pools, there is opportunity to tune the inspection engines based on empirical analysis.

[0626] Security and Privacy Related Design Considerations

[0627] In this embodiment, the Common Inspection Framework may be designed to enable each inspection engine to operate in a separate process, supporting the principle of minimality. It uses the Session Management elements to maintain session separation. When an inspection function indicates there is at least one inspection violation (a function could observe multiple violations), the framework can block the violating traffic, if policy dictates for that session. It may also generate an audit event for each violation.

[0628] Flexibility, Availability, and Maintainability Design Considerations

[0629] In this embodiment, the Common Inspection Framework may be designed to be flexible. It provides a rich and straightforward interface for inspection engines, so that new inspection engines can tap the auditing, threading, and session management capabilities already developed.

[0630] Subcomponent Details

[0631] IInspectionEngine

[0632] In one embodiment, IInspectionEngine defines the interface that inspection engines must implement in order to be invoked by the Common Inspection Framework.

[0633] InspectionMgr

[0634] In this embodiment, the InspectionMgr may coordinate the Common Inspection Framework activity. It maintains and reads data and control traffic from the VDP Router invokes the inspection engine, via IInspectionEngine, logs events, and blocks or forwards traffic to the VDP Forwarder.

[0635] Administration

[0636] In this embodiment, the Common Inspection Framework may be administered via configuration files. The configuration parameters include thread pool tuning parameters, engine name, and the identifiers for the VDP Router and Forwarder (to specify high or low).

[0637] Dirty Word Search Filter

[0638] In one embodiment, the Dirty Word Search (DWS) component inspects character-oriented input to identify words that should not be disseminated from high to low to domains. The Dirty Word Search is like other inspection components in that it preferably uses some kind of overall user session state to validate a specific keyboard event. It may plug into the overall Inspection Engine Framework. Issues such as threading, event generation, and heartbeat monitoring may be handled by the framework.

[0639] One embodiment of Dirty Word Search performs a naïve inspection of session characters, using a modified Aho-Corasick text matching algorithm. If a dirty word is detected, then the packet can be discarded. Because actual packet discarding is a policy-driven aspect, the Dirty Word Search does not actually drop a packet, per se; it merely signals that an event has occurred.

[0640] Design Decisions and Considerations

[0641] Decision to Develop or Reuse

[0642] In this embodiment, the Dirty Word Search component can reuse the Inspection, Session Management, Process/Threading Framework, and Transaction Processing components developed for the Guard. Its design may reuse elements of research-validated keyword-matching algorithms based on the seminal Aho-Corasick paper.

[0643] Component Design Decisions

[0644] In one embodiment, the Dirty Word Search component reflects object-oriented analysis and design methodology on a procedural C programming language platform. An object-oriented approach facilitates reuse and future-proofs. The State Machine and Flyweight design patterns may be employed.

[0645] Interface-Related Design Considerations

[0646] In this embodiment, the Dirty Word Search component may have minimal interface-related concerns. Because it is an inspection component, it may behave similarly to other inspection components, to facilitate administration and development. The Dirty Word Search component, by way of the Inspection Engine, generates Audit messages that comply with the Audit format, uses configuration files that comply with the Configuration File component and implements the necessary interfaces to work in the Inspection Engine framework.

[0647] Performance-Related Design Considerations

[0648] In this embodiment, the Dirty Word Search component may be designed so that it has no discernable impact on user response time. Therefore, it may use an efficient optimization of the Aho-Corasick multiple-pattern-matching algorithm, optimized for single-octet languages.

[0649] One embodiment could support full Unicode UTF-32, quad-octet encodings by using a pattern matching algorithm akin to those used in anti-virus scanners. Dictionary representation is separated from session state to allow that multiple user sessions could share the same dictionary. Because real-world performance bottlenecks are often not understood until code is tested, the design can make use of loose-coupling, including the separation of the algorithm from overall inspection engine. Loose coupling facilitates performance tuning by enabling new, better implementations of components to be introduced.

[0650] Safety, Security, and Privacy Design Considerations

[0651] In one embodiment, the Dirty Word Search component carries out a single-context per-character inspection method—multiple character strings are treated as successive single-character events. As with other Guard applications, the Dirty Word Search may execute in a separate domain. It may have one-way input for character events, one-way decision output to indicate success or failure, and IPC interfaces with various supporting system components, such as the Audit and Initialization components. Exemplary security issues may include:

• • [0652] Complete detection of dirty words in the context of a single application session without factoring mouse cursor movement.
  • [0653] Integration with Guard components to ensure consistent response to security-relevant events.
  • [0654] Accurate detection of dirty words when a clean word is possible (e.g., suppose “secret” is dirty and “secretary” is not; it would not be possible to determine a clean word is present until an “a” is sent—long after “secret” might be sent).
  • [0655] Provision for detecting simple substitutions, in which the substituted character maps to one other character (e.g., the number zero for the letter “o”).

[0656] Flexibility, Availability, and Maintainability Design Considerations

[0657] One embodiment of the Dirty Word Search component preferably supports multiple languages, each with its own search algorithm. Unicode enables the representation of any widespread written language, represented by up to four bytes. Efficient Aho-Corasick implementations rely on constant-time lookup of node transitions, which in Unicode could potentially include 2³² possibilities. Because the original Aho-Corasick design calls for single-character nodes, its tree structure is preferably modified because of scalability problems. Instead a “trie” structure may be used. A trie does not represent every transition with a new node. Rather, multiple transitions can point to the same node, reducing memory footprint.

[0658] In this embodiment, to support multiple algorithms, the algorithm may be implemented as a separable module, upgradeable at system patch time.

[0659] Subcomponent Details

[0660] In this embodiment, highlights of the assumptions of the Dirty Word Search, separate from the core implementation of the Aho-Corasick algorithm variant: can include:

• • [0661] A dirty word results in a security event unless a clean word immediately follows.
  • [0662] An entire clean word is preferably consumed in order for a security event not to be triggered.
  • [0663] Policy blocks result in a termination state.

[0664] In this embodiment, given these assumptions, there are states to distinguish between a dirty word's detection and session termination.

[0665] RuntimeDictionary

[0666] In one embodiment, the RuntimeDictionary is a state machine representation of all dirty and clean words in the dictionary. States are represented by a CharacterState object. Because a single Unicode character could be one of 2³² values, it is not feasible to store all transitions in a 2³²-element array. Therefore, a word may be represented as a sequence of bytes. The two bytes indicate transitions to other states; subsequent bytes are preferably matched from a linked list.

[0667] CharacterNode

[0668] In this embodiment, a CharacterNode can represent a state of the RuntimeDictionary. It contains the first byte of the Unicode representation, transitions to other CharacterNode states, and a flag indicating a dirty word match.

[0669] SessionCharacterProcessor

[0670] In this embodiment, the SessionCharacterProcessor object may store the state needed to capture character-oriented entry of words and processes characters. A purpose is to invoke state transitions in the RuntimeDictionary. It maintains a stack of characters entered by the user, to access previous state when a backspace is pressed and a reference to the CharacterState used in the search algorithm state machine.

[0671] DictionaryReader

[0672] In this embodiment, the DictionaryReader may use the Configuration component to read and update the RuntimeDictionary.

[0673] DirtyWordSearchEngine

[0674] In this embodiment, the DirtyWordSearchEngine may be a simple function that extracts the character or string data from part of the VDP packet and passes it to the SessionCharacterProcessor for evaluation.

[0675] SubstitutionCode

[0676] In this embodiment, a SubstitutionCode uniquely substitutes for another character, such as “3” for “e,” or identifies a command, such as backspace or left-cursor movement.

[0677] Administration

[0678] In this embodiment, Administration of this component may be accomplished through the system's configuration files. The Guard Policy Administrator—or possibly a more specific Dirty Word Search Policy Administrator—creates and modifies policies governing the behavior of components on the Guard, including the Dirty Word Search Filter. The Policy Administrator, therefore, controls the policy-specific configuration items, such as the dirty word and clean word lists. The Policy Administrator can also control auditing behavior and resource allocation related to the filter, and can determine the responses of the filter to suspicious events. The capabilities of Policy Administrator may be tightly controlled, and should be assumed by a properly trained individual.

[0679] Interfaces

[0680] In this embodiment, within the Guard system component, the Dirty Word Search Filter process will interface with several other subcomponents. The table below provides a description of some exemplary interfaces:

[0681]

DWS Filter - Internal Guard Interfaces
Subcomponent	Interface Description
High-Side VDP	This subcomponent receives information from the High-Side VDP
Router	Router, via the common Wire Protocol. The bulk of the data received
	consists of VDP character events; however, configuration and session
	setup information is also received over the same channel. This is one-way
	communication.
Low-Side VDP	This subcomponent sends information to the Low-Side VDP Forwarder,
Forwarder	via the common Wire Protocol. The bulk of the data sent consists of VDP
	character events; however, configuration and session setup information is
	also sent over the same channel. This is one-way communication.
Initialization	The Initialization Process launches this subcomponent, using an ‘exec’
Process	call. No communications are established between this subcomponent and
	the Initialization Process.
Configuration	This subcomponent reads configuration information from the
	Administration and Configuration subcomponent, using the interfaces
	provided by the Administration and Configuration subcomponent. This is
	one-way communication.
Heartbeat	Upon execution, this subcomponent utilizes the common Wire Protocol to
Monitor	provide regular heartbeat messages to the heartbeat monitor. This is one-
	way communication.
Shutdown	Upon execution, this subcomponent registers with the Shutdown Process,
Process	using the common Wire Protocol. Once registered, the heartbeat monitor
	listens for shutdown commands from the shutdown process. This is one-
	way communication.
Audit	This subcomponent sends audit messages directly to the Audit
	subcomponent, using the common Wire Protocol. This is one-way
	communication.

[0682] Keyboard Filter

[0683] In one embodiment, the Keyboard Filter inspects VDP keyboard data to ensure that keystroke messages are consistent with the acceptable use of a keyboard by a client application. It is preferably to distinguish its behavior from that of the Dirty Word Search component, which processes text character events—a higher level of abstraction.

[0684] In this embodiment, the Keyboard Filter may be like other inspection components in that it preferably uses some kind of overall user session state to validate specific events. To provide this, the Keyboard Filter can plug into the Common Inspection Engine Framework. Like other Inspection and Filter components, the Keyboard Filter can employ individual session states for each user.

[0685] One embodiment of Keyboard Filter performs token bucket rate limiting. If an average or burst threshold is reached, the token, a keystroke, is discarded. In the context of keyboard inspection, discarding means the generation of a security event and potential packet discarding. Because actual packet discarding is a policy-driven aspect, the Keyboard Inspector does not actually drop a packet, per se; it merely creates an error object that the Inspection Engine Manager processes. The Inspection Engine Manager, in turn signals that an event has occurred.

[0686] In this embodiment, an exemplary Keyboard Inspector workflow for keyboard inspection may be as follows:

• • [0687] A scan code arrives. Keyboard Filter retrieves scan code history.
  • [0688] The new scan code is added to the history, with a fresh timestamp.
  • [0689] The token bucket rate-limiter algorithm is applied to determine if an excessive keystroke threshold has been reached.
  • [0690] Update the session's status, by adding to the Keyboard Filter's custom status data, and return the result to the Inspection Engine Manager.

[0691] Design Decisions and Considerations

[0692] Decision to Develop or Reuse

[0693] In this embodiment, the Keyboard Filter may reuse the Inspection, Session Management, Process/Threading Framework, and Transaction Processing components developed for the Guard. Its design may reuse the token bucket rate limiter algorithm.

[0694] Component Design Decisions

[0695] In this embodiment, the Keyboard Filter may reflect object-oriented analysis and design methodology. An object-oriented approach facilitates reuse and future-proofs many design decisions that cannot be determined during the initial design activities. The Flyweight design pattern may be employed.

[0696] Interface-Related Design Considerations

[0697] In this embodiment, the Keyboard Filter may have minimal interface-related concerns. Because it is an inspection component, it may behave similarly to other inspection components to facilitate administration and development. In one embodiment, the Keyboard Filter, by way of the Inspection Engine, generates Audit messages that comply with the Audit format, uses configuration files that comply with the Configuration File component, and implements the necessary interfaces to work in the Inspection Engine framework.

[0698] Performance-Related Design Considerations

[0699] In this embodiment, the Keyboard Filter component may be designed so that it has no discernable impact on user response time. It may provide administrator-tunable rate limits. Because real-world performance bottlenecks are often not understood until code is tested, the design can make use of loose coupling, including the separation of the algorithm from the overall inspection engine. Loose coupling facilitates performance tuning by enabling new, better implementations of components and to be introduced.

[0700] Database Design Considerations

[0701] In this embodiment, this component may have no database design considerations. The keyboard layout may be simple enough to be defined in a static file.

[0702] Safety, Security, and Privacy Design Considerations

[0703] In one embodiment, the Keyboard Filter component carries out a single-keystroke inspection method—multiple keystrokes in a message are represented as multiple invocations of the algorithm. In one embodiment, keyboard switching within a session may not be supported in the Keyboard Filter. As with other Guard applications, the Keyboard Filter may execute in a separate domain. It may have a one-way input for scan code events, one-way decision output to indicate success or failure, and IPC interfaces with various supporting system components, such as the Audit and Initialization components. Exemplary security issues include:

• • [0704] Detection of unsupported scan codes
  • [0705] Detection of excessive average and burst typing rates
  • [0706] Integration with Guard components to ensure consistent response to security-relevant events.

[0707] Flexibility, Availability, and Maintainability Design Considerations

[0708] In one embodiment, the Keyboard Filter preferably supports multiple keyboards. It is preferably extensible to support additional inspection algorithms with minimal impact to design.

[0709] Subcomponent Details

[0710] KeyPress

[0711] In one embodiment, the Keypress object stores the keyboard scan code and timestamp. In one embodiment, the Keyboard Inspector preferably only identifies typing-rate anomalies. Therefore, it need only have a queue of timestamps. However, for diagnostic purposes, it is useful to have the scan code as well, such as logging the first keystroke that occurred in an anomaly.

[0712] KeyboardState

[0713] In one embodiment, the KeyboardState object maintains the state necessary to conduct keystroke anomaly detection, including the active keyboard and the queue of Keypress objects.

[0714] KeyboardConfig

[0715] In one embodiment, a KeyboardConfig maintains the keyboard configuration parameters. Because multiple sessions might use the same kind of keyboard, the read-only KeyboardConfig is shared across sessions

[0716] KeyboardReader

[0717] In one embodiment, the KeyboardReader uses the Configuration component to read and update the RuntimeDictionary.

[0718] KeyboardInspector

[0719] In one embodiment, the KeyboardInspector is a simple function that extracts the scan code from the VDP packet and passes it to the KeyboardConfig for evaluation.

[0720] Administration

[0721] In this embodiment, administration of this component can be accomplished through the system's configuration files. The Guard Policy Administrator—or possibly a more specific Keyboard Policy Administrator—creates and modifies policies governing the behavior of components on the Guard, including the Keyboard Filter. The Policy Administrator, therefore, controls the policy-specific configuration items, such as the keyboard layout, scan codes, and permissible typing rate in one embodiment. The Policy Administrator can also control auditing behavior and resource allocation related to the filter, and can determine the responses of the filter to suspicious events. The capabilities of Policy Administrator may be tightly controlled, and should only be assumed by a properly trained individual.

[0722] Interfaces

[0723] In this embodiment, within the Guard system component, the Keyboard Filter process may interface with several other subcomponents. The table below provides a description of exemplary interfaces:

[0724]

Keyboard Filter - Internal Guard Interfaces
Subcomponent	Interface Description
High-Side VDP	This subcomponent receives information from the High-Side VDP
Router	Router, via the common Wire Protocol. The bulk of the data received
	consists of VDP keyboard events; however, configuration and session
	setup information is also received over the same channel. This is one-way
	communication.
Low-Side VDP	This subcomponent sends information to the Low-Side VDP Forwarder,
Forwarder	via the common Wire Protocol. The bulk of the data sent consists of VDP
	keyboard events; however, configuration and session setup information is
	also sent over the same channel. This is one-way communication.
Initialization	The Initialization Process launches this subcomponent, using an ‘exec’
Process	call. No communications are established between this subcomponent and
	the Initialization Process.
Configuration	This subcomponent reads configuration information from the
	Administration and Configuration subcomponent, using the interfaces
	provided by the Administration and Configuration subcomponent. This is
	one-way communication.
Heartbeat	Upon execution, this subcomponent utilizes the common Wire Protocol to
Monitor	provide regular heartbeat messages to the heartbeat monitor. This is one-
	way communication.
Shutdown	Upon execution, this subcomponent registers with the Shutdown Process,
Process	using the common Wire Protocol. Once registered, the heartbeat monitor
	listens for shutdown commands from the shutdown process. This is one-
	way communication.
Audit	This subcomponent sends audit messages directly to the Audit
	subcomponent, using the common Wire Protocol. This is one-way
	communication.

[0725] Mouse Filter

[0726] In one embodiment, a purpose of the mouse filter subcomponent is to take mouse events associated with a given session and perform a set of inspections to verify that those events do not contain any anomalies that might adversely affect the Terminal Server or the Client. These inspections will be largely transparent to the Client user.

[0727] In this embodiment, the Mouse Filter may be like other filtering subcomponents in that it preferably uses some kind of overall user session state to validate specific events. To provide this, the Mouse Filter may plug into the Common Inspection Engine Framework.

[0728] Design Decisions and Considerations

[0729] Decision to Develop or Reuse

[0730] In this embodiment, much of the Mouse Filter's functionality may be virtually identical to that of other filter components (such as the image filter subcomponent, etc.). This will permit the reuse of certain features, such as the following:

• • [0731] State table and connection information storage
  • [0732] Auditing and blocking mechanisms
  • [0733] Inbound and outbound IPC mechanisms for transporting VDP data and internal control messages
  • [0734] Rate limiting and prioritization of data on a per-user basis.

[0735] In this embodiment, the Common Inspection Engine Framework may be employed as a wrapper for the Mouse Filter. The wrapper may handle those functions that are required by inspection engines, while leaving the Mouse Filter engine to focus on inspecting mouse events.

[0736] Component Design Decisions

[0737] In this embodiment, several factors affect the design of the Mouse Filter subcomponent, including:

• • [0738] The need for protection between the low-side and high-side domains (via inspection, tightly controlled data flows, etc.)
  • [0739] The ability to understand the format of VDP mouse packets
  • [0740] The ability to differentiate mouse events associated with different sessions and users, and to perform the appropriate actions on that data.

[0741] Interface-Related Design Considerations

[0742] In this embodiment, the Mouse Filter subcomponent may employ CAB's common Wire Protocol and IPC mechanism for receiving data from the High-Side VDP router, and sending data on to the Low-Side VDP Packetizer. In addition, these IPC mechanisms may be used for transmitting control information, such as session IDs, packet IDs, and session state. The Mouse Filter subcomponent may also use the common IPC mechanism to communicate with the Audit subsystem. Utilizing SELinux enforcement of the IPC mechanisms canl ensure that the direction of data flows is strictly controlled, and that data can cross the domain boundary in a tightly controlled fashion.

[0743] Performance-Related Design Considerations

[0744] In this embodiment, the transmission of mouse events may consume very little bandwidth, compared to image or sound data, so performance may not be as large a concern as it is with image or sound data. On the other hand, a major portion of the user's experience is directly affected by how fast user input events are sent through the Guard and system. Thus, mouse input events are preferably processed as efficiently and quickly as possible to ensure that there is no lag between user input and the resulting visual response.

[0745] Database Design Considerations

[0746] In this embodiment, the Mouse Filter subcomponent may not require a database to store connection information. Instead, it may maintain a connection table containing relevant information about each connection (session ID, user ID, session state, screen size, etc.) in memory.

[0747] In this embodiment, the Mouse Filter subcomponent may require access to policy information in order to determine how to handle anomalies. Policy information may be obtained via the Administration and Configuration subcomponents. Based on policy settings, the Mouse Filter may block and/or log certain types of anomalies. One embodiment of the filter may also need to identify patterns in mouse movements in order to detect side channel communications (e.g. the Ouija board scenario, etc.). The mouse inspection component may also provide fine-grained control over throughput, in order to give preference to certain users over others.

[0748] Safety, Security, and Privacy Design Considerations

[0749] In this embodiment, the Mouse Filter subcomponent may reside in its own security domain. SELinux may ensure that data can only be read in from the IPC shared with the high-side VDP Router. Similarly, data may only be written to the IPCs shared with the low-side VDP Packetizer and the Audit component. This may prevent data flows from moving in unintended directions, thereby tightly mediating the interactions between the high-side and low-side domains.

[0750] Flexibility, Availability, and Maintainability Design Considerations

[0751] In this embodiment, the Mouse Filter subcomponent may support availability by generating a “heartbeat” at regular intervals, allowing the Heartbeat Monitor subcomponent to monitor overall system health. If the Mouse Filter subcomponent dies or enters an illegal state, the heartbeat should cease, thereby indicating a serious problem to the heartbeat monitor.

[0752] Subcomponent Details

[0753] In this embodiment, the Mouse Filter subcomponent may consist primarily of a mouse filter engine, and the Common Inspection Engine Framework wrapper. The mouse filter engine may contain a pool of threads that will perform the actual inspection of mouse events, which should allow higher throughput. The wrapper will handle functions common to all filters (IPC communications, session data management, VDP library functions, etc.), and may be reusable. The wrapper may consist of a number of threads in order to perform its tasks. For example, the wrapper may include reader and writer threads for IPC communications, a heartbeat thread for system health monitoring, etc.

[0754] In this embodiment, VDP packets containing mouse event data may be forwarded on to the mouse filter engine, along with information about the connection (session ID, etc.). The mouse filter engine may be responsible for inspecting the following types of events:

• • [0755] Mouse movement events
  • [0756] Drag-and-drop events
  • [0757] Scroll wheel events
  • [0758] Raw mouse button press-and-release events
  • [0759] Interpreted mouse click events (single, double, and triple clicks).

[0760] In this embodiment, in order to perform these operations, the mouse filter engine may need to be able to parse VDP data to identify the mouse event to be inspected, and thus the type of inspection to be performed. The mouse filter engine may then analyze the event, and determine whether the data passes or fails inspection. Note that proper analysis of some events may depend on session-specific settings like screen size. In essence, the mouse filter engine will be checking for improper field lengths, invalid values, illegal coordinates, etc.

[0761] In this embodiment, in addition to format and data validation, the mouse filter engine may need to do basic anomaly detection. Anomalies that are preferably detected by the mouse filter engine include:

• • [0762] Mouse coordinates out of the range of the screen
  • [0763] Mouse movements that exceed the threshold regulating event frequency or mouse movement speed
  • [0764] Mouse movement packets received when movement is disabled
  • [0765] Mouse click and scroll packets received when unsupported or disabled (Scrolling and third mouse button are optionally supported)
  • [0766] Mouse click packets received in the wrong input mode:
    • [0767] Raw mode supports generic press and release click events
    • [0768] Interpreted mode supports client detected single, double, and triple click events.

[0769] In this embodiment, if an event passes all checks, it may then be passed to the low-side VDP Forwarder. Otherwise, the Mouse Filter may notify the Audit subsystem of the failure, and then use the current policy to determine whether to pass the offending mouse event. The Audit subsystem may be responsible for coordinating additional actions, such as closing down the current session or locking out the user.

[0770] Administration

[0771] In this embodiment, the Guard Policy Administrator can create and modify policies governing the behavior of components on the Guard, including the Mouse Filter. The Policy Administrator can thereby control auditing behavior and resource allocation, and can also determine the responses of the filter to suspicious events. The role of Policy Administrator may have limited abilities, and should preferably only be assumed by a highly vetted individual.

[0772] Interfaces

[0773] In this embodiment, within the Guard system component, the Mouse Filter may interface with several other subcomponents. The table below shows examples of these interfaces:

[0774]

Mouse Filter - Internal Guard Interfaces
Subcomponent	Interface Description
High-Side VDP	This subcomponent receives information from the High-Side VDP
Router	Router, via the common Wire Protocol. The bulk of the data received
	consists of VDP mouse events; however, configuration and session setup
	information is also received over the same channel. This is one-way
	communication.
Low-Side VDP	This subcomponent sends information to the Low-Side VDP Forwarder,
Forwarder	via the common Wire Protocol. The bulk of the data sent consists of VDP
	mouse events; however, configuration and session setup information is
	also sent over the same channel. This is one-way communication.
Initialization	This Initialization Process launches this subcomponent, using an ‘exec’
Process	call. No communications are established between this subcomponent and
	the Initialization Process.
Configuration	This subcomponent reads configuration information from the
	Administration and Configuration subcomponent, using the interfaces
	provided by the Administration and Configuration subcomponent. This is
	one-way communication.
Heartbeat	Upon execution, this subcomponent utilizes the common Wire Protocol to
Monitor	provide regular heartbeat messages to the heartbeat monitor. This is one-
	way communication.
Shutdown	Upon execution, this subcomponent registers with the Shutdown Process,
Process	using the common Wire Protocol. Once registered, the heartbeat monitor
	listens for shutdown commands from the shutdown process. This is one-
	way communication.
Audit	This subcomponent sends audit messages directly to the Audit
	subcomponent, using the common Wire Protocol. This is one-way
	communication.

[0775] Image Filter

[0776] In this embodiment, this section describes the elements in the CAB Guard that inspect image data and image-related operations that are sent from the low-side CAB Terminal Server to the high-side CAB Client. When image data is transmitted from the low-side Terminal Server, it is the responsibility of the Guard to ensure that such image data is properly formed, and will not pose any threat to the high-side Client. In one embodiment, the image inspection methodology will consist primarily of message format verification and field validation, which together ensure that no malformed or dangerous image data traverses the Guard. Other embodiments may offer more complex inspections, such as checking for the existence of steganographic content.

[0777] In this embodiment, the Image Filter subcomponent may be like other filter subcomponent in that it preferably uses some kind of overall user session state to validate specific events. To provide this, the Image Filter may plug into the Common Inspection Engine Framework.

[0778] Design Decisions and Considerations

[0779] Decision to Develop or Reuse

[0780] In this embodiment, much of the Image Filter subcomponent's functionality may be virtually identical to that of other inspection components (such as the Mouse Inspection subcomponent, etc.). This may permit the reuse of certain features, such as the following:

• • [0781] State table and connection information storage
  • [0782] Auditing and blocking mechanisms
  • [0783] Inbound and outbound IPC mechanisms for transporting VDP data and internal control messages
  • [0784] Rate limiting and prioritization of data on a per-user basis.

[0785] In this embodiment, the Common Inspection Engine Framework may be utilized as a wrapper for the Image Filter. The wrapper may handle those functions that are required by inspection engines, while leaving the Image Filter engine to focus on inspecting mouse events.

[0786] Component Design Decisions

[0787] In this embodiment, several factors may affect the design of the Image Filter subcomponent, including:

• • [0788] The need for protections between the low-side and high-side domains (via inspection, tightly controlled data flows, etc.)
  • [0789] The need for the rapid inspection of large quantities of image data and operations
  • [0790] The ability to understand VDP drawing commands and caching requests that contain bitmaps defined by Common Image Format (CIF)
  • [0791] The ability to differentiate data associated with different sessions and users, and to perform the appropriate actions on that data.

[0792] Interface-Related Design Considerations

[0793] In this embodiment, the Image Filter subcomponent may employ CAB's common Wire Protocol and IPC mechanism for receiving data from the High-Side VDP router, and sending data on to the Low-Side VDP Packetizer. In addition, these IPC mechanisms may be used for transmitting control information, such as session IDs, packet IDs, and session state. The Image Filter subcomponent may also utilize the common IPC mechanism to communicate with the Audit subsystem. Utilizing SELinux enforcement of the IPC mechanisms may ensure that the direction of data flows is controlled, and that data can preferably only cross the domain boundary in a tightly controlled fashion.

[0794] Performance-Related Design Considerations

[0795] In this embodiment, performance may be a consideration for the Image Filter subcomponent, considering the quantities of data that it will be required to handle. For this reason, the Image Filter may require a variety of optimization techniques, including loop unrolling, inline assembly, efficient branching, caching, etc.

[0796] Database Design Considerations

[0797] In this embodiment, the Image Filter subcomponent may not require a database to store connection information. Instead, it may maintain a connection table containing relevant information about each connection (session ID, user ID, session state, client screen resolution and color depth, etc.) in memory.

[0798] In this embodiment, the Image Filter subcomponent may require access to policy information in order to determine how to handle anomalies. Policy information may be obtained via the Administration and Configuration subcomponents. Based on policy settings, the Image Filter may block and/or log certain types of anomalies. One embodiment of the filter may also provide fine-grained control over throughput, in order to give preference to certain users over others.

[0799] Safety, Security, and Privacy Design Considerations

[0800] In this embodiment, the Image Filter subcomponent may reside in its own security domain. SELinux may ensure that data can only be read in from the IPC shared with the high-side VDP Router. Similarly, data may be written to the IPCs shared with the low-side VDP Packetizer and the Audit component. This may prevent data flows from moving in unintended directions, thereby tightly mediating the interactions between the high-side and low-side domains.

[0801] Flexibility, Availability, and Maintainability Design Considerations

[0802] In this embodiment, the Image Filter subcomponent may support availability by generating a “heartbeat” at regular intervals, allowing the Heartbeat Monitor subcomponent to monitor overall system health. If the Image Filter subcomponent dies or enters an illegal state, the heartbeat should preferably cease, thereby indicating a serious problem to the heartbeat monitor.

[0803] Subcomponent Details

[0804] In this embodiment, the Image Filter subcomponent may consist primarily of an image filter engine, and the Common Inspection Engine Framework wrapper. The image filter engine may contain a pool of threads that can perform the actual inspection of image data and operations, while the wrapper will handle functions common to all filters (IPC communications, session data management, VDP library functions, etc.). Note that the image filter engine may be replicated into a number of separate threads in order to increase throughput.

[0805] In this embodiment, VDP packets containing image data and operations may be forwarded on to the image filter engine, along with information about the connection (session ID, etc.) It may be preferable for the Image Filter subcomponent to maintain some state about sessions for the purposes of auditing and/or blocking traffic associated with a given user or session. The image filter engine may be responsible for inspecting the following exemplary VDP drawing commands and operations:

• • [0806] Raw image data in VDP CIF; this includes 8-, 15-, 16-, and 24-bit images
  • [0807] Palette updates
  • [0808] Cursor updates
  • [0809] CIF clear and pattern clear operations
  • [0810] Screen copy operations
  • [0811] Cache copy operations
  • [0812] Cached cursor draw operations
  • [0813] Cached text draw operations
  • [0814] Various other cache operations, including cursor cache, screen cache, bitmap cache, and font cache operations.

[0815] In this embodiment, in addition to basic format and anomaly detection, the image filter engine preferably ensures that any packets it receives are valid for the current session's capabilities. Each user session may permit some subset of drawing commands, caching operations, and parameters (i.e., screen size). If any packets are received containing operations or parameters that are not supported by the capability set, the image filter preferably takes appropriate action. Actions may include dropping the packet and logging an audit event for the occurrence.

[0816] In this embodiment, in order to perform these operations, the image filter engine may need to be able to parse VDP data to identify the type of data to be inspected, and thus the type of inspection to be performed. The image filter engine may then inspect the data, and determine whether the data passes or fails inspection. The image filter engine may, for example, be checking for:

• • [0817] Sizes or coordinates out of the range of the screen
  • [0818] Color depths other than that expected for the current session
  • [0819] Improperly formatted VDP packets
  • [0820] Parameters with improper lengths or invalid values
  • [0821] Caching indexes that do not correspond to valid cache entries
  • [0822] Unsupported or invalid caching operations.

[0823] In this embodiment, if the data passes all checks, it may then be passed to the high-side VDP Forwarder. Otherwise, the Image Filter may notify the Audit subsystem of the failure, and then use the current policy to determine whether to pass the offending event. The Audit subsystem may be responsible for coordinating additional actions, such as closing down the current session or locking out the user.

[0824] Administration

[0825] In this embodiment, the Guard Policy Administrator can create and modify policies governing the behavior of components on the Guard, including the Image Filter. The Policy Administrator can thereby control auditing behavior and resource allocation, and can also determine the responses of the filter to suspicious events or data. The role of Policy Administrator may have limited abilities, and preferably should be assumed by a highly vetted individual.

[0826] Interfaces

[0827] In this embodiment, within the Guard system component, the Image Filter may interface with several other subcomponents. The table below shows examples of these interfaces:

[0828]

Image Filter - Internal Guard Interfaces
Subcomponent	Interface Description
Low-Side VDP	This subcomponent receives information from the Low-Side VDP Router,
Router	via the common Wire Protocol. The bulk of the data received consists of
	VDP image data and operations; however, configuration and session setup
	information is also received over the same channel. This is one-way
	communication.
High-Side VDP	This subcomponent sends information to the High-Side VDP Forwarder,
Forwarder	via the common Wire Protocol. The bulk of the data sent consists of VDP
	image data and operations; however, configuration and session setup
	information is also sent over the same channel. This is one-way
	communication.
Initialization	Initialization Process launches this subcomponent, using an ‘exec’ call.
Process	No communications are established between this subcomponent and the
	Initialization Process.
Configuration	This subcomponent reads configuration information from the
	Administration and Configuration subcomponent, using the interfaces
	provided by the Administration and Configuration subcomponent. This is
	one-way communication.
Heartbeat	Upon execution, this subcomponent utilizes the common Wire Protocol to
Monitor	provide regular heartbeat messages to the heartbeat monitor. This is one-
	way communication.
Shutdown	Upon execution, this subcomponent registers with the Shutdown Process,
Process	using the common Wire Protocol. Once registered, the heartbeat monitor
	listens for shutdown commands from the shutdown process. This is one-
	way communication.
Audit	This subcomponent sends audit messages directly to the Audit
	subcomponent, using the common Wire Protocol. This is one-way
	communication.

[0829] Sound Filter

[0830] In one embodiment, CAB supports audio content transferred from the low-side Terminal Server to the high-side Client.

[0831] In one embodiment, the Sound Filter preferably ensures that such data is properly formed, and will not pose any threat to the high-side Client. In one embodiment, the audio inspection methodology may consist primarily of message format verification and field validation, which together may ensure that no malformed or dangerous audio data traverses the Guard.

[0832] In this embodiment, the Sound Filter subcomponent may be like other filter subcomponent in that it preferably maintains some kind of overall user session state to validate specific events. To provide this, the Sound Filter may plug into the Common Inspection Engine Framework.

[0833] VDP Communications Subsystem

[0834] In this embodiment, the VDP Communications Subsystem performs Guard routing and forwarding functions. It may consist of three subcomponents: the VDP Router, VDP Forwarder, and Session Management interface.

[0835] In one embodiment, the VDP Router receives VDP packets from the Network Listener and routes them to the next location. The VDP Forwarder receives VDP packets from Guard components and forwards them to the Network Listener for network transmission. There may be high and low VDP Routers and Forwarders. The VDP Router and Forwarder may be designed to perform fast routing of data between Guard components, while maintaining session coherency, session prioritization and one-way data flow policy.

[0836] In this embodiment, the Session Management interface may define the common operations used for synchronizing session information across the VDP Router, VDP Forwarder and other Guard components.

[0837] Design Decisions and Considerations

[0838] Decision to Develop or Reuse

[0839] In one embodiment, the VDP Communications component reuses the Process/Threading Framework, Wire Protocol, and Transaction Processing components developed for the Guard. It provides common interfaces so that other components can communicate with it.

[0840] Component Design Decisions

[0841] In one embodiment, the VDP Communications component reflects object-oriented analysis and design methodology on a procedural C programming language platform. An object-oriented approach may facilitate reuse and may future proof many design decisions that cannot be determined during the initial design activities. It may use the Bridge pattern to separate threading concerns and to support loose coupling with which it communicates with the components.

[0842] Interface-Related Design Considerations

[0843] In this embodiment, the VDP Communications Component may define interfaces for components in the inspection path. The interfaces may include sending and receiving from the Network Listener and inspection engines. In one embodiment, both packet flow and control interfaces may flow in a unidirectional manner, either strictly high-to-low or low-to-high, without direct feedback channels. The VDP Communications component may generate Audit messages that comply with the Audit format, uses configuration files that comply with the Configuration File component, and implements the necessary interfaces to work in the Inspection Engine framework.

[0844] Performance-Related Design Considerations

[0845] In this embodiment, the VDP Communications component may be designed so that it has no discernable impact on user response time with multiple simultaneous sessions. It may be designed so that different threading models can be employed. To reduce contention, lock-free algorithms may be employed for passing data across threads. Because real-world performance bottlenecks are often not understood until code is tested, the design may make heavy use of loose coupling, including the separation of IO from and packet verification and reordering processing. Loose coupling facilitates performance tuning by enabling new, better implementations of components to be introduced.

[0846] Safety, Security, and Privacy Design Considerations

[0847] In this embodiment, the VDP Communications Component may play a role in the one-way pipeline between Network Listeners of different levels. Packet data and control messages preferably flow in one direction. Exemplary flows are presented in the table below:

[0848]

VDP Communications Subcomponent Packet and Control Flow
VDP Communications Sub-
Component	Packet and Control from	Packet and Control to
High-Side VDP Router	High-Side Network Listener	Inspection Engines, High-
		Side Authenticator, Client
		Logger
Low-Side VDP Forwarder	Inspection Engines, Low-Side	Low-Side Network Listener
	Authenticator
Low-Side VDP Router	Low-Side Network Listener	Inspection Engines
High-Side VDP Forwarder	Inspection Engines, High-Side	High-Side Network Listener
	Authenticator, Event Manager
Session Management	Control from all session-	Control to all session-related
	related components	components.

[0849] Subcomponent Details

[0850] In this embodiment, the VDP Communications subsystem may consist of three subcomponents: the VDP Router, VDP Forwarder and Session Management interface.

[0851] VDP Router

[0852] In one embodiment, the VDP Router executes core VDP protocol verification and routes the packets to the next Guard component for processing. The VDP Router receives packets from the Network Listener, which has preferably ensured that the VDP header is valid and that the packet has been read from the network. The VDP Router may use the VDP Reference Implementation to perform validation functions, to execute VDP protocol state transitions and to identify the type of VDP packet received. If validation succeeds, then the VDP Router forwards the packet to the next Guard component based on packet type.

[0853] In one embodiment, there may be two running instances of the VDP Router: high-side (client-receive) and low-side (translator-send). The high-side router forwards packets to the VDP Authenticator, high-to-low inspection engines, and the VDP Logger. The low-side router forwards packets to the low-to-high inspection engines.

[0854] VDPRouterServer

[0855] In this embodiment, the VDPRouterServer may receive packet and control IPC messages from the Network Listener. It places all packets in a per-session queue for inspection by the VDPVerifier. It may be a very small component to minimize IO latency with the Network Listener.

[0856] VDPRouterSessionState

[0857] In one embodiment, the VDPRouterSessionState may consist of common user session state and an additional inbound packet queue. The packet queue may assure that packets are assigned per-user sequence numbers in order of arrival at the Guard.

[0858] VDPVerifier

[0859] In one embodiment, the VDPVerifier performs VDP protocol verification and packet prioritization, sequencing, and routing. It can extract packets from the per-session queues in priority order. Once extracted, it can use the VDP Reference implementation to verify the packet and determine the packet's type. If the packet is valid, it is assigned the next sequence number.

[0860] In one embodiment, the VDPVerifier maintains a mapping of packet type to destination processor, i.e., the next Guard component to receive the packet for processing. Destinations may be managed by a configuration file. The VDPVerifier may queue the packet into the appropriate destination, using the prioritization associated with the user's session state.

[0861] In this embodiment, because there may be two running instances of the VDP Router, with different target components, there may be different configuration files and security policies that dictate the flow of communication.

[0862] VDPPacketProcessorClient

[0863] In one embodiment, the VDPPacketProcessorClient makes the IPC call to the packet processor, sending higher priority packets first.

[0864] VDP Forwarder

[0865] In one embodiment, the VDP Forwarder receives packets from the inspection engines and forwards them to the Network Listener for transmission across the network. Because session inspection is spread across processes, it preferably reorders the packets before they are transmitted. It may use a sequence number generated by the VDP Router.

[0866] In this embodiment, there may be two running instances of the VDP Forwarder: low-side (translator-send) and high-side (client-receive). The low-side forwarder may send packets to the low-side Network Listener. The high-side forwarder may send packets to the high-side Network Listener.

[0867] VDPReordererServer

[0868] In one embodiment, the VDPReordererServer receives IPC messages from Guard components that can forward a packet. It places packets in a per-session priority queue for reassembly.

[0869] VDPReorderer

[0870] In one embodiment, the VDPReorderer reads packets in sequence-number-order from the session priority queue and places them in an outbound packet queue for forwarding to the Network Listener.

[0871] VDPForwarderClient

[0872] In one embodiment, the VDPForwarderClient reads packets from the outbound packet queue and sends an IPC to the Network Listener.

[0873] Session Management

[0874] In one embodiment, the Session Management component may consist of an encapsulated in-process service for managing sessions. It processes control messages, defines interfaces for specialized control messages (e.g., “Notify Translator”) and provides extensible session state management.

[0875] SessionState

[0876] In this embodiment, a SessionState object may maintain core shared session state and provides extensibility for applications that need to store additional, local state (e.g., the Dirty Word Search stores a list of keystrokes on a per-session basis). It provides synchronization capabilities so that applications can have safe access to data. SessionState may be accessed through the SessionTable.

[0877] SessionTable

[0878] In this embodiment, a SessionTable may provide guarded access to SessionState. It hides the storage details of data, so that application writers do not need to worry about coding to a specific data structure API.

[0879] SessionManager

[0880] In this embodiment, a SessionManager may provide the core session control functions. It can receive session control messages from an IPC provided by the application using it. It may support additional session control IPCs by providing an interface to the SessionTable. The Session Manager may be essentially a lightweight service that receives control messages via IPC, performs local operations (i.e., initially add or remove a session), and forwards the request if the message has been received for the first time.

[0881] INotifyTranslator

[0882] In this embodiment, an INotifyTranslator interface may define the message sent in final-stage session initiation. It may use the IPC provided by the application using it. Applications preferably implement this interface if they wish to send or receive final-stage session initiation control messages.

[0883] IConnectionReceived

[0884] In this embodiment, an IConnectionReceived interface may define the message sent in early-stage session initiation, before any VDP traffic has been forwarded by the High-side Listener. It may use the IPC provided by the application using it. Applications preferably implement this interface if they wish to send or receive early-stage session initiation control messages.

[0885] Administration and Configuration Subcomponent

[0886] In one embodiment, the Administration and Configuration subcomponent provides the administrative utilities, configuration files, system status reporting, and run-time interfaces for CAB administration. It provides a partitioned, policy-enforced environment for system administration. Each administrative role permits a high degree of control to the system's administrator's area of concern.

[0887] In one embodiment, the system administration functions may be command-line based. Administrators edit configuration files using a text editor and issue a commit command, which invokes the transactional configuration update. To support administration, the Administration and Configuration subcomponent provides diagnostic and performance reports.

[0888] Design Decisions and Considerations

[0889] Decision to Develop or Reuse

[0890] In this embodiment, the administration functions of CAB have been designed to minimize dependencies on proprietary software or concepts. In one embodiment, administration of the CAB system relies on standard SELinux system commands such as tar, bzip2, and cp to generate backups and export data. The configuration files can be readily edited with standard text editors like vi. The subcomponents that validate configuration data may be modular and reused through the system. The configuration file format, XML, for example, is a commonly accepted standard, simplifying administration and enabling integration with existing XML utilities.

[0891] In one embodiment, the performance monitor functions use data collected from the command line utilities top and ifconfig, data derived from files in the/proc file system, and information provided by other CAB subcomponents. The Performance Monitor may be the primary source of CAB data. Additionally, the Audit subsystem can provide live session data.

[0892] Performance-Related Design Considerations

[0893] In this embodiment, the administrative and performance reporting functions may have very little impact on overall system performance. They are intended to provide live snapshot data. Periodically, the performance reporting functions contact system utilities, read from files in the/proc file system, and aggregate data received from CAB components. Data processing may be performed as it is collected, and therefore can be minimal and spread out over time. In one embodiment, deeper analysis (e.g., audit reduction), which is more resource-intensive, should preferably be carried out off-line.

[0894] Database Design Considerations

[0895] In one embodiment, configuration data—including user data—resides in text-based XML files. In another embodiment, database functionality may be used instead of text-based XML files.

[0896] Safety, Security, and Privacy Design Considerations

[0897] In one embodiment, the administration and performance reporting functions can use the SELinux policy to provide security for the system. Security requirements dictate that administrative roles are preferably partitioned (e.g., policy and auditing roles are separate). The policy can confine the administrative roles, utilities, and configuration files into restricted domains, partitioning capabilities and isolating them from other parts of the system. The performance functionality may also be isolated.

[0898] Subcomponent Details

[0899] Administrative Roles

[0900] In one embodiment, the CAB Guard and Translator have partitioned administrative roles. The responsibilities for each role may be provisioned by the principal of least privilege. The table below presents examples of the roles. Both Guard and Translator may have User, Policy, and Log administrative roles. For example, the User administrator maintains all administrative roles. The Policy role configures the system, except for those functions having to do with auditing and diagnostics. The Log role monitors the system and takes non-policy corrective action. The Guard may also have Client and Forensic administrative roles. For example, the Client administrative role manages client user accounts and profiles. The Forensic administrative role can examine some system logs and view live and recorded sessions.

[0901]

CAB Administrative Roles
Role	Purpose	Actions	Notes	Systems
User	Administer	Add, lock, and suspend	Dominates other	Guard and
	administrators	administrators	administrative roles;	Translator
		Change administrator	some actions may only
		passwords	be carried out in
			maintenance mode
Client	Administer client	Add, lock, and remove		Guard
	users	client users
		Define user profiles
		Assign user profiles
Policy	Configure Guard	Configure all Inspection	Cannot change Audit	Guard and
	operations and	Engine parameters	configuration	Translator
	policy	Configure system-wide
		session constraints
		(e.g., screen resolution)
		Backup system
		configuration
Log	Execute day-to-day	Configure the Audit and	Cannot change policy	Guard and
	operations and	Alert policies	or configuration,	Translator
	identify problems.	View Audit logs	except Audit and Alert
		Backup Audit logs
		View performance
		statistics
		Terminate user sessions
		Turn on the flight
		recorder for a live
		session
Forensic	Incident prevention	View live or recorded	May carry out Audit	Translator
	and analysis	sessions	duties, as needed for
		View some audit logs	analysis

[0902] Administrative Functions

[0903] The following sections describe the administrative utilities.

[0904] System Administrative Utilities

[0905] In this embodiment, core administrative capabilities can include commands to shut down the system, view active sessions and terminate sessions.

[0906] In one embodiment, the Shutdown command may be a command line that is invoked by the Log Administrator to terminate Guard communications and shut down processes. The command sends a shutdown event to the Audit Event Manager, which initiates the system shutdown by signaling the Shutdown Manager.

[0907] In one embodiment, the View Sessions command prints each active session, including high-side user name, numeric session identifier, session start time, session state (i.e., “active” or “suspended”) and other data. The command may parse the live session's data file generated by the Audit subsystem. The tool's output can be filtered using standard Linux tools such as grep or sed.

[0908] In this embodiment, a Kill Session command may terminate a session. It may take one or more session IDs as parameters. The Kill Session may send a terminate session event to the Audit Event Manager, which signals the High-Side Interface Listener to terminate the session. View Sessions and Kill Sessions may work in tandem, much like the UNIX-style ps and kill commands.

[0909] In this embodiment, a Generate Password command may manage passwords. There may be versions to administer both types of users: administrative and client. Each version may access a different password configuration file. The SELinux Security Policy preferably ensures that each version can access its file and do so during the appropriate policy mode. In production mode, preferably only client user passwords are modified. In maintenance mode, preferably only administrative passwords are modified.

[0910] In one embodiment, both versions may use a system encryption key for encryption and decryption. Old passwords within a policy-driven reuse constraint are decrypted and compared with the new password in plaintext form. If the new password is sufficiently different, it is accepted. An encrypted version replaces the old password, and the just-replaced password is appended to the user's list of old password.

[0911] Configuration File Edit Utility

[0912] In this embodiment, configuration files may be edited through vi, arguably the most ubiquitous text editor in UNIX and Linux. Each administrative role has permission to view and edit specific files, enforced by the SELinux Security Policy. In one embodiment, administrators edit files in the/etc/cab/config_admin directory, the offline editing directory. These edits do not affect the running CAB system processes.

[0913] In this embodiment, once files are ready to be incorporated in system operation, they may be committed by the Configuration File Commit utility.

[0914] Configuration File Commit Utility

[0915] In this embodiment, once an administrator has completed edits of one or more configuration files, the changes can take effect once they have been committed. The Configuration File Commit utility can verify the correctness of the modified files, posts the valid new versions and signals the relevant application to reload the configuration. The Configuration File Commit utility may perform the following exemplary tasks:

• • [0916] Verify that the configuration file is well formed (i.e., no syntax errors).
  • [0917] Verify that the configuration file matches the format defined in its schema file.
  • [0918] Create a unique transactional log file having the names of all files /etc/cab/config_transaction directory.
  • [0919] Generate a Beginning Configuration Transaction Audit event, which includes:
  • [0920] Administrator user name
  • [0921] Transactional log file name
  • [0922] Names of files modified
  • [0923] All file text changes.
  • [0924] Move the old configuration files to the/etc/cab/config_history directory, with a unique name having a timestamp.
  • [0925] Move the new configuration files to the/etc/cab/config-runtime directory.
  • [0926] Remove the transactional log file.
  • [0927] Generate a Completed Configuration Transaction Audit event indicating that the transaction was completed. The Audit subsystem signals the Shutdown monitor, which, in turn, notifies of all running processes to reread their configuration files.

[0928] In this embodiment, if there are validation errors when the administrator uses the commit utility, the utility can report those errors to the administrator, and sends them to the Audit subsystem to be logged.

[0929] Configuration Files

[0930] In this embodiment, CAB configuration files may be text-based XML files. Schemas may define the elements, configuration types and attributes. The Configuration File subcomponent may not trust the schema definition included in the XML file because the definition could easily be removed or substituted with an inappropriate schema. Instead, the validation routines may be preconfigured to read specific XML schemas.

[0931] In this embodiment, an exemplary configuration file directory may be laid out as follows:

[0932]

Configuration Files - Directory Structure
Directory	Purpose
/etc/cab	Contain all CAB configuration files.
/etc/cab/config_admin	Staging area for configuration files edited by administrators.
	All files have types accessible only to the administrative roles
	(e.g., Policy Administrator or User Administrator) charged
	with their maintenance. This directory is readable only the
	administrator and Configuration File Commit Utility. The
	utility copies files from this directory to the config_runtime
	directory (described below).
/etc/cab/config_runtime	Live configuration file area, The “configuration commit”
	procedure audits the changes made in the config_admin
	directory after an edit, and copies the files contained in
	config_admin to config_runtime.
/etc/cab/config_history	Contains history of all configuration files, with each file name
	having a timestamp that shows when it was moved.
/etc/cab/config_transaction	Contains transaction rollback logs for pending transactions. If
	any files are present during system initialization, then a
	transaction was not completed. Administrative action is
	necessary.
/etc/cab/data	This file contains all binary data files, such as encrypted
	passwords, data dictionaries, and images for future
	administrator GUI.

[0933] In this embodiment, exemplary initial definitions are described in the following subsections:

[0934] cab_guard_system.xml

[0935] In this embodiment, the Guard system-level configuration file contains global static boundary variables for the Guard processes and threads. This file defines the process defaults used during initialization.

[0936] cab_guard_policy.xml

[0937] In this embodiment, the Guard policy configuration file contains all data relating to policy and security decisions configured by the Policy Administrator.

[0938] cab_guard_hs_roles.xml

[0939] In this embodiment, the Guard Roles configuration file defines the roles for the client users. There are several types of roles that need to be defined include no-access, basic user, and priority user.

[0940] cab-guard_hs_users.xml

[0941] In this embodiment, the Guard user file contains the client user database.

[0942] cab_guard_hs_user_password.xml

[0943] In this embodiment, the Guard user password file contains the Client user passwords.

[0944] cab_guard_hs_ls_user_map.xml

[0945] In this embodiment, the Guard High/Low Mapper configuration file contains the mapping between the high-side user identity and the low-side user identity.

[0946] cab_guard_ls_users.xml

[0947] In this embodiment, the Guard low-side user configuration file contains the details of low-side user accounts.

[0948] cab_guard_user_prefs.xml

[0949] In this embodiment, the Guard user preferences configuration file defines all user preferences that have been determined based on the client system setup, and allowed guard session capabilities.

[0950] cab_guard_capabilities.xml

[0951] In this embodiment, the Guard capabilities configuration file contains all available and allowable session capabilities with regard to browse and collaboration data moving through the system via the VDP protocol. It allows the Administrator to limit the session settings that can be provided to a high-side user.

[0952] cab_guard_dirty_word.xml

[0953] In this embodiment, the dirty word configuration file contains all the dirty words checked during text input from the user. It also contains Dirty Word Search Filter tuning parameters.

[0954] cab_guard_clean_word.xml

[0955] In this embodiment, the clean word configuration file contains all clean words checked during text input from the user.

[0956] cab_guard_audit.xml

[0957] In this embodiment, the audit configuration file contains all configurable data related to the Audit Component and associated processes.

[0958] cab_guard_keyboard_filter.xml

[0959] In this embodiment, the keyboard filter configurable data related to the Guard Keyboard Filter, which is the keyboard inspection process.

[0960] cab_guard_init.xml

[0961] In this embodiment, the initialization configuration file contains all configurable data needed to initialize the system.

[0962] cab_translator_system.xml

[0963] In this embodiment, the translator system-level configuration file, defines global static variables for the Translator processes and threads. The file is used to tune the Translator.

[0964] cab_translator_policy.xml

[0965] In this embodiment, the policy configuration file contains all data relating to policy and security decisions configured by the Translator Admin.

[0966] cab_translator_audit.xml

[0967] In this embodiment, the audit configuration file contains all configurable data related to the Audit subsystem.

[0968] cab_translator_init.xml

[0969] In this embodiment, this initialization configuration file contains all configurable data need for system initialization.

[0970] Configuration File API

[0971] In this embodiment, to support code reuse and development efficiency, Configuration may include a configuration file access library. It can provide a common access mechanism for all configuration parameters, and adds a layer of abstraction supporting future enhancements to the interface. Depending upon licensing and security concerns, the Gnome libxml2 library could be extended for CAB purposes.

[0972] User Interface

[0973] In this embodiment, the user interfaces for the administration and performance reporting functions may be simple command line executables. For configuration files and performance data stores, the Administrator can use standard Linux utilities such as vi, cat, and more. The administrative functions of CAB interact with a large number of system subcomponents and data sources. To allow for least privilege enforcement, the administrative functions and any data they interact with can be modularized and isolated into their own security domains.

[0974] In this embodiment, the Administration and Performance Component may have tight integration with the configuration file subsystem and interacts with the Initialization and Audit subsystems. It can sit at a layer above the configuration file and relies on schema validation to ensure valid data types and values. The Performance Monitor receives performance data from the Audit Event Manager, along with other locations described previously. If it determines that performance data exceed policy-driven thresholds, it can generate an Audit event which can be used to cause a policy-driven response. In most cases, system policy would probably indicate that shutdown is necessary. The table below illustrates examples of a high level analysis of the interfaces:

[0975]

Administration and Configuration Functions - Interfaces
Subcomponent	Interface Description
System	System utilities, such as vi, require write access to CAB configuration
Utilities (write)	files. To support the use of multiple process domains, these utilities may
	be placed in one of several wrappers that provide access only to a subset
	of configuration files.
System	System utilities, such as cat and more, require read access to CAB
Utilities (read)	configuration and log files. To support the use of multiple process
	domains, these utilities may be placed in one of several wrappers that
	provide access only to a subset of configuration files.
Configuration	Several administrative functions-specifically any function committing
File Validation	changes to configuration data-depends on this library. This library
Library	provides read and write interfaces to a variety of configuration files;
	access to those files is enforced by the SELinux Security Policy.
Audit	Administrative functions and utilities send audit messages directly to the
Subsystem	Audit Subsystem, using the common Wire Protocol. The messages
	include “begin configuration transaction,” “configuration change error,”
	and “configuration change successful.” This is one-way communication.
Initialization	The Configuration File subcomponent creates transaction rollback log
Subcomponent	files in a well-known location. Once files have been committed, they are
	removed. If any files are present at system startup, the system halts so that
	an administrator can correct the problem.
Shutdown	The Configuration File subcomponent sends events to the Audit
Subcomponent	Subsystem. The Audit Subsystem, in turn sends event to the Shutdown
	subcomponent, indicating that processes need to reread their configuration
	file. In exceptional cases, such as configuration file disk write failures, a
	fatal event could trigger system shutdown.

[0976] In one embodiment, the performance functions of CAB read from a large number of data sources throughout the system, and writes to a private data store. The data store may be text-based, in comma-separated-value format, so that it can be downloaded from the machine and analyzed using third-party programs. Examples are provided in the following table:

[0977]

Performance Reporting Functions - Interfaces
Subcomponent	Interface Description
Audit	Performance reporting functions receive CAB performance-related and
(receiving	session-related data, in the form of messages from the Event Manager
performance	subcomponent of the Audit subsystem, via the common Wire Protocol.
messages)	This is the only path for CAB processes to send performance data to the
	Performance Monitor. This is one-way communication.
OS Data	Performance reporting functions read data from system-wide sources and
Sources	commands, such as top, ipconfig, and/proc. Data is read from these
	sources, and not written, however, execute access is required for the
	command executables.
Performance	Performance reporting functions requires a writable/appendable private
Data Store	data store to store historical and consolidated data.
Initialization	The Initialization Process launches the performance data gathering
Process	element(s) to support the performance reporting functions, using an ‘exec’
	call. No communications are established between these elements and the
	Initialization Process.
Configuration	The performance gathering and reporting elements may read
	configuration information from the Administration and Configuration
	subcomponent, using the interfaces provided by the Administration and
	Configuration subcomponent. This is one-way communication.
Heartbeat	Upon execution, the Performance Monitor subcomponent uses the
Monitor	common Wire Protocol to provide regular heartbeat messages to the
	heartbeat monitor. This is one-way communication.
Shutdown	Upon execution, this subcomponent registers with the Shutdown Process,
Process	using the common Wire Protocol. Once registered, the heartbeat monitor
	listens for shutdown commands from the shutdown process. This is one-
	way communication.
Audit (sending	Performance data gathering and reporting elements send audit messages
audit messages)	directly to the Audit Subsystem, using the common Wire Protocol. This is
	one-way communication.

[0978] Translator Component

[0979] In one embodiment, the main functionality of the CAB Browse Translator is to convert commercial thin-client protocols into the CAB-developed Virtual Desktop Protocol (VDP). VDP is preferred over existing commercial protocols because of its non-proprietary nature, which allows for more complete feature control, easier inspection, thorough feature reduction and mitigation of security risks posed by some commercial features.

[0980] In this embodiment, within the CAB system, the Translator preferably only performs conversion between protocols; it preferably does not perform the actual cross-domain functionality. That functionality may be done by the Guard.

[0981] In this embodiment, essentially, the Translator converts and relays images, mouse events, keyboard events, and—in one embodiment—audio data between the Guard and the commercial Terminal Server. By reducing the native COTS protocol to VDP, the risks posed by elements such as mobile code, file share access, and viruses can be mitigated. A high-level functional view of the Translator is shown in FIG. 23.

[0982] FIG. 24 shows an example of a block diagram of the CAB Translator component. In this embodiment, as shown in the figure, the Translator may reuse many subcomponents and elements discussed above that are used for the Guard. Those subcomponents can include:

• • [0983] System Initialization (with some modifications as discussed below)
  • [0984] Operating System (SELinux)
  • [0985] SELinux Security Policy (with some modifications as discussed below)
  • [0986] Heartbeat Monitor
  • [0987] Performance Monitor
  • [0988] Shutdown Monitor (with some modifications as discussed below)
  • [0989] Wire Protocol/IPC Mechanisms
  • [0990] Audit Subcomponent
  • [0991] Administration and Configuration.

[0992] In this embodiment, in addition to those subcomponents shared with the Guard, the following subcomponents may be unique to the Translator:

• • [0993] Listener Process
  • [0994] VDP2RDP Processes.

[0995] The sections below will present these subcomponents in detail, and will further discuss design considerations and other minor differences between the Translator and the Guard.

[0996] General Design Decisions and Considerations

[0997] Terminal Server Support

[0998] In this embodiment, a design consideration for the Translator component is which brand(s) of terminal server products would be supported. A terminal server, a hardware platform running commercial off-the-shelf (COTS) software, provides the remote thin-client services on the low-side network, and hosts the low-side desktops to be accessed from the high-side client. Each manufacturer of terminal server products may use different thin-client protocols. Support for many of the different types of terminal server implementations is possible with the architecture.

[0999] For example, one embodiment of CAB interfaces with Microsoft's Windows Terminal Server, using the RDP protocol. Another embodiment of CAB interfaces with Citrix Corporation's MetaFrame Server, using the ICA protocol. These and similar protocols may be referred to generally as remote protocols.

[1000] Other embodiments can support additional types of terminal servers because the CAB architecture—through the use of its Translator component—is capable of supporting a large number of terminal server technologies.

[1001] (U) NOTE: The term “Terminal Server” has multiple meanings within this document. For clarification, the following notations are used

• • [1002] “CAB Terminal Server”: CAB's low-side hardware/software platform that hosts each user session. Also referred to as the “Terminal Server” (with capitalization).
  • [1003] “Microsoft Windows Terminal Server”: Microsoft's product, built into their Windows server platforms that provides multi-user remote access.
  • [1004] “terminal server” (without capitalization): A generic term identifying any product providing multi-user remote access.

[1005] Operating System and Platform-Related Considerations

[1006] In one embodiment, the Translator can use the same hardened operating system and core system services as in the Guard. These core services can be engineered for use for both the Guard and Translator to satisfy a common set of requirements. Utilizing the same base operating system and core services that the Guard uses allows the Translator to:

• • [1007] Reuse OS work and core services
  • [1008] Ensure consistency across the system and implementation
  • [1009] Allow for better patch management across platforms
  • [1010] Provides a common operating experience as the Guard to the administrator
  • [1011] Allows easier integration into the Guard later if desired.

[1012] Performance

[1013] In one embodiment, the Translator component can be architected primarily for performance. All traffic that is sent through the Translator preferably needs to enter and exit as fast as possible to ensure that the end-users' experience is not affected by the translation process.

[1014] In this embodiment, for this reason, Translator subcomponents can be designed to be thread-safe with minimal contention for the reasons described previously.

[1015] Subcomponents

[1016] In this embodiment, as stated above, the Translator can use the same SELinux build and many of the system services used in the Guard. Additionally, the Translator can employ unique Listener and VDP2RDP subcomponents to perform its specialized tasks. FIG. 25 shows services that can be utilized by the Translator.

[1017] Listener Process

[1018] In this embodiment, the Listener Process can be responsible for managing incoming/outgoing connections to/from the Guard. This includes the setup of the incoming TLS sessions and the actual TCP connection managed through the socket API. Upon receiving valid VDP connections, the translator process can be responsible for spawning a new translator process and passing the connection to that process for translation.

[1019] In this embodiment, the Listener process may comprise two primary threads, and a thread pool:

• • [1020] Main thread, which transitions to the Shutdown role
  • [1021] Bootstrap thread pool
  • [1022] Heartbeat thread.

[1023] In one embodiment, the Main thread is responsible for the process initialization steps as well as managing the incoming TLS/TCP connections from the Guard. The main thread may rely on, for example, the Berkley Socket API provided by the operating system to accept incoming connections. Once a connection is established, it can be handed off to a new thread from the bootstrap thread pool to begin the setup process. This newly spawned thread may be responsible for executing a new VDP translator process and handing off information that the new process needs to begin translating.

[1024] In this embodiment, the Main thread may also responsible for creating and managing a write-only channel with the audit subsystem. This channel can provide a process-wide logging capability. Since all threads in the system preferably need access to the audit subsystem, synchronization mechanisms are preferably present to ensure that all threads can efficiently log events without deadlock or starvation.

[1025] In this embodiment, the Heartbeat thread may be initiated by the Main thread at startup. Its function is to periodically receive a simple message from the Main thread that it is still working properly. The Main thread can establish a write-only IPC channel with the Heartbeat thread. The heartbeat interval may be received at startup from the configuration items read-in.

[1026] In this embodiment, when the Main thread has completed its startup operations, it transitions to the role of the Shutdown thread. The purpose of the Shutdown thread is to wait for control and shutdown events from the shutdown process. This thread will establish a read-only IPC channel with the shutdown process and wait for events. When this thread does receive an event to shut down it must gracefully start the termination of all running threads, clean up any state, and if necessary, notify the shutdown thread prior to closing.

[1027] In one embodiment, in addition to managing the incoming network connection, the Listener can also ensure that it has channels open with:

• • [1028] Shutdown process: Allows the system to shut down the Listener when critical events are dispatched from the event manager.
  • [1029] Heartbeat process: The Listener process preferably maintains a periodic heartbeat with the Heartbeat process so that the Heartbeat process can detect any loss of use, process or resource failure
  • [1030] Audit Subsystem: Provides the listener the capability to send auditable events for later storage/lookup as well as a means to receive control events from the event manager.

[1031] In this embodiment, at start up, the Listener process can read configuration items for itself or the individual VDP translators to be invoked for session handling. These configuration items can be read once from persisted storage and stored in memory for later look up and hand off to the VDP translator processes.

[1032] Subcomponent Details

[1033] In one embodiment, upon being executed by the Init process, the Listener process begins by using the configuration subcomponent to read in each of the configuration items related to the Listener and any COTS protocol translators that are later executed (e.g., VDP2RDP, VDP21CA).

[1034] In this embodiment, exemplary configuration items include:

• • [1035] The network interface to listen on for TCP/TLS connections
  • [1036] The network port to listen on for TCP/TLS connections
  • [1037] TLS card communication settings (anything the Listener needs to know to use the TLS card)
  • [1038] A list of valid COTS protocol translators and the details for each
    • [1039] Location of the physical process in the file system
    • [1040] Fully qualified filename for IPC communications
    • [1041] The network interface to use to connect to the CAB Terminal Server
    • [1042] Threading model expected by the process (one process/session or multiple sessions/process using threads)
    • [1043] Any process thread limitations for the multiple sessions/process model
  • [1044] Audit subsystem communication settings
  • [1045] Certificate store location and access details
  • [1046] Heartbeat interval.

[1047] In one embodiment, the Listener continues by establishing a communication link with the audit subcomponent to preferably ensure that future events can be properly logged to the audit subcomponent.

[1048] In one embodiment, the Listener continues by first connecting to the shutdown process and then the heartbeat process using an IPC channel defined by each process. If both connections were successful, the Listener spawns a new thread to handle the heartbeat communications. The Listener then spawns a second thread to handle TLS/TCP listening operations. The Main thread then continues by waiting on the previously established channel with shutdown for shutdown events. The Heartbeat thread can be given a higher priority than the other threads in order to ensure that the Heartbeat thread is always responsive.

[1049] In one embodiment, the Listener thread begins by:

• • [1050] Creating a new TCP socket
  • [1051] Binding to the interface and port defined in the configuration
  • [1052] Starting to listen, and block waiting for connections to be accepted.

[1053] In one embodiment, when a new connection is accepted, the Listener thread retrieves a new thread from the local bootstrap thread pool and assigns it to the new connection. The Listener thread may be responsible for ensuring that the binding between this new thread and the connection are recorded for any future maintenance operations.

[1054] In one embodiment, once the new connection thread has been established, its first step is to wait for the first packet on the new connection and peek at it to determine which type of translator is required by the connection. Next, the thread will execute that the required VDP Translator (either RDP or ICA) process, setup an IPC new channel for communicating with this new process, and attempt to connect to the newly created translator process using IPC. When connecting to the translator process, the connection thread should use the filename specified in the configuration file for the translator type to which they are connecting, concatenated with the PID (process identifier) of the executed translator process. The executed process should take as its first parameter, the path and filename to use for this IPC channel.

[1055] In this embodiment, assuming the IPC channel between the connection thread and the executed translator was successful, the connection thread should send the translator the connection socket descriptor and any state needed to use that connection from within the VDP API connection component.

[1056] In this embodiment, following this, the connection thread preferably sends the configuration items specific to the translator process as defined by the previously read configuration state. Once completed, the connection thread should wait for a shutdown notification from the connected process. If the connected process fails before it can establish a connection with the audit subsystem, the process notifies the Connection thread via this IPC channel. If a failure response is returned, the connection thread should log the event and continue with the normal thread shutdown process. Shutting down the connection thread releases allocated resources, resets the managed state and adds itself back into the thread pool. The Listener thread and Listener process may have no knowledge of the previously executed translator process

[1057] In this embodiment, the Listening thread continues accepting connections until it is signaled by the main thread that shutdown should be initiated. Once shutdown is initiated, the Listener process should wait until the Listener thread and Heartbeat thread have terminated before gracefully closing.

[1058] Interfaces

[1059] In this embodiment, within the Translator component, the Listener Process may interface with several other subcomponents. The table below provides examples of these interfaces:

[1060]

Listener Process - Internal Translator Interfaces
Subcomponent	Interface Description
High-side TCP Stack	The Listener process communicates with the High-side TCP stack
	for all incoming network operations from the Guard.
VDP2RDP Process	The Listener Process launches each VDP2RDP Process, using an
	‘exec’ call. An individual VDP2RDP Process is launched to
	support each active user session. The Listener Process then uses
	the shared Wire Protocol to pass configuration information to
	VDP2RDP. The following configuration information is passed:
	SocketDescriptor (for the individual session's incoming VDP
	connection), AllowedEncryption (to identify permitted encryption
	types when connecting to the RDP server), Keys (as required to
	perform TLS functions).
Initialization	The Initialization Process launches this subcomponent, using an
	‘exec’ call. No communications are established between this
	subcomponent and the Initialization Process.
Configuration	This subcomponent reads configuration information from the
	Administration and Configuration subcomponent, using the
	interfaces provided by the Administration and Configuration
	subcomponent. This is one-way communication.
Encryption/Decryption	Listener Process interacts with this subcomponent to perform TLS
	functions, using the interfaces provided by the subcomponent.
Heartbeat Monitor	Upon execution, this subcomponent utilizes the common Wire
	Protocol to provide regular heartbeat messages to the heartbeat
	monitor. This is one-way communication.
Shutdown Process	Upon execution, this subcomponent registers with the Shutdown
	Process, using the common Wire Protocol. Once registered, the
	heartbeat monitor listens for shutdown commands from the
	shutdown process. This is one-way communication.
Audit	This subcomponent sends audit messages directly to the Audit
	subcomponent, using the common Wire Protocol. This is one-way
	communication.

[1061] VDP2RDP Process

[1062] In this embodiment, another major process that is unique to the Translator is the VDP2RDP process. The VDP2RDP process may be responsible for handling the packet translation between the VDP and RDP protocols. In one embodiment, the translator system may be set up so that one VDP2RDP process is executed to handle one and only one user session.

[1063] In this embodiment, the VDP2RDP can manage the packet flow using two socket-based TCP connections: one with the Guard from the high-side interface and one with the Terminal Server from the low-side interface.

[1064] In this embodiment, the VDP2RDP process comprises four threads that are preferably always running:

• • [1065] Main
  • [1066] Heartbeat
  • [1067] Upstream
  • [1068] Downstream

[1069] In this embodiment, the architecture of the VDP2RDP process is shown as an example in FIG. 26.

[1070] In one embodiment, the Main thread is responsible for performing the startup operations as well as receiving shutdown operations once normal operations have commenced. Operations of the main thread may include:

• • [1071] Accepting configuration items, including the high-side socket descriptor, from the Listener process
  • [1072] Establishing IPC channels with the audit, shutdown, and heartbeat processes
  • [1073] Connecting to the low-side Terminal Server and initiating a login.

[1074] In this embodiment, the Heartbeat thread may be started by the main thread to provide a periodic heartbeat with the heartbeat process. This thread can establish a write-only IPC channel with the Heartbeat thread and periodically send a simple message to the heartbeat process to notify the Heartbeat process that it is still working properly. The heartbeat thread should get the heartbeat interval from the configuration items sent to the VDP2RDP thread at startup.

[1075] In this embodiment, the Upstream thread may be responsible for handling RDP packets that are received from the low-side socket connection to the Terminal Server, translating them to VDP, and sending them out the high-side socket connection to the Guard.

[1076] In this embodiment, the Downstream thread may be responsible for handling VDP packets that are received from the high-side socket connection to the Guard, translating them to RDP, and sending them out the low-side socket connection to the Terminal Server.

[1077] In this embodiment, the VDP2RDP process preferably maintains connections with the following using IPC:

• • [1078] Shutdown process: Allows the system to shut down the session when critical events are dispatched from the event manager
  • [1079] Heartbeat process: The VDP2RDP process must maintain a periodic heartbeat with the heartbeat process so that the heartbeat process can detect any loss of use, process or resource failure
  • [1080] Audit Subsystem: Provides the VDP2RDP process the capability to send auditable events for later storage/lookup as well as a means to receive control events from the event manager.

[1081] In one embodiment, at start up, the VDP2RDP process is preferably expected to set up an IPC channel with the executing thread in the Listener process using a command-line parameter identifying a file and the VDP2RDP processes PID. Once this channel is established, the process should wait for the configuration items needed by the process to run, and the socket descriptor for the incoming connection. Once the VDP2RDP process has everything it needs, it should begin the startup process and only close the channel with the Listener process once the audit subsystem connection has been successfully established.

[1082] Startup

[1083] In one embodiment, the VDP2RDP process is executed by the Listener process when a new high-side connection with the Guard is established for handling a new VDP user session. An exemplary first step in this process is to create a new IPC channel using the filename passed to it at runtime and its PID. Once the IPC channel has been created, the VDP2RDP may wait for the following items:

• • [1084] Configuration Items
    • [1085] Outgoing interface for the session
    • [1086] Heartbeat settings (interval)
    • [1087] TLS and Certificate information
  • [1088] Connected socket descriptor: high-side socket descriptor to use for all high-side traffic.

[1089] In one embodiment, once the VDP2RDP process has received all of the items it needs to run from the Listener process, it will attempt to connect to the audit subsystem using IPC. If the connection with the audit subsystem is successful, the VDP2RDP process can release the IPC channel created between itself and the Listener process because any future fatal startup options can be sent through the audit subsystem.

[1090] In this embodiment, the VDP2RDP process can continue by connecting to both the shutdown process and the heartbeat process using IPC. If both are successful, the VDP2RDP process will spawn a heartbeat thread to periodically notify the system that it still exists. Once this is complete the VDP2RDP process enters the connecting phase of its startup.

[1091] In this embodiment, the VDP2RDP process continues by attempting to make a socket connection to the Terminal Server and initiating the low-side login process. If this connection fails the VDP2RDP process will notify the connected Guard using VDP and start the shutdown process. If successful, the VDP2RDP process will spawn two threads, one for upstream traffic (Low to High) and another for downstream traffic (High to Low). Once both traffic threads have started, the VDP2RDP process has entered the running phase and normal operations begin.

[1092] In this embodiment, once in a running state, the main thread becomes the shutdown thread by waiting for shutdown events from the shutdown process. This way, when shutdown events do occur, it will be easier for the process to shut down the remaining three threads.

[1093] Subcomponent Elements

[1094] In one embodiment, the following elements may be utilized by the VDP2RDP process.

• • [1095] VDP API—The VDP2RDP process can use the VDP API whenever it needs to interface with the VDP protocol. The VDP API encapsulates the receiving and validation of incoming VDP packets so that the process can ensure that all packets received are valid for the current state.
  • [1096] Cache Management—A portion of the RDP protocol uses image caching as a mechanism to reduce the overall bandwidth required for the user's session to perform effectively. While VDP does support some caching operations that are similar to one in RDP, not all are the same and there may be situations where the Guard only employs select features provided by VDP. In these situations, the translator preferably maintains its own local cache so that the requested cache-based drawing request can be drawn in a local virtual frame buffer and passed on to the Guard as image updates.
  • [1097] Virtual Frame Buffer—The virtual frame buffer is an in memory representation of the end-users display as defined by the drawing commands and caching request passed to it by the Terminal Server via RDP. The VDP2RDP process preferably employs the use of a virtual frame buffer when the request VDP features do not map directly to features provided by the RDP protocol. In these situations, RDP commands and requests are preferably drawn to the local frame buffer and sent to the Guard as an image update.
  • [1098] Upstream Thread—The upstream thread operates on both connected sockets. It waits for RDP packets on the low-side connection; when they are received, it can convert them into their corresponding VDP packets. Upstream traffic may be directly related to what gets displayed on the end-users screen and therefore, the upstream threat may need to employ the services of the local cache and frame buffer before a VDP message can be sent. Once the conversion is made, the upstream thread can send the converted packet to the Guard using the high-side socket connection.
  • [1099] Downstream Thread—The downstream can also operate on both connected sockets. It waits for VDP packets on the high-side connection: when they are received, it converts them into their corresponding RDP packets. All downstream traffic may be directly related to user input from the client. In certain situations, the received VDP packet will represent a compound action that requires multiple outgoing RDP packets. Once the conversion is finished, the downstream packages up the outgoing packets and send them to the Terminal Server using the low-side socket connection.

[1100] High-Side Network Interface

[1101] In one embodiment, the high-side network interface manages incoming network traffic from the Guard. This interface can employ a firewall so that only allowed ports and connecting IPs are used. Incoming connections are preferably required to authenticate and connect via TLS before any traffic can be received. VDP traffic can be received and sent over the previously established TLS connection with the Guard.

[1102] Low-side Network Interface

[1103] In one embodiment, the load side network interface is responsible for managing network traffic between the translator and the Terminal Server.

[1104] In this embodiment, the low-side interface can optionally support an SSL/TLS crypto board if the Terminal Server supports or forces that all traffic be sent through a secure port. The option is completely up to the site administrator and can be configured by the guard. When the Terminal Server does require an SSL/TLS, the same constraints apply to the set up of that connection. If SSL/TLS is supported, prior to any VDP traffic being accepted or processed, the secure link is preferably established.

[1105] The low-side network interface may control traffic directly connected to the Terminal Server and therefore must understand the Remote Desktop Protocol (RDP). In one embodiment, the RDP may comprise four basic network layers:

• • [1106] ISO: Based on the IS08073 Standard (RFC 905) using ISO Transport over TCP, also known as ITOT (RFC 2126).
  • [1107] MCS: Multipoint Communication Service Protocol, modified as defined in the ITU-T T.122 standard and implemented in the ITU-T Rec. T.125 standard
  • [1108] Security: RDP layer for handling secure communications and licensing. All traffic from this point on can be encrypted and verified with an attached Message Authentication Code (MAC).
  • [1109] RDP: Based primarily on the ITU-T. 128 Application Sharing with modifications for use on a Windows-based platform. User input and image output is encoded in this layer.

[1110] RDP Translation Details

[1111] Information Sources

[1112] In this embodiment, there are two primary sources for public RDP knowledge upon which the translation assumptions have been based.

[1113] In this embodiment, the first source of information includes a collection of internationally recognized and standardized protocols. These protocols provide insight into the overhead, technology, and features involved with and provided by the Remote Desktop Protocol.

[1114] In this embodiment, the second information source available is an open source RDP client implementation called rdesktop. The rdesktop client provides an in-depth look into how the protocol works, how the packets are laid out, and the minimum protocol support needed to achieve basic functionality.

[1115] Protocol Specifics

[1116] In one embodiment, the Remote Desktop Protocol may be based on four documented standards:

• • [1117] RFC 2126, ISO Transport over TCP (ITOT): defines how an ISO based protocol is transmitted over a TCP connection
  • [1118] RFC 905, ISO DP 8073 Transport Protocol: the specific ISO protocol used by RDP for transmission over a TCP connection and the ITOT rules
  • [1119] ITU-T T.125, Multipoint Communication Service: channel based communication protocol design to stream content dynamically to multiple simultaneous users
  • [1120] ITU-T T.128, Application Sharing: stream protocol that runs over the T.125 protocol and defines all of the communications necessary to remotely share a user session. The RDP protocol is largely based upon this standard.

[1121] As a result, one embodiment of the RDP protocol may be broken down into four distinct protocol layers that are derived directly from these standards:

• • [1122] ISO Layer: Based upon RFC 2126 and 905
  • [1123] MCS Layer: Based upon the T.125 Standard
  • [1124] Security Layer: Security layer defined by entirely by the protocol
  • [1125] RDP Layer: Derived almost exclusively from T. 128 with additions and exceptions made to fit the Windows platform.

[1126] Translation

[1127] In this embodiment, there may be two aspects of the RDP translation that preferably should be considered when implementing a VDP2RDP translator:

• • [1128] Control Operations: Many of the functions supported in RDP are used for control over the protocol. These functions are used to control how a session starts up and how it will operate throughout the life of the session. Control operations such as these do not have a one-to-one mapping to a feature supported in VDP and therefore, no direct translation is needed. Instead, most control operations will be processed entirely within the RDP side of the VDP2RDP translator. For the most part, configuration items that define the options for these control operations will be statically defined in configuration files or provided to the VDP2RDP translator at session startup.
  • [1129] Direct Translation: Many RDP features have a one-to-one or one-to-many mapping with VDP. In some situations the mapping of these features is very simple and little more than a transfer of information needs to be done, while in others more complicated scenarios arise that require internal processing or an expansion of the received packets. It is these more complicated scenarios that will often require session-specific state information.

[1130] In this embodiment, a third aspect of translation involves the dropping of RDP packets that cannot, or should not, be processed or passed to the VDP side.

[1131] Control

[1132] In this embodiment, control packets provide a mechanism for controlling how the user session runs and operates from the client perspective. There may be essentially thee types of RDP control packets that VDP is interested in for the purpose of translation:

• • [1133] Login: Login control packets are used for one purpose: activating a new user session. This is a control item not only because it is the entry point into a new user session, but because it contains many of the static configuration items that can only be configured once at the start of the session. Some of the configuration items included in the login control packets are:
    • [1134] Username/password (if automatic login desired)
    • [1135] Domain
    • [1136] Login flags (automatic versus user entered login)
    • [1137] Remote host and client information
    • [1138] Desired RDP version
    • [1139] Screen resolution (Width×Height)
    • [1140] Color depth
    • [1141] Keyboard layout
    • [1142] Security settings (strong versus week encryption)
    • [1143] Supported channels (clipboard, sound, device redirector, etc. . . . ).
  • [1144] Capabilities: RDP has been designed to support a capabilities negotiation phase, which allows a client to define and in some cases turn off many configuration items and features provided in the protocol. This is a great feature because it allows the client to suit the session to their needs and limitations (e.g., bandwidth, memory). In addition, the server gets an opportunity to deny certain requests because of configuration constraints defined at the server for the whole system. Some of the capability items included are:
    • [1145] Operating system and protocol version
    • [1146] Supported compression types and selected level
    • [1147] Display support (resolution, color depth, palettes)
    • [1148] Supported drawing and caching operations
    • [1149] Cache size support
    • [1150] Cursor options.
  • [1151] State: State control packets are any packets that affect the state of the user's session. For instance, if the server for some reason issues a disconnect message to the VDP2RDP translator, this is preferably propagated up through the Translator, Guard, and eventually to the Client. The translation in most cases for this type of packet is a one-to-one mapping from RDP to VDP packets and vice versa.

[1152] In this embodiment, configuration items the translator needs for login and capability negotiation can either be read in from local persistent configuration files or from the VDP connection request packet sent to the Translator from the Guard. The table below outlines examples of what configuration items the Guard will provide to the translator via the connection request message and which TLV type they are associated to.

[1153]

Available VDP Configuration Items
TLV	Configuration Item
Display Settings	Resolution (Width and Height)
	Color Depth (8, 15, 16, or 24 bit)
Language Settings	Key Layout
Login	Terminal Server Username
	Terminal Server Password
Remote Host	Terminal Server IP Address and Port
	Which translator to use (RDP/ICA)
Cache Size	Cache Configuration:
	Bitmap Cache
	Font Cache
	Cursor Cache
	Palette Cache
Output Capabilities	Supported Drawing Operations
System Capabilities	Supported Clipboard Features
	Supported File Transfer Features
	Supported Audio Features
	Supported Video Features
	User pre-emption supported
	Timeout settings (idle, suspend, cache)
	User priority
	Availability of session performance
Security Settings	Low-side security setting (Translator ⇄Terminal
	Server)

[1154] RDP disconnect packet. In one embodiment, this packet may be sent either by the RDP client or server to notify it that they are terminating the session. The RDP disconnect packet provides a reason code that can be used by the translator to determine which VDP packet to send, either a Session Shutdown or Session Timeout message.

[1155] Direct Translation

[1156] In this embodiment, direct translation of RDP packets may be needed for user input coming from the client and visual output sent from the Terminal Server. The tables below outline example of the types of packets to be translated from VDP and RDP.

[1157]

VDP to RDP Packet Translation
VDP	RDP
Packet	Type	Description	Packet(s)	Description
Keyboard	0x040001	User presses a	Keyboard Event	Standard keyboard press any
Press		keyboard key	(Down)	release event. Includes either a
Keyboard	0x040002	User releases a	Keyboard Event	scancode or virtual key code for the
Release		keyboard key	(Up)	key pressed.
Key string	0x040003	User enters a	Multiple	Translated into multiple sequential
		captured string	Keyboard Events	RDP key events packaged into the
			(Down and Up)	same packet. One press and release
				event is needed for every character
				included in the string.
Mouse Press	0x040004	User clicks a	Mouse Event	Standard mouse click and release
		mouse button	(Down)	event. Includes a flag for the button
Mouse	0x040005	User releases a	Mouse Event	pressed (1, 2, or 3) and the location
Release		mouse button		of the cursor.
Mouse	0x040006	User moves the	Mouse Event	Standard mouse movement event.
Move		mouse	(Move)	Includes the new cursor location.
Mouse	0x040007	User moves the	Mouse Event	RDP assigns the flags for button 4
Scroll Up		mouse scroll	(Button4)	and 5 to the scroll up and down
		wheel up		events. Thus, to scroll a standard
Mouse	0x040008	User moves the	Mouse Event	mouse down event needs to be sent
Scroll Down		mouse scroll	(Button5)	using the flags for buttons 4 or 5,
		wheel down		depending on the action (up or
				down)
Mouse	0x040009	User completed	Mouse Events	Client initiated single-click requires
Single-Click		a single mouse	(Down and Up)	a mouse down and release event
		click		separated by at least 150 ms. This
				is so the message is only
				interpreted as a single click
Mouse	0x04000A	User completed	Mouse Events	Requires two sets of mouse down
Double-		a double	(Two quick	and release packaged together in
Click		mouse click	Down and Up)	one packet so the Terminal Server
				will detect their closeness as a
				double-click
Mouse	0x04000B	User completed	Mouse Events	Requires three sets of mouse down
		a triple mouse	(Three quick	and release packaged together in
Triple-Click		click	Down and Up)	one packet so the Terminal Server
				will detect their closeness as a
				triple-click
Mouse Drag	0x04000C	User-initiated	Mouse Event	A drag motion is simulated by
		dragging	(Down)	sending a RDP mouse down event
Mouse Drop	0x04000D	User completed	Mouse Event (Up)	and sending mouse move events
		a drop		before the mouse release is sent.
				The VDP Mouse drag only sends
				the RDP mouse down event. A
				subsequent VDP Mouse Drop
				event results in the mouse release
				for the previous down, potentially
				at a different mouse location.

[1158] RDP to VDP examples:

[1159]

RDP to VDP Packet Translation
RDP	VDP
Packet	Description	Packet(s)	Type	Description
Disconnect	Sent by the client	Session	0x020001	Sent for Terminal Server initiated
	or server to close	Shutdown		shutdowns while the session is
	a session			running
		Session	0x020002	Sent when the Terminal Server
		Disconnect		initiates a Disconnect because of a
				remote idle timeout
		Connection	0x030003	If the disconnect is sent as the
		Response		result of a Terminal Server login
				request the error message is
				denoted in the connection
				response to the Guard
Palette	Sent to update the	Palette	0x050001	Close to a one-to-one mapping
Update	active palette for	Update		between the two protocols. VDP
	future bitmap			reduces a little bit of overhead.
	updates
Bitmap	Sent to paint a	CIF Paint	0x050003	Depending upon the compression
Update	bitmap to the			algorithm allowed by the Guard,
	screen			the image must be decompressed,
	compressed or			potentially re-compressed using a
	otherwise			Guard sponsored algorithm.
				Otherwise the translation is close
				to one-to-one.
System	Sent to reset the	Cursor	0x050002	Cursor related RDP messages are
Pointer	state of the	Update		all sent as a VDP cursor update
	current cursor			image. The VDP update message
	pointer			is for a monochrome (1 bit/pixel
Color	Sent to update the			color) which requires the
Pointer	current cursor			translator to down sample the
	with a new cursor			color pointers.
Cache	Sent to cache a	Cursor	0x060001	The cursor sent as the same format
Pointer	cursor image in	Cache		as the VDP cursor update packet
	the cursor cache			with the addition of an index.
				Neglecting the down-sampling
				needed to drop the color this
				packet is close to one-to-one with
				eth RDP packet.
Raw Bitmap	Uncompressed	Bitmap	0x060003	VDP Bitmap Cache packet is very
Cache	bitmap sent	Cache		close to its RDP counterpart,
Raw Bitmap	specifically to be			minus a little overhead. Only
Cache v2	cached			difference is the VDP version can
Bitmap	Compressed			handle both compressed and
Cache	bitmap sent			decompressed images.
Bitmap	specifically to be			Compressed images may need to
Cache 2	cached			be decompressed and potentially
				re-compressed according to the
				algorithms allowed by the Guard.
Font Cache	Sent to cache	Font Cache	0x060004	The VDP Font cache packet is
	multiple glyphs			very similar to its RDP
	for a given font			counterpart minus a little
				overhead. This translation may
				require the glyph pixel maps be
				adjusted slightly to fit the format
				defined by VDP
DestBlt	Destination	Clear	0x050004	Translates to the VDP Clear
Order	Block transfer			packet which is used for general
	sent to clear and			clearing operations of a
	area of the screen			rectangular region of the screen
Rect Order	Sent to clear an			using a sent color. Also used to
	area of the screen			invert the region.
	with a specified
	color
PatBlt	Sent to clear and	Pattern	0x050005	The VDP Pattern clear packet is
Order	area of the screen	Clear		very similar to the RDP PatBlt
	with a specified			packet. The VDP version is
	bruch			slimmer but the translation is close
				to on-to-one
ScreenBlt	Sent to copy one	Screen	0x050006	The VDP Screen Copy packet is
Order	portion of the	Copy		very similar to the RDP ScreenBlt
	screen to another			packet. The VDP version is
				slimmer but the translation is close
				to on-to-one
DeskSave	Sent to save a	Screen	0x060002	The VDP Screen Cache packet is
Order	portion of the	Cache		slightly different from the
	screen to a client			DeskSave RDP packet in that its
	bitmap cache			based on indexes. The RDP
				desksave operation is saved based
				on an offset into the desktop
				image and therefore translation
				will need to be done to map the
				two. The RDP Desksave packet is
				primarily used for saving
				commonly viewed areas of the
				Desktop, whereas the Screen
				Cache can be used to cache any
				section of the screen for later
				display
MemBlt	Sent to copy a	Cache	0x050007	The VDP Cache Copy packet is
Order	cached bitmap to	Copy		very similar to the RDP MemBlt
	the screen			packet. The VDP version is
				slimmer but the translation is close
				to on-to-one
TriBlt Order	Sent to do a	Pattern	0x050005	The RDP TriBlt packet is
	combination of	Clear and	and	translated into multiple sets of
	MemBlt and	Cache	0x050007	Pattern Clear and Cache Copy
	PatBlt commands	Copy		packets packaged together for
				transit.
Line Order	Sent to draw a	CIF Paint	0x050003	These are unsupported operations
	line to the screen			that must be transmitted as bitmap
Polyline	Sent to draw a	CIF Paint	0x050003	updates. If these operation can not
Order	poly-line to the			be turned off at startup then the
	screen			translator will maintain a Virtual
				Frame Buffer to draw the
				operations in. The translator
				would then sent a CIF Paint
				message that contains the update.
Text Order	Sent to draw text	Cached	0x050009	The VDP Cache text Draw packet
	from a cached	Text Draw		is very similar to the RDP Text
	font			order packet. The VDP version is
				slimmer but the translation is close
				to on-to-one

[1160] In this embodiment, depending upon the session configuration as managed by the Guard at session startup (using the Capabilities, Connection Request, and Response packets), some of these input events, drawing operations, or caching requests may be disabled.

[1161] In this embodiment, if an input event is sent when that input option is disabled, the packet preferably should be considered invalid, but it is up to the Guard to decided what action should be taken (drop packet or shutdown the session). Examples of this are:

• • [1162] Sending a Key press/release event for a character with a visual representation when direct input mode is disabled.
  • [1163] Using no visual key representations in the Key string packet
  • [1164] Sending Mouse Scroll events when the mouse wheel has been disabled
  • [1165] Sending Mouse Up/Down events for button 3 when the button has been disabled
  • [1166] Sending Mouse move events when movement has been disabled
  • [1167] Sending Mouse move events that break the frequency and hover rules as defined in the capabilities packet sent to the client.

[1168] In this embodiment, if a drawing command or caching request is disabled the translator may try to have the RDP session disable that feature so no translator processing needs to be done to handle the missing feature. If this is not possible, the translator may have to use a Virtual Frame Buffer (VFB) to locally draw the requested operation and send the resulting change in the users display to the client as a bitmap update. This applies to the drawing commands and capabilities that can be disabled on a per user or profile basis.

[1169] Interfaces

[1170] In this embodiment, within the Translator component, the VDP2RDP Process may interface with several other subcomponents, as shown by the examples in the table below:

[1171]

VDP2RDP - Internal Translator Interfaces
Subcomponent	Interface Description
Listener Process	The Listener Process launches each VDP2RDP Process, using an
	‘exec’ call. An individual VDP2RDP Process is launched to
	support each active user session. The Listener Process then uses
	the shared Wire Protocol to pass configuration information to
	VDP2RDP. The following configuration information is passed:
	SocketDescriptor (for the individual session's incoming VDP
	connection), AllowedEncryption (to identify permitted encryption
	types when connecting to the RDP server), Keys (as required to
	perform TLS functions).
Encryption/Decryption	VDP2RDP Process interacts with this subcomponent to perform
	TLS functions, using the interfaces provided by the subcomponent.
Heartbeat Monitor	Upon execution, this subcomponent uses the common Wire
	Protocol to provide regular heartbeat messages to the heartbeat
	monitor. This is one-way communication.
Shutdown Process	Upon execution, this subcomponent registers with the Shutdown
	Process, using the common Wire Protocol. Once registered, the
	heartbeat monitor listens for shutdown commands from the
	shutdown process. This is one-way communication.
Audit	This subcomponent sends audit messages directly to the Audit
	subcomponent, using the common Wire Protocol. This is one-way
	communication.
Low-side TCP stack	The VDP2RDP process communicates with the low-side terminal
	server using the low-side TCP stack. All network traffic goes
	through this interface and may require an additional SSL/TLS
	tunnel, which would require use of the encryption/decryption
	subcomponent.

[1172] System Initialization

[1173] In one embodiment, the CAB Translator component reuses the Initialization subcomponent from the Guard, but is modified to support a different initialization sequence. In one embodiment, for the Translator, the CABInit process initializes in the following order:

• • [1174] Integrity checks
  • [1175] Heartbeat Process
  • [1176] Audit Subsystem
  • [1177] Shutdown Subsystem
  • [1178] Performance Monitor
  • [1179] Listener.

[1180] In this embodiment, note that VDP2RDP processes may be launched by the Listener as each new connection is made.

[1181] In this embodiment, the sequence shown above does not include the standard processes initialized as part of the SELinux boot. The Network Boolean (within the Security Policy) may not be enabled until all of the processes have successfully initialized. In complying with the core services design, the running Translator subcomponents preferably maintain links with the—

• • [1182] Audit Subsystem, for logging and event management
  • [1183] Heartbeat, for health management
  • [1184] Shutdown, for shutdown management.

[1185] Shutdown Monitor

[1186] In one embodiment, the CAB Translator component reuses the Shutdown Monitor subcomponent from the Guard; however, it is modified to shut down a different set of processes. For the Translator, the Shutdown Monitor may shut down the following:

• • [1187] Heartbeat Process
  • [1188] Audit Subsystem
  • [1189] Performance Monitor
  • [1190] Listener
  • [1191] VDP2RDP Processes.

[1192] Heartbeat Monitor

[1193] In one embodiment, the CAB Translator component reuses the Heartbeat Monitor subcomponent from the Guard, modified to monitor a different set of processes. For the Translator, the Heartbeat Monitor monitors the following:

• • [1194] Shutdown Process
  • [1195] Audit Subsystem
  • [1196] Performance Monitor
  • [1197] Listener
  • [1198] VDP2RDP Processes.

[1199] SELinux Security Policy

[1200] In this embodiment, though the Translator may share the same base operating system as the Guard, the Security Policy is preferably modified to allow for the differences in processes and functionality. The security domains within the Translator may include:

• • [1201] Listener domain (contains the Listener process)
  • [1202] VDP2RDP domain (contains VDP2RDP processes)
  • [1203] Audit domains (several domains containing audit related processes)
  • [1204] Administrative domains (several domains containing administrative and configuration processes)
  • [1205] Heartbeat Monitor domain (containing the system monitoring functions)
  • [1206] Other domains to be added.

[1207] Operating System

[1208] In one embodiment, the CAB Translator component reuses the base operating system install from the Guard component. Very few deviations may occur. Most notably, the firewall configuration may differ for the translator.

[1209] In one embodiment, the firewall rules support Guard VDP traffic, Terminal Server protocol traffic, and trusted Network Time Protocol. Examples of these rules are shown in the following table:

[1210]

Translator Firewall Rules
Interface	Direction	Protocol	IP Addresses	Notes
Guard-	Inbound TCP	VDP TLS	Individual Guard IP	Prescribed by site
side			addresses or	deployment
			networks, as
			prescribed by site
			policy
	Inbound/Outbound	Network	Single NTP server	Necessary for time
	UDP	Time		synchronization;
		Protocol		recommended
		(NTP)		deployment on secure
				switched network
Terminal-	Outbound TCP	Proprietary	Individual Terminal
Server-		Terminal	Server IP addresses
Side		Server	or networks, as
		TLS/SSL	prescribed by site
			policy

[1211] Terminal Server Component

[1212] In this embodiment, the Terminal Server component may provide a low-side, multi-user platform on which the low-side presences can physically reside. In one embodiment, it may consist of a commercial off-the-shelf (COTS) platform that supports remote thin-client connections.

[1213] In this embodiment, the Terminal Server platform may be connected to the low-side network. This means that the Terminal Server can be configured, without any CAB-specific training, to support applications, resources and protocols natively available on that network. A functional view of the Terminal Server is shown in FIG. 27.

[1214] Design Decisions and Considerations

[1215] Terminal Server Products Supported

[1216] In this embodiment, CAB has been architected to support a variety of terminal server solutions. Because the native server protocol is translated to VDP, supporting additional protocols over time will require very few system changes outside of the Translator.

[1217] In this embodiment, there are over a dozen different terminal server solutions available; some are commercial products, some are open-sourced. While open-source solutions appear attractive from a cost perspective, their lack of technical support and limited reliability become major obstacles to ensuring system availability. Of the commercial products, Microsoft and Citrix Corporation dominate the thin-client market. Both offer features that meet the requirements needed of the terminal server functionality.

[1218] In one embodiment, Microsoft Windows Terminal Server, using the RDP protocol, may be supported. In another embodiment, Citrix Corporation's MetaFrame Server, using the ICA protocol may be supported. In yet other embodiments, support for other types of terminal servers may include, for example, VNC, Tarantella and X.

[1219] Platform Support Considerations

[1220] In one embodiment, Citrix is available on UNIX, Linux, and Mac. In another embodiment, Microsoft Windows Terminal Server is supported on Windows platforms, for example, Windows 2000 and 2003.

[1221] Scalability and Performance Considerations

[1222] In this embodiment, many issues contribute to scalability and performance. Some of the issues are listed below:

• • [1223] Memory requirements and utilization—Determining the amount of memory necessary for a particular use of a terminal server is complex. It is possible to measure how much memory an application has committed—the memory the operating system has guaranteed the application that it can access. However, the application will not necessarily use all of that memory, and it certainly is not using all of that memory at any one time.
  • [1224] Network usage overhead—A terminal server is confined by the bandwidth supported by its network interfaces, the amount of bandwidth each of the systems processors can sustain transmission of, and the utilization required by each processor to transmit network traffic.
  • [1225] Effects of color depth—Sessions engaged with high-color depth (e.g., 24 bits/pixel) require significantly more bandwidth and subsequently reduce the total system effectiveness and scalability.
  • [1226] Effects of login activity on CPU—Account first use and session startup are very resource-intensive actions and will affect the end performance of the connecting session and already active sessions.
  • [1227] Effects of kernel address space limitations—The majority of operations performed by the Microsoft Windows Terminal Server are done in the Windows kernel. Thus, the more user sessions active the more memory that is necessary in kernel space. The Windows kernel has a hard limit to the size in which the kernel memory footprint can be. If that footprint is used up, additional sessions cannot be run regardless if there is sufficient free physical memory remaining for allocation.
  • [1228] Effect of application processes—Studies have shown background grammar checking in Microsoft Word had a significant negative impact on scalability, reducing the number of users supported.
  • [1229] Effect of User interactions—Such as typing rates on CPU utilization, user opening, and closing of applications.
  • [1230] Support for audio/video—The effect of audio/video processing and transmission by the Microsoft Windows Terminal Server may be significant.

[1231] Component Architecture

[1232] In one embodiment, the CAB Terminal Server may consist almost entirely of Microsoft COTS products, thus the actual architecture of the Terminal Server is beyond the scope of this document. The CAB Terminal Server is presented here because it is a component of the overall CAB system. The CAB requirements that are solely met by the CAB Terminal Server component are preferably readily supported by any terminal server product chosen.

[1233] In this embodiment, while the CAB Terminal Server may be based on COTS products, proper configuration is preferable to ensure reliability and performance standards are met. In addition, low-side user accounts for CAB users may be maintained on the Terminal Server.

[1234] Virtual Desktop Protocol (VDP)

[1235] In this embodiment, the Virtual Desktop Protocol is a protocol for communications between CAB components. More specifically, VDP may be used for communications between the Client and Guard, and between the Guard and Translator. In one embodiment, VDP communications may coordinate among multiple load-balanced Guards and multiple load-balanced Translators.

[1236] In this embodiment, it is preferably that each CAB component implement VDP in the same fashion. This consistency allows for code reuse and helps to ensure compatibility between components. The subsections below describe the consistent implementation and provide further details to support the consistency.

[1237] Protocol Definition

[1238] Session Startup

[1239] In one embodiment, VDP assumes that the client application knows the network location (IP address/port) and domain classification of the VDP server to which they are connecting. Thus, in this embodiment, VDP provides no negotiation regarding server discovery.

[1240] In one embodiment, VDP does not provide any inherent confidentiality or integrity mechanisms to protect the content of the packets transmitted. For this reason, the assumption is that VDP will be used from within a tunnel (SSL, TLS, IPSEC, L2TP and PPTP) that provides an adequate level of confidentiality and integrity.

[1241] In this embodiment, a VDP session may begin with the client connecting to the server using the Transmission Control Protocol (TCP). There may be no restrictions regarding the port number on which the server runs. Port assignment of the VDP server may be left up to the server itself.

[1242] In this embodiment, following a successful TCP connection, the authentication sequence preferably begins. This sequence begins with server sending an authentication capabilities packet that identifies the supported authentication methods available to the client. In one embodiment, VDP supports a simple form of user password authentication to identify the connecting user. In other embodiments, other known authentication methods may also be used.

[1243] In this embodiment, following successful authentication, the client preferably receives a capability packet including the allowed options for the current session and settings from the previous connection if they exist. The client preferably next sends a connection request packet that includes the options they wish to use during the session. Upon processing this request, the server will preferably first respond with a status message indicating whether the selected settings have been accepted or denied. If the selected settings are accepted, the server may be responsible for then establishing a connection with the remote desktop session and responding to the client with an indication of success or failure. Reasons for failure include an invalid user/password or password expiration. In this case, it is up to the client to initiate a password change request before future authentication requests.

[1244] In this embodiment, following a successful connection response, normal user input traffic can commence.

[1245] User Input

[1246] In this embodiment, there may be two basic forms of user input supported by VDP: Keyboard and Mouse input.

[1247] Keyboard

[1248] In one embodiment, VDP supports the keys available, for example, on a standard 101-key keyboard plus the two Microsoft window keys and one context key (effectively a Microsoft 104-key keyboard).

[1249] In this embodiment, VDP may use a key encoding consistent with the scan codes defined, for example, in the Microsoft Windows operating system for 101/104-key keyboard types.

[1250] In this embodiment, keyboard input may be transmitted in forms including:

• • [1251] Key string: Used to group a sequence of entered characters together into a string for submission all at once. This method may be used as the default input method for input keys with a visual representation.
  • [1252] Scancode: A virtual hardware code used to identify the key based on physical location on the keyboard. This allows any key on a 104-key keyboard to be handled independent of the keyboard layout.
  • [1253] Virtual Key: A standardized code used to represent special keys or key sequences such as (Ctrl-Alt-Delete or Alt-Tab).

[1254] Input Methods

[1255] In this embodiment, VDP may support types of text input methods including:

• • [1256] Buffered Input
  • [1257] Direct Input

[1258] In this embodiment, buffered input may be the default input method for keyboard keys that have a visual representation. This input method may be provided so that text input will be controlled by the end-client and transmitted at one time for entry into the system.

[1259] In this embodiment, direct input allows the user to send each character as a sequence of key-press and key-release events. This input method provides a more realistic user experience by simulating the normal keyboard input method that would be used on a local machine. When direct input mode is enabled, the client can send every key defined on their keyboard using the key-press and key-release packets.

[1260] Key Layouts

[1261] In this embodiment, variable keyboard layouts are supported because they allow the user to orient their keyboard to the language to which they are accustomed. When typing on a Windows system in another language, it helps to have the keyboard laid out in a way that is more conducive or standardized to fit that language.

[1262] In one embodiment, the default keyboard layout used by VDP is QWERTY, also identified as “en-us.” The QWERTY keyboard gets its name from the first six top-level characters: “Q,” “W,” “E,” “R,” “T,” and “Y” on a standard United States keyboard. The en-us keyboard layout is identified by the code 0x0409.

[1263] Another embodiment may support layouts or input methods that require text input in ways other than simply typing the keyboard (i.e., complex languages with thousands of character sets such as Japanese, Chinese or Korean).

[1264] Mouse

[1265] In one embodiment, VDP supports standard mouse input. Examples supported include those mouse with up to three buttons and a scroll wheel. It is preferable for mouse input use that there are at least two buttons.

[1266] In this embodiment, VDP may support two basic modes of mouse-click input:

• • [1267] Raw
  • [1268] Interpreted

[1269] In this embodiment, the raw mouse input mode may rely on the remote server for detection and handling of multiple click-and-drag based events. In this mode, the client will send press-and-release events for every mouse click that occurs. The remote server can then detect whether a double-click, triple-click, drag, or drop event occurred based on the frequency in which the event was received.

[1270] In this embodiment, in interpreted mouse input mode, it may be up to the client to detect when double-click, triple-click, and drag-based events occur. When detected, the client would send event-specific messages to the server instead of generic press-and-release events.

[1271] In one embodiment, interpreted mode has been provided for systems that regularly have inconsistent latency. In these situations, if the press-and-release events are not processed and sent to the remote desktop server in the speed in which they were received, the remote server may not detect quick key presses as double-clicks. Interpreted mode provides a way of bypassing this problem by leaving the detection up to the local client. By using the interpreted mode, the server can preferably guarantee that the respective click events would be packaged together so that the multiclick event is properly detected.

[1272] In this embodiment, in addition to the two different click-input modes, VDP may also support mouse movement and scroll wheel movement. For these two types of input, it may be up to the server to instruct the client if these types are currently enabled and the frequency in which they should be sent.

[1273] Server Output

[1274] In this embodiment, VDP Output messages sent from the remote server can be broken down into two basic categories:

• • [1275] Drawing Commands: Commands that affect the users' visual display of their desktop current session
  • [1276] Caching Requests: Requests to store drawing content in the client's memory for later retrieval and drawing.

[1277] In one embodiment, VDP has been designed so that the administrating server can configure the operations to support for each user session it manages. This includes both caching requests and drawing commands. At connection time the server may inform the client which operations it can expect based upon the configuration settings on the server (via the connection response message).

[1278] In this embodiment, a VDP session preferably supports these basic operations:

• • [1279] Bitmap drawing: Painting bitmaps on the screen
  • [1280] Cursor updates: Changing the current mouse cursor
  • [1281] Palette updates (if 8-bit color is supported): Changing the palette for all future bitmaps.

[1282] Drawing Commands

[1283] In this embodiment, drawing commands may include any operation that directly or indirectly affects the user's visual picture of the screen. This may include the following commands:

• • [1284] Clear
    • [1285] Screen: Region of the screen is cleared with a color and bitwise operator
    • [1286] Pattern: Clearing of a region of the screen using a patterned brush and bitwise operator.
  • [1287] Draw
    • [1288] Bitmap: Drawing of a bitmap to the screen potentially decompressing it first
    • [1289] Text: Request to draw text based on a previously cached font
    • [1290] Cursor: Request to change the current cursor
  • [1291] Copy:
    • [1292] Memory: Copying of a bitmap from the cache to the screen using a bitwise operator
    • [1293] Screen: Copy of one region of the screen to another using a bitwise operator

[1294] In this embodiment, the copy and clear-based drawing commands may use some form of bitwise operator to perform their operations.

[1295] Image Formats

[1296] In one embodiment, there may be five relevant binary image or image-related formats that are defined by or referenced by this specification:

• • [1297] Bitmap Images: Major updates to the screen are performed with and on device-independent bitmaps. This may be defined by the Common Image Format (CIF) standard.
  • [1298] Bitmap Compression: Refers to the algorithms used to compress bitmap images for transit. This is also defined by the CIF standard.
  • [1299] Palettes: Palettes are needed for bitmap images with 8-bit or less color depth. This is also defined by CIF standard.
  • [1300] Cursors: Refers to the images used to display a user's mouse cursor.
  • [1301] Font Glyphs: Refers to the images used to display text-based output to the screen.

[1302] Caching Requests

[1303] In this embodiment, caching requests include operations that involves storing image-related data in the client's memory for later retrieval and lookup. The caching feature enables the system to store commonly used data with the client for later lookup and usage. This prevents the server from having to send the same image to a client numerous times.

[1304] In this embodiment, the following caching requests may be available:

• • [1305] Bitmap cache: Bitmap sent specifically to be cached
  • [1306] Screen Cache: Saving a region of the screen for later painting
  • [1307] Cursor Cache: Saving of a cursor bitmap
  • [1308] Font Cache: Font sent as an array of glyphs for later text output.

[1309] In one embodiment, when each of these commands is issued by the server, included is a cache index that tells the client where to store the data. The cache size in bytes and elements expected by the client is dictated by the administrating server via the capabilities packet using the “Cache Size” Type Length Value (TLV) type.

[1310] Capabilities

[1311] In this embodiment, following a successful authentication process, the client may receive a capabilities packet that includes various capability fields, for example, color depth, drawing capability and key layout. The capability fields may define what options are available to that user's session and any information about that client's previous settings from the last connection.

[1312] Shutdown and Error Management

[1313] In this embodiment, VDP may provide two basic packets for shutting down a session:

• • [1314] Session Shutdown
  • [1315] Session Timeout

[1316] Session Shutdown

[1317] In this embodiment, the session shutdown message may be sent whenever a node in the system that is aware of the current VDP session wishes the session be completely terminated. Accompanying the shutdown message may be a reason or status code that the sender can use to indicate to the end-client the reason for the shutdown. This reason could be both a fatal and non-fatal shutdown; there are no restrictions as to how this field is used. For example, the client can use the Session Shutdown packet to close the session completely or request that the session be suspended for later opening.

[1318] Session Timeout

[1319] In this embodiment, VDP may recognize different types of timeouts, including:

• • [1320] Idle Timeout: Refers to the amount of time that the user's session must remain idle for the server to forcefully shut down the connection
  • [1321] Suspend Timeout: Refers to the amount of time the server will save the session upon receiving a user-initiated suspension. The suspend feature is initiated using a Session Shutdown message with the suspend reason set. This feature exists to allow the user pause their session and reconnect to it later or on a different machine.
  • [1322] Cached Timeout: Refers to the amount of time that the remote desktop server will cache a user's session before logging it out and completely removing all user states. By default, most remote desktop servers will cache a user's logged-in session locally for a specified time. This is done so every authentication to the remote session does not require the overhead of startup. This cached session remains for the cache timeout period unless the user explicitly logs them selves out of the remote session.

[1323] In this embodiment, the session timeout message may be sent to the end-client to indicate a system-enforced shutdown because of idle or suspend-based timeout. Included in this message may be specific details about the time that just expired and how long the session will be cached for later reconnection. When the client initiates a shutdown, the user can additionally receive a session timeout message indicating how long the connection will be cached on the remote desktop server in a suspended or cached state.

[1324] Protocol Structure

[1325] In this embodiment, Although not explicitly defined by each packet in this section, packets are preferably aligned to a 4-byte boundary. Any packet that does not already align to this boundary is preferably padded with zeros to ensure that the 4-byte boundary requirement is maintained.

[1326] Packet Header

[1327] In one embodiment, the packet header may be composed of five fields, as shown in the table below. Each packet described may start with the packet header defined below. The size and offset columns are represented in bytes.

[1328]

VDP Packet Header Layout
Offset	Size	Name	Type	Description
0	4	Identifier	ascii	Unique number used to
				identify the VDP packet
				(0x56445000 = “VDP\0”)
4	2	Version	uint16	Identifies what version of the
				protocol to use. The High
				order byte represents a major
				version and the low order byte
				represents a minor version
				(0x0100 = version 1 .0)
6	2	Packet	uint8	Primary packet type use to
		Type		categorize the packet.
8	2	Sub Packet	uint16	Secondary packet type.
		Type
10	2	Payload	uint16	Length of the payload in four
				byte words (0x0100 = 16
		Length		words * 4 bytes/word =
				64 bytes). VDP packet can
				have a maximum length of
				65535 words or 266,122 bytes.

[1329]

[1330] In one embodiment, the CAB implementation additionally subdivides the packet-type field into the following logical fields (offsets are from within the packet type field above):

[1331]

CAB Packet Type Field
Bits
Offset	Size	Name	Type	Description
0	1	Upstream	bit	Indicates if the packet is going
				upstream or downstream. Setting
				the bit means that the packet
				should be moving upstream.
				Otherwise, the packet should
				be moving downstream.
1	7	Segment	uint	ID indicating on which segment
				in the cab architecture the packet is
				being transmitted.
8	8	Type	uint8	Type code for the packet

[1332] In one embodiment, the CAB system refers to the terms Upstream and Downstream in the opposite way of conventional definitions. In the CAB system:

• • [1333] Upstream refers to packets moving from the low domain to the high domain (e.g., Terminal Server→Translator→Guard→Client)
  • [1334] Downstream refers to packets moving from the high domain to the low domain (e.g. Client→Guard→Translator→Terminal Server)

[1335] In this embodiment, the changes above result in the following exemplary packet header:

[1336]

CAB VDP Header

[1337] Exemplary CAB Segment IDs:

[1338]

CAB Segment IDs
ID	Segment	Description
0x0001	Client		Guard	Packets sent between the client and
				guard
0x0002	Guard		Translator	Packets sent between the guard
				and the translator
0x0003	Guard		Guard	Packets sent between two guards
				for Inter Guard Communication
				(IGC). This is used for load
				balancing and guard
				synchronization
0x0004	Client		FTG	Packets sent between the client
				and the file transfer guard
				specifically for file transfers
0x0005	Translator		FTG	Packets sent between the
				translator and the file transfer
				guard specifically for file transfers

[1339] Packet Types

[1340] In this embodiment, the packet type section may be used to identify valid packets supported in VDP, their corresponding packet type and subpacket type codes, as well as their physical make-up. This following table enumerates the exemplary packet types and subtypes. The length column in the table below is used to identify the preferably number of bytes needed for each packet (this does not include the 12 bytes required for the header).

[1341]

VDP Packet Types
Type	Subtype	Length
ID	Name	ID	Name	(bytes)	Description
0x0001	Authentication	0x0001	User/Password	76	Standard user password request
			Request
		0x0002	User/Password	4	Standard user password
			response		response
		0x0003	Change Password	140	Request to change the current
					password
		0x0004	Change Password	2	Password Change Response
			Response
		0x0005	Auth Capabilities	4	Describes the available
					authentication methods
0x0002	State	0x0001	Session	8	Sent to indicate a shutdown of
			Shutdown		the session, forceful or
					otherwise
		0x0002	Session Timeout	14	Sent to indicate a timeout based
					shutdown
		0x0003	Client	518	Sent to the client to notify it of
			Notification		some event
0x0003	Capabilities	0x0001	Capabilities	Var.	Sent to provide the client with a
					set of valid options for their
					current session
		0x0002	Connection	Var	Send by the client to initiate a
			Request		connection with the server
		0x0003	Connection	Var	Sent by the server to confirm
			Response		the connection response
0x0004	User Input	0x0001	Keyboard Press	4	User presses a keyboard key
		0x0002	Keyboard	4	User releases a keyboard key
			Release
		0x0003	Key string	Var.	User enters a captured string
		0x0004	Mouse Press	6	User clicks a mouse button
		0x0005	Mouse Release	6	User releases a mouse button
		0x0006	Mouse Move	4	User moves the mouse
		0x0007	Mouse Scroll Up	4	User moves the mouse scroll
					wheel up
		0x0008	Mouse Scroll	4	User moves the mouse scroll
			Down		wheel down
		0x0009	Mouse Single-	6	User completed a single mouse
			Click		click
		0x000A	Mouse Double-	6	User completed a double
			Click		mouse click
		0x000B	Mouse Triple-	6	User completed a triple mouse
			Click		click
		0x000C	Mouse Drag	6	User-initiated dragging
		0x000D	Mouse Drop	6	User completed a drop
0x0005	Drawing	0x0001	Palette Update	Var.	Contains a new palette to use
	Command				for all future 8-bit images.
		0x0002	Cursor Update	Var.	Contains a new cursor image
		0x0003	CIF Paint	Var.	Contains 1 . . . N new images to
					be drawn
		0x0004	Clear	12	Clears a region of the screen
					using a specified color or
					operation
		0x0005	Pattern Clear	29	Clears a region of the screen
					using a bitwise operation and
					patterned brush
		0x0006	Screen Copy	14	Copies one area of the screen to
					the other using a bitwise
					operation
		0x0007	Cache Copy	16	Copies a cached bitmap to the
					screen using a bitwise operation
		0x0008	Cached Cursor	2	Request to change the cursor
			Draw		from cache
		0x0009	Cached Text	Var.	Request to draw text from
			Draw		cache
0x0006	Cache	0x0001	Cursor Cache	Var.	Cursor to cache
	Request	0x0002	Screen Cache	10	Request to cache a section of
					the screen
		0x0003	Bitmap Cache	12	A bitmap to store in the cache
		0x0004	Font Cache	Var.	A array of font glyphs to cache
0x0007	Health	0x0001	Client Request	6	Request for health status
					information
		0x0002	Client Response	12	Health status information
0x0008	Audit/log	0x0001	Remote Log	284	Send a log entry

[1342] In this embodiment, the table below shows examples of the valid packets for each segment and the direction in which they are allowed.

[1343]

CAB Valid Segment ID and Packet Mappings
Segment	Dir.	Type	Subtype
C G(1)	Down	Authentication (0x01)	User/Password Request (0x0001)
		Authentication (0x01)	Change Password Request(0x0003)
		Capabilities (0x03)	Connection Request (0x0002)
		User Input (0x04)	All Subtypes (0x0001-0x000C)
		Health (0x07)	Health Client Request (0x0001)
		Audit/Log (0x08)	Remote Log (0x0001)
	Up	Authentication (0x01)	User/Password Response (0x0002)
		Authentication (0x01)	Change Password Response (0x0004)
		State (0x02)	Session Timeout (0x0002)
		State (0x02)	Client Notification (0x0003)
		Capabilities (0x03)	Capabilities (0x00001)
		Capabilities (0x03)	Connection Response (0x0003)
		Drawing Ops (0x05)	All Subtypes (0x0001-0x0009)
		Caching Ops (0x06)	All Subtypes (0x0001-0x0004)
		Health (0x07)	Health Client Response (0x0002)
	Both	State (0x02)	Session Shutdown (0x0001)
G T(2)	Down	Capabilities (0x03)	Connection Request (0x0002)
		User Input (0x04)	All Subtypes (0x0001-0x000C)
	Up	State (0x02)	Session Timeout (0x0002)
		Capabilities (0x03)	Connection Response (0x0003)
		Drawing Ops (0x05)	All Subtypes (0x0001-0x0009)
		Caching Ops (0x06)	All Subtypes (0x0001-0x0004)
	Both	State (0x02)	Session Shutdown (0x0001)