The invention relates to a method for authenticating applications of a computer system.
A computer system is considered in which a certain number of “trusted” services operate in a secure local environment (Trusted Environment). These services offer functions which may be accessed from outside the Trusted Environment. The aim is therefore to control who (and which application) has the right to access each function.
For example, the case of a digital rights management (DRM) agent may be used, which is executed in the Trusted Environment. This DRM agent manages the authorisation for reading MP3 files protected by a DRM license. This license includes, for example, rights to read the MP3 file up to a limited date. The DRM agent is responsible for verifying that the license conditions are respected. Operating in a Trusted Environment helps it in this mission: for example, it has guarantees as to the time and the date of the local system. If the conditions are respected, the DRM agent authorises the reading of the MP3 file. For this purpose, it must provide the standard MP3 player application (which is executed in a standard zone, which is to say outside of the Trusted Environment) the key to decode the MP3 file. Obviously, the DRM agent should not supply this key to an unknown MP3 player application (which for example, could post it on Internet . . . ). It may be seen from this example that the secure service (DRM agent) must authenticate the standard application (MP3 player) which invokes the reading of the MP3 file.
Furthermore, it is easy for a local service to authenticate another local application in closed environments, whether they are closed operating systems (which is to say in which all of the applications are installed initially, under the supervision of an administrator or an approved user) or execution environments. Indeed, if it is a closed operating system, the installation of the application itself is a guarantee of its authenticity as only authorised persons can carry out this operation. If it is an execution environment (virtual machine), the problem is only slightly more complicated as the format of the application is designed to provide the virtual machine with the means to verify its authenticity or integrity (by its construction, a virtual machine handles the code of the applications it executes).
The problem is much more complex in the case of an open system, where new applications may be downloaded freely and installed, and where there are many tools for developing, modifying, debugging and tracing applications. However, the need to find a solution is even more crucial as open systems are used more and more often, including in the field of embedded computing (or buried) systems such as for mobile telephones, portable multimedia players or PDAs (personal digital assistants).
Consequently, certain systems have chosen to integrate advanced security mechanisms within the operating systems. This is the case for example of the capabilities that are found in certain operating systems such as Linux, SELinux (registered trade marks) in particular, where the operating system integrates the notion of authorisation (example of authorisation: “an honest MP3 player application is authorised to use the services of a DRM agent”). This solution has several disadvantages:
Other solutions, such as that of the “Trusted Computing” model are based on the presence of specific security hardware (Trusted Platform Module—TPM) and a cryptographic certification mechanism. In this case, the TPM is charged with providing an external entity with guarantees on the authenticity of the local system. However, the cryptographic certification is designed to provide guarantees on a global system and not on a given application (there are no systems using a TPM to authenticate a local application); furthermore, the addition of dedicated hardware is not necessarily possible in all situations (for technical and/or commercial reasons).
The specific purpose of the invention is therefore to eliminate these disadvantages by means of a method which permits guarantees to be provided locally, on an open operating system and without modifying it, on the authenticity of “standard” applications which are executed outside of the Trusted Environment, to secure services operating within the Trusted Environment, wherein this method permits three different levels of trust to be obtained:
This method permits the authentication of applications of an operating system comprising:
According to the invention, prior to any access to the services of the Trusted Environment by an application, this method comprises the following operating phases:
Advantageously, the process could further feature a “Driver” software component, permitting access to the Trusted Environment from the operating system, and the operations could then be carried out as follows:
Advantageously:
The resources of the computer system controlled by the Trusted Environment may include cryptographic encoding means.
Advantageously, the Trusted Environment (EC) may be executed in a secure microprocessor mode, which provides improved security guarantees.
The invention also relates to an authentication system for applications which uses the method defined above and may be executed on portable equipment such as a mobile telephone, an audio or video player, a PDA, etc.
One mode of execution of the invention will be described below, by way of non-restrictive example and in reference to the appended drawing in which:
The single FIGURE is a diagrammatical representation of the architecture of an authentication system according to the invention.
In this example, the terminal 1 uses:
The switch from the OS2 operating system to the EC Trusted Environment is controlled by a Driver 5, which is to say a small module (or plug-in) which is executed in the kernel of the OS2 operating system.
This Driver is designed to intercept the access requests from a non-secure application (that is executed in the OS2 operating system) to a secure service 4 (that is executed in the Trusted Environment EC).
Following the interception of an access request, the Driver 5 sends to the OS2 operating system the identifier of the application and requests the file containing its executable code. Usually, the operating systems keep this information in a data structure called a process control block (PCB).
The Driver 5 executes a “hashing” operation (such as SHA-1) on the file provided by the OS2 operating system.
The OS2 operating system may further search in the file directory a “manifest” file, which contains the absolute name of all the important files that the application uses (for example a configuration file, a shared library, etc.) and supplies this information to the Driver 5. The Driver 5 then carries out the “hashing” operation, both on the executable manifest file and on all of the files referenced in the manifest file (or just on some of them).
In all cases, the Condensed result provides unique identification of the non-secure application (given that the “hashing” function enables crashes to be avoided). It is then sent to the Trusted Environment for verification of its authenticity. By way of example, the Condensed result may be compared to a list of acceptable Condensed results. If the Condensed result is found, the access to the services offered by the security service 4 may be authorised.
In the example described above, the OS2 operating system only intervenes to identify the files corresponding to the request for access to a service of the EC Trusted Environment and to search for the pertinent information, which falls entirely in the field of an operating system, and does not calculate the Condensed result or carry out an authentication check.
Furthermore, the EC Trusted Environment certificate may also not be based on the OS2 operating system and may be independent from it, as this single FIGURE is only one possible embodiment.
On the Linux (registered trade mark) operating system, the Driver 5 obtains the list of files related to the connection request in line with the following operating sequence, based on the observation that each process is viewed, within the Linux (registered trade mark) kernel, as a task (“struct task_struct”).
Number | Date | Country | Kind |
---|---|---|---|
0513247 | Dec 2005 | FR | national |
Filing Document | Filing Date | Country | Kind | 371c Date |
---|---|---|---|---|
PCT/FR06/02871 | 12/22/2006 | WO | 00 | 11/3/2008 |