Abstract:
A mobile wireless device programmed with software which provides a trusted user interface for the device by allowing the content of a secure screen memory to be modifiable only by authorised applications. Normally, the entire screen memory address is public information, making the entire screen memory fully available to any application; hence, even sensitive dialogs would use screen memory which can in theory be looked at by malicious software, enabling that malicious code to grab PIN data etc. or corrupt a trusted user interface. But with the present invention, unauthorised applications are prevented from accessing the data displayed by the secure frame buffer because they are able to access only the non-secure screen memory. Hence, malicious applications cannot retrieve data from a trusted dialog or compromise that data. Further, as the present invention is a software only solution, it requires no new hardware per se—the only requirement is that components (e.g. a software window server; a video chip etc.) can select content from different parts of screen memory—i.e. secure and non-secure frame buffers.

Description:
FIELD OF THE INVENTION  
       [0001]     This invention relates to a trusted user interface for a secure mobile wireless device. The user interface forms an element of a platform security architecture.  
       DESCRIPTION OF THE PRIOR ART  
       [0002]     Platform security covers the philosophy, architecture and implementation of platform defence mechanisms against malicious or badly written code. These defence mechanisms prevent such code from causing harm Malicious code generally has two components: a payload mechanism that does the damage and a propagation mechanism to help it spread. They are usually classified as follows: 
        Trojan horse: poses as a legitimate application that appears benign and attractive to the user.     Worm: can replicate and spread without further manual action by their perpetrators or users.     Virus: Infiltrates legitimate programs and alters or destroys data.        
 
         [0006]     Security threats encompass (a) a potential breach of confidentiality, integrity or availability of services or data in the value chain and integrity of services and (b) compromise of service function. Threats are classified into the following categories: 
    1. Threats to confidentiality and integrity of data. Examples: Get users password; corrupt files.     2. Threats to confidentiality and integrity of services. Examples: Use bandwidth from phone network subscriber without paying for it; repudiate transaction with network service provider.     3. Threats to availability of service (also called denial of service). Examples: Prevent the user from sending a text message; prevent the user from accepting a telephone call.    
 
         [0010]     Games are an important application category for mobile wireless devices, but expose the device to high levels of security risk Usually, games require direct access to the screen memory or to a graphic accelerator in order to perform fast bitmap operations. However, allowing direct access to the screen is an open door to the following threats: 
    1. Denial of service 
        1.1. Make the screen unreadable by erasing/scrambling pixel values     1.2. Display fake error messages to prevent the user to use some applications    
        2. Confidentiality breach 
        2.1. Fake trusted user interface dialogs to get confidential data as password     2.2. Capture pixel values written by another application to retrieve confidential data    
       
 
         [0017]     Hence, conventional screen memories (also known as frame buffers) present an Achilles heel to platform security since applications such as malicious or badly written games can grab or alter sensitive information (e.g. passwords etc.) displayed on screen. Hewlett Packard PCT/GB00/02005 shows one possible approach to solving this aspect of platform security: it discloses a PC with a secondary, secure hardware system (video chip, frame buffer) to prevent unauthorised access to sensitive information. The user interface can therefore be thought of as trusted when sensitive information is being displayed. This hardware solution would however be prohibitively expensive to implement in a mobile wireless device (typically a ‘smartphone’, enhanced mobile telephone, PDA or other personal, portable computing device) because of space and cost constraints.  
         [0018]     Hence, mobile wireless devices offer very considerable challenges to the designer of a platform security architecture. To date, there have been no effective proposals for trusted user interfaces for secure mobile wireless devices.  
       SUMMARY OF THE PRESENT INVENTION  
       [0019]     In a first aspect of the present invention, there is a mobile wireless device programmed with software which provides a trusted user interface for the device by allowing the content of a secure screen memory to be accessible or modifiable only by authorised applications, the software operating automatically to detect whether an application is an authorised application, to thereby eliminate the need to deploy additional secure hardware as a mechanism for ensuring the integrity of the secure screen memory.  
         [0020]     In one implementation, the address locations of the secure screen memory are known only to the window server and the kernel, which can make this memory available solely to executable code with the appropriate capability. ‘Capability’ refers to a property assigned to executable code which defines the sensitive actions which that code can perform or the sensitive resources which that code can access.  
         [0021]     Secure and non-secure frame buffers are usually physically distinct parts of the same RAM based screen memory and hence no costly hardware duplication is required for implementation (e.g. no separate secure hardware crypto-processor, memory or display processor, as required in some prior art solutions).  
         [0022]     The secure screen memory provides a trusted resource so that sensitive dialogs (e.g. entering PINs or digitally signing a document) can take place in a secure environment. Normally, the entire screen memory address is public information, making the entire screen memory fully available to any application; hence, even sensitive dialogs would use screen memory which can in theory be looked at by malicious software, enabling that malicious code to grab PIN data etc. or corrupt a trusted user interface.  
         [0023]     But with the present invention, unauthorised applications are prevented from accessing the data displayed by the secure frame buffer because they are able to access only the non-secure screen memory. Hence, malicious applications cannot retrieve data from a trusted dialog or compromise that data. Further, as the present invention is a software only solution, it requires no new hardware per se—the only requirement is that the software window server and the video device driver run by the kernel can select content from different parts of screen memory—i.e. secure and non-secure frame buffers.  
         [0024]     A further feature is that input events such as keyboard, mouse and pen events are collected by the kernel and sent to the window server only. The window server is responsible for dispatching events to the appropriate window&#39;s process owner. In trusted user interface (UI) mode, no input events can be globally captured or redirected in order to prevent an un-trusted application to grab sensitive information typed by the user, such as a password.  
         [0025]     In an implementation, there is a visual indication is provided to the user when the trusted user interface is active; the indication can be hardware based, such as a particular LED being lit. It can also be software based, such as a particular screen icon or message being displayed in an area of the screen forbidden to other applications. In all cases it is under the control of the kernel. Only the window server, owner of the secure frame buffer, can ask the kernel to switch this indicator on or off, hence providing a way for the user to identify a genuine trusted dialog from a fake one.  
         [0026]     In another aspect, there is an operating system adapted to run on a secure mobile wireless device in which the operating system provides a trusted user interface for the device by allowing the content of a secure screen memory to be accessible or modifiable only by authorised applications, the software operating automatically to detect whether an application is an authorised application, to thereby eliminate the need to deploy additional secure hardware as a mechanism for ensuring the integrity of the secure screen memory.  
     
    
     DETAILED DESCRIPTION  
       [0027]     The present invention will be described with reference to the security architecture of the Symbian OS object oriented operating system, designed for single user wireless devices. The Symbian OS operating system has been developed for mobile wireless devices by Symbian Ltd, of London United Kingdom.  
         [0028]     In this architecture, a trusted path between the user and the OS kernel is provided: this prevents untrusted applications from retrieving or compromising data from a trusted dialog.  
         [0000]     1 Trusted Computing Platform  
         [0000]     1.1 Trusted Computing Base  
         [0029]     A trusted computing base (TCB) is a basic architectural requirement for robust platform security. The trusted computing base consists of a number of architectural elements that cannot be subverted and that guarantee the integrity of the device. It is important to keep this base as small as possible and to apply the principle of least privilege to ensure system servers and applications do not have to be given privileges they do not need to function. On closed devices, the TCB consists of the kernel, loader and file server, on open devices the software installer is also required. All these processes are system-wide trusted and have therefore full access to the device. This trusted core would run with a “root” capability not available to other platform code (see section 2.1).  
         [0030]     There is one other important element to maintain the integrity of the trusted computing base that is out of the scope of this invention, namely the hardware. In particular, with devices that hold trusted computing base functionality in flash ROM it is necessary to provide a secure boot loader to ensure that it is not possible to subvert the trusted computing base with a malicious ROM image.  
         [0000]     1.2 Trusted Computing Environment  
         [0031]     Beyond the core, other system components would be granted restricted orthogonal system capabilities and would constitute the Trusted Computing Environment (TCE); they would include system servers such as phone and window servers . . . For instance the window server would not be granted the capability of phone stack access and the phone server would not be granted the capability of direct access to keyboard events. It is strongly recommended to give as few system capabilities as possible to a software component to limit potential damage by any misuse of these privileges.  
         [0032]     The TCB ensures the integrity of the full system as each element of the TCE ensures the integrity of one service. The TCE cannot exist without a TCB but the TCB can exist by itself to guarantee a safe “sand box” for each process.  
         [0000]     2 Process Capabilities  
         [0033]     A capability can be thought of as an access token that corresponds to a permission to undertake a sensitive action. The purpose of the capability model is to control access to sensitive system resources. The most important resource that requires access control is the kernel executive itself and a system capability (see section 2.1) is required by a client to access certain functionality through the kernel API. All other resources reside in user-side servers accessed via IPC [Inter Process Communication]. A small set of basic capabilities would be defined to police specific client actions on the servers. For example, possession of a make calls capability would allow a client to use the phone server. It would be the responsibility of the corresponding server to police client access to the resources that the capability represents. Capabilities would also be associated with each library (DLL) and program (EXE) and combined by the loader at run time to produce net process capabilities that would be held by the kernel. For open devices, third party software would be assigned capabilities either during software installation based on the certificate used to sign their installation packages or post software installation by the user. The policing of capabilities would be managed between the loader, the kernel and affected servers but would be kernel-mediated through the IPC mechanism.  
         [0034]     The key features of the process capability model are: 
        It is primarily focused around system servers and client-server IPC interactions between these entities.     Capabilities are associated with processes and not threads. Threads in the same process share the same address space and memory access permissions. This means that any data being used by one thread can be read and modified by all other threads in the same process.     The policing of the capabilities is managed by the loader and kernel and through capability policing at the target servers. The kernel IPC mechanism is involved in the latter.     When the code is not running, capabilities are stored inside of libraries and programs. Capabilities stored in libraries and programs are not modifiable, as they would be stored during installation in a location that is only accessible by the Trusted Computing Base.     Not all servers would have to handle client capabilities. Servers would be responsible for interpreting capabilities as they wish.     The only cryptography involved in this scheme might be at the software installation stage where certificates would be checked off against a suitable root certificate. 
 
 2.1 System Capabilities: Protecting the Integrity of the Device 
 
 Root. “Full Access to All Files—Can Modify Capabilities Associated With Executables”
       
 
         [0041]     “Root” capability—Used by the Trusted Computing Base only, it gives full access to all files in the device.  
         [0000]     System Capabilities  
         [0042]     Some system servers require some specific access to the Trusted Computing Base.  
         [0043]     Because of the object-oriented implementation of Symbian OS, the kind of resources required by a system server is most of the time exclusive to it. Therefore, one system server would be granted some system capability that would be orthogonal to those required by another. For instance, the window server would be granted access to keyboard and pen events issued by the kernel but it would not have permission to access the phone stack. In the same way, the phone server would be granted access to the phone stack but would not have permission to collect events from the kernel. As examples, we can name:  
                                       WriteSystemData   Allows modification of configuration system data       CommDD   Grants access to all communication and Ethernet card           device drivers.       DiskAdmin   Can perform administration task on the disk (reformat,           rename a drive, . . . ).                  
 
 2.2 User-Exposed Capabilities: Mapping Real-World Permissions 
 
         [0044]     The process of generating capabilities can be difficult. One has first to identify those accesses that require policing and then to map those requirements into something that is meaningful for a user. In addition, more capabilities means greater complexity and complexity is widely recognised as being the chief enemy of security. A solution based on capabilities should therefore seek to minimise the overall number deployed. The following examples map fairly broadly onto the main threats which are unauthorised access to system services (eg. the phone stack and preserving the confidentiality/integrity of user data. 
    PhoneNetwork. “Can access phone network services and potentially spend user money”
        “Make telephone calls”    “Send short text messages”.    
        WriteUserData. “Can read and modify users private information”
        “Add a contact”.     “Delete an appointment”.    
        ReadUserData. “Can read users private information”
        “Access contacts data”.     “Access agenda data”.    
        LocalNetwork. “Can access local network”
        “Send Bluetooth messages”.     “Establish an IR connection”    “Establish an USB connection”   
        Location. “Can access the current location of the device”
        “Locate the device on a map”    “Display closest restaurants and cinema”   
       
 
         [0061]     It is necessary to make a distinction between PhoneNetwork and LocalNetwork because it is possible to transmit information across a network without spending any money (eg. Bluetooth piconet). This kind of access may be a very useful third party software enabler but nonetheless represents a local way of leaking sensitive information via a trojan horse so it must be protected with a capability, albeit LocalNetwork PhoneNetwork, if granted by the user, would allow trojans seeking to use the phone network as their exit route; that is potentially much more damaging and hence the blunt warning in its description.  
         [0062]     Root and system capabilities are mandatory; if not granted to an executable, the user of the device cannot decide to do it. Their strict control ensures the integrity of the Trusted Computing Platform. However the way servers check user-exposed capabilities or interpret them may be fully flexible and even user-discretionary.  
         [0000]     2.3 Assigning Capabilities to a Process  
         [0063]     The association of a run-time capability with a process involves the loader. In essence, it transforms the static capability settings associated with individual libraries and programs into a run-time capability that the kernel holds and can be queried through a kernel user library API. The loader applies the following rules: 
    Rule 1. When creating a process from a program, the loader assigns the same set of capabilities as its program&#39;s.     Rule 2. When loading a library within an executable, the library capability set must be greater than or equal to the capability set of the loading executable. If not true, the library is not loaded into the executable.     Rule 3. An executable can load a library with higher capabilities, but does not gain capabilities by doing so.     Rule 4. The loader refuses to load any executable not in the data caged part of the file system reserved to the TCB.    
 
         [0068]     It has to be noted that: 
        Libraries&#39; capabilities are checked at load time only. Beyond that, all code contained in libraries is run freely and is assigned the same capability set as the program it runs into when initiating some IPC calls.     For ROM images with execution in place, the ROM build tool resolves all symbols doing the same task as the loader at runtime. Therefore the ROM build tool must enforce the same rules as the loader when building a ROM image.        
 
         [0071]     These rules 
        Prevent malware from being loaded in sensitive processes, for example, a plug-in in a system server     Encourage encapsulation of sensitive code inside processes with no possible bypass        
 
         [0074]     The examples below show how these rules are applied in the cases of statically and dynamically loaded libraries respectively.  
         [0000]     2.3.1 Examples for Linked DLLs  
         [0000]    
       
         
           
              The program P.EXE is linked to the library L1.DLL.  
              The library L1.DLL is linked to the library L0.DLL.  
              Case 1: 
            P.EXE holds Cap1 &amp; Cap2     L1.DLL holds Cap1 &amp; Cap2 &amp; Cap3     L0.DLL holds Cap1 &amp; Cap2.     Process P cannot be created, the loader fails it because L1.DLL cannot load L0.DLL. Since L0.DLL does not have a capability set greater than or equal to L1.LDLL, Rule 2 applies.    
         
              Case 2: 
            P.EXE holds Cap1 &amp; Cap2     L1.DLL holds Cap1 &amp; Cap2 &amp; Cap3     L0.DLL holds Cap1 &amp; Cap2 &amp; Cap3 &amp; Cap4     Process P is created, the loader succeeds it and the new process is assigned Cap1 &amp; Cap2. The capability of the new process is determined by applying Rule 1; L1.DLL cannot acquire the Cap4 capability held by L0.DLL, and P1.EXE cannot acquire the Cap3 capability held by L1.DLL as defined by Rule 3. 
 
 2.3.2 Examples for Dynamically Loaded DLLs 
   
         
              The program P.EXE dynamically loads the library L1.DLL.  
              The library L1.DLL then dynamically loads the library L0.DLL.  
              Case 1: 
            P.EXE holds Cap1 &amp; Cap2     L1.DLL holds Cap1 &amp; Cap2 &amp; Cap3     L0.DLL holds Cap1 &amp; Cap2     Process P is successfully created and assigned Cap1 &amp; Cap2.     When P requests the loader to load L1.DLL &amp; L0.DLL, the loader succeeds it because P can load L1.DLL and L0.DLL. Rule 2 does apply here the loading executable being the process P not the library L1.DLL: the IPC load request that the loader processes is sent by the process P. The fact that the call is within L1.DLL is here irrelevant. Rule 1 &amp; 3 apply as before and P does not acquire Cap3 by loading L1.DLL    
         
              Case 2: 
            P.EXE holds Cap1 &amp; Cap2     L1.DLL holds Cap1&amp;Cap2&amp;Cap3     L0.DLL holds Cap1&amp;Cap2&amp;Cap4     Process P is successfully created and assigned Cap1 &amp; Cap2. When P requests the loader to load L1.DLL &amp; L0.DLL, the loader succeeds it because P can load L1.DLL and L0.DLL. Once again, Rule 2 does apply with P as the loading executable rather than L1.DLL, while Rule 3 ensures P acquires neither Cap3 nor Cap4. 
 
 3 Trusted UI 
   
         
           
         
       
     
         [0100]     The preferred implementation defines a system capability called TrustedUI. Processes running with this capability are defined as trusted for using the trusted user interfaces.  
         [0000]     3.1 Identification of Trusted Dialogs by the User.  
         [0101]     A trusted user interface is required to prevent spoofing of trusted user interface by malicious third party software and thereby provide a trusted path to the user interface within the TCB. This is very important, particularly as we move to the world of multi-functional trusted personal devices acting as smart wallets. For instance, both the PIN enter dialog and the transaction sign dialog would benefit from a comprehensive trusted user interface. If lacking, a malicious application could steal PIN data and use data protected by this PIN without the knowledge of the user.  
         [0102]     There are two ways of showing that a trusted user interface is active: 
        Trusted hardware indicator: For example a trusted LED which goes on when a trusted user interface interaction occurs. This indicator would be accessed through a device driver dedicated to the window server. The window server would ask the kernel to switch this LED on when it would receive a genuine request to display a trusted dialog within a trusted user interface session. At the end of this session, the window server would ask the kernel to switch the LED off.     Trusted software indicator For example a particular symbol/logo on trusted dialogs in a specific part of the screen not accessible to non-executive code. A trusted software indicator would require removal of access to video RAM from general user mode code for this specific part of the screen. 
 
 3.2 Trusted Screen/Keyboard 
       
 
         [0105]     However, trusted dialogs within the context of the Symbian OS platform is about more than a trusted visual indicator and would raise further requirements on client access to the display manager APIs (eg. the window server). It is also about displaying information in a frame buffer that untrusted applications (like games) cannot access and ensuring that keystrokes cannot be captured from a trusted dialog by an untrusted application.  
         [0000]     3.3 Identification of Use Cases  
         [0106]     Games are valuable because of their popularity amongst customers. Their numbers, qualities and “play-ability” are often used as main selling point for smart phones. Usually games require direct access to the screen memory or to a graphic accelerator in order to perform fast bitmap operations. However allowing direct access to the screen is an open door to the following threats: 
        Denial of service 
            Make the screen unreadable by erasing/scrambling pixel values     Display fake error messages to prevent the user to use some applications    
            Confidentiality breach 
            Fake trusted user interface dialogs to get confidential data as password     Capture pixel values written by another application to retrieve confidential data    
               
 
         [0113]     If the economic risk of denial of service attacks is low (the user cannot use his device but other users, network operators and service providers are not touched), the attacks on confidential data are more serious. The attacker might be able to breach the users privacy and/or to spend users money by accessing confidential data.  
         [0114]     To sum up, games have got two main characteristics that require contradictory security features: 
        Games usually need a direct access to the display memory or a direct access to a graphic accelerator driver. Based on the definition of capabilities and the trusted computing environment, they must be granted some system capabilities.     Games are often provided by third parties. They cannot be trusted per se and their audit would imply a long and expensive process that few third parties would like to do.        
 
         [0117]     It is a fundamental security feature that system capabilities must be restricted to core components only. The more applications are granted system capabilities the less relevant the capability model is. This poses a particular challenge for games.  
         [0000]     3.4 Giving Direct Screen Access to Games Without Compromising Trusted Dialogs  
         [0118]     Conventionally, the screen memory address is mapped as global, so in practice every application knowing the address can access the screen memory directly. This address is fixed for each type of mobile wireless devices and therefore if published it can be reused by anyone for this device.  
         [0119]     An implementation of the present invention physically separates the screen memory associated with untrusted applications from the screen memory used by trusted dialogs. The window server will be liable for telling the video driver which frame buffer should be displayed.  
         [0000]     3.4.1 Assumptions  
         [0000]    
       
         
           
              1. One frame buffer (called Fb1) is used by untrusted applications and its address is mapped as global in RAM  
              2. The window server (WSERV) is part of the TCE.  
              3. The second frame buffer (called Fb2) is used by trusted applications to display secure dialogs. Its memory address is protected and can be seen only by the window server and the kernel.  
              4. The untrusted application is called Game.  
              5. The application TApp has been granted TrustedUI system capability.  
              6. UI session, a client-server session between an application and the window server.  
              7. The device has got a trusted LED only modifiable by the window server and the kernel. 
 
 3.4.2 Game Uses Fb1 Address Directly 
 
              1. Game writes or reads pixel values directly from Fb1. 
 
 3.4.3 TApp Asks for WSERV Services 
 
              1. TApp connects WSERV.  
              2. TApp asks WSERV to create a trusted UI session  
              3. WSERV retrieves TApp&#39;s capabilities from the kernel. WSERV verifies that Tapp has got TrustedUI system capability.  
              4. WSERV asks the kernel to use Fb2 as current frame buffer and switch the LED on.  
              5. The kernel verifies that the call is made by WSERV.  
              6. The kernel switches the trusted user interface LED on and activates Fb2 on the video card.  
              7. TApp can create a trusted dialog. 
 
 3.4.4 Game Asks for WSERV Services 
 
              1. Game connects WSERV.  
              2. Game asks WSERV to create a trusted UI  
              3. WSERV retrieves Game&#39;s capabilities from the kernel. WSERV verifies that Game has not got TrustedUI.  
              4. WSERV disconnects Game. 
 
 3.4.5 TApp Closes its Trusted UI Session 
 
              1. TApp asks WSERV to close its trusted session.  
              2. WSERV closes TApp&#39;s trusted session.  
              3. WSERV asks the kernel to use Fb1 and switch the LED off.  
              4. The kernel verifies that the request is made by WSERV.  
              5. The kernel switches the trusted user interface LED off and reactivates Fb1 on the video card. 
 
 3.4.6 Conclusions 
 
           
         
       
     
         [0144]     Even if “two frame buffers” requires more screen memory, it is a good solution for the following reasons 
        1. It does not change the behaviour of the code already witten; Fb1 is still global.     2. The kernel does not need to change MMU mappings in client space.     3. Untrusted applications do not have to terminate or to be killed if the display is required by a trusted dialog. They just continue to use the public screen buffer even if this one is not visible to the user.     4. There is physical screen memory segregation.        
 
         [0149]     In order to protect the user against fake trusted dialog attacks, a LED or reserved screen space must be used. A LED would be preferable, saving screen space and probably be more easily understood by users.