DE102014209037A1 - Apparatus and method for protecting the integrity of operating system instances - Google Patents

Abstract

A device (100; 200; 300) is provided. The device (100; 200; 300) comprises a processor unit (110) which comprises one or more processors, a memory unit (120) which comprises nonvolatile memories, an interface (130) for data transmission to an information element (900) and for data reception from the information element (900), and a group of operating system instances (140, 141, 142). The set of operating system instances (140, 141, 142) includes one or more working environment instances (141, 142), wherein each operating system instance (140, 141, 142) of the set of operating system instances (140, 141, 142) has data, the data each Operating system instance (140, 141, 142) of the group of operating system instances (140, 141, 142) are stored in encrypted form in the non-volatile memory of the memory unit (120). The apparatus (100; 200; 300) is arranged, when a check result has a first result, to decrypt the data of a working environment instance (141) of the one or more work environment instances (141, 142) to decrypt data of that work environment instance (141) and, depending on the decrypted data of that work environment instance (141), execute one or more processes associated with that work environment instance (141) on the processor unit (110); and the device (100; 200; 300) is arranged for, if the check result has a second result different from the first result, decrypting the data of none of the one or more working environment instances (141, 142).

Description

The application relates to integrity assurance and more particularly to an apparatus and method for protecting the integrity of operating system containers or virtualized operating system instances.

Communication units, especially mobile communication units, such as smartphones, are now an omnipresent part of our lives. They are used for a wide range of tasks, both in private life and in business. The different tasks that are performed with the smartphone usually have different security requirements. If, for example, online banking is operated with a smartphone, then there are high security requirements. Likewise, for example, there are high security requirements when a mobile communication unit communicates with a corporate network.

Isolation concepts, such as virtualization and container concepts, allow you to deploy multiple, isolated system environments. Examples include system virtualization and operating system level virtualization. A well-known example of system virtualization is Xen and a well-known example of operating system level virtualization are the so-called LinuX containers (LXC). The LXC underlying operating system mechanisms allow several isolated Linux systems to run on one system unit. Specifically, at LXC each container has its own virtual environment. Each of the containers has its own namespaces for, among other things, processes and the file directory system, which are isolated from the other containers and thus inaccessible. However, all containers use the kernel of the underlying operating system. In the case of system virtualization, each instance uses its own kernel, which in turn implements processes. Again, each instance has its own file directory system, which is inaccessible to other instances.

It would be desirable to provide improved concepts that enhance the security of mobile communication units.

The object of the present invention is achieved by a device according to claim 1, by a system according to claim 16, by an information element according to claim 18, by a system according to claim 19, by a method according to claim 20 and by a computer program according to claim 21.

A device is provided. The apparatus comprises a processor unit comprising one or more processors, a memory unit comprising nonvolatile memories, an interface for transmitting data to an information element and for receiving data from the information element, and a group of operating system instances. The set of operating system instances includes one or more working environment instances, each operating system instance of the set of operating system instances having data, and wherein the data of each operating system instance of the set of operating system instances is stored encrypted in the nonvolatile memory of the storage unit. The apparatus is arranged for, when a check result has a first result, decrypting the data of a work environment instance of the one or more work environment instances to generate decrypted data of that work environment instance, and one or more processes dependent on the decrypted data of that work environment instance Working environment instance are assigned to execute on the processor unit; and the apparatus is arranged to, if the check result has a second result different from the first result, decrypt the data of none of the one or more work environment instances.

For example, in one embodiment, the set of operating system instances may further include a login instance. In this case, the interface can be set up to receive cryptographic information or other data from the information element. The device can be set up to decrypt the data of the logon instance based on the cryptographic information or the other data in order to generate decrypted data of the logon instance and, depending on the decrypted data of the logon instance, one or more processes that the Registration instance are assigned to run on the processor unit to provide a graphical user interface that allows user input. Further, in such an embodiment, the interface may be configured to communicate the user input or a broadcast message that depends on the user input to the information element, which interface may be further configured to receive, after this transmission, a response message containing the check result includes. Depending on the result of the check, the decryption and execution of one of the working environment instances, or the decryption and, correspondingly, the execution of one of the working environment instances, then occur.

In another embodiment, a system without a login instance is implemented. This eliminates the PIN entry, but the integrity protection is still implemented.

The device may preferably be a communication unit. Particularly preferably, the device is a mobile communication unit, such. As a smartphone or tablet.

Furthermore, an information element is provided. The information element comprises a memory unit comprising non-volatile memory, a processor unit, and an interface. One or more private cryptographic keys of one or more asymmetric key pairs are stored in the nonvolatile memory of the memory unit. The interface is configured to receive an encrypted cryptographic key or other data, wherein the encrypted cryptographic key is decryptable using the private cryptographic key. The processor unit is configured to decrypt the encrypted cryptographic key or other data using the one or more private cryptographic keys to obtain a decrypted cryptographic key or decrypted data. The interface is designed to output the decrypted cryptographic key or the decrypted data.

Further, the interface is adapted to receive an encrypted PIN which is decryptable using the private cryptographic key or the decrypted data. The processor unit is configured to decrypt the encrypted PIN using the private cryptographic key or the decrypted data to obtain a decrypted PIN. Alternatively, in other embodiments, an unencrypted PIN is transmitted in plain text.

The processor unit is designed to compare the (possibly decrypted) PIN with a stored PIN in order to obtain a check result, wherein the stored PIN is stored in the non-volatile memory of the memory unit. In this case, the check result either has a first result if the check result indicates that the decrypted PIN and the stored PIN match, or it has a second result different from the first result if the check result indicates that the decrypted PIN and the stored PIN do not match. Further, the processor unit is configured to generate a response message comprising the verification result. The interface is designed to output the response message.

The information element is also referred to below as a "secure element". Preferably, the information element is configured as a smart card, which is configured as described below.

• – Wenn ein Überprüfungsergebnis ein erstes Resultat aufweist, Entschlüsseln von Daten einer Arbeitsumgebungsinstanz einer oder mehrerer Arbeitsumgebungsinstanzen einer Gruppe von Betriebssysteminstanzen, um entschlüsselte Daten dieser Arbeitsumgebungsinstanz zu erzeugen, wobei jede Betriebssysteminstanz der Gruppe der Betriebssysteminstanzen Daten aufweist, wobei die Daten jeder Betriebssysteminstanz der Gruppe der Betriebssysteminstanzen im nichtflüchtigen Speicher einer Speichereinheit verschlüsselt gespeichert sind, und, abhängig von den entschlüsselten Daten der besagten Arbeitsumgebungsinstanz, Ausführen von einem oder mehreren Prozessen, die dieser Arbeitsumgebungsinstanz zugeordnet sind, auf einer Prozessoreinheit. Und:
• – Wenn das Überprüfungsergebnis ein zweites Resultat aufweist, das von dem ersten Resultat verschieden ist, kein Entschlüsseln der Daten der ein oder mehreren Arbeitsumgebungsinstanzen.

Furthermore, a method is provided. The method comprises:

• When a check result has a first result, decrypting data of a working environment instance of one or more working environment instances of a set of operating system instances to generate decrypted data of that work environment instance, each operating system instance of the set of operating system instances comprising data of each operating system instance of the set of operating system instances are stored in encrypted form in the nonvolatile memory of a memory unit and, depending on the decrypted data of said work environment instance, executing one or more processes associated with that work environment instance on a processor unit. And:
• If the check result has a second result different from the first result, no decrypting of the data of the one or more work environment instances.

Furthermore, a computer program with a program code for carrying out the method described above is provided.

Embodiments of the present invention are based on deploying operating systems that are isolated from one another on a mobile communication unit and that are specially protected by special access mechanisms against unauthorized access, and whose data integrity is particularly ensured. A so-called secure element, which has an integrated circuit, such as a chip card, plays a special role here. In embodiments of the present invention, the operating system instances of the mobile communication unit are coupled to a particular secure element. As a result, a coupling of the device, z. As a smartphone, to the secure element and vice versa realized.

Hereinafter, preferred embodiments of the invention will be described with reference to the drawings.

The drawings show:

1a shows a device according to a first embodiment,

1b shows a device according to a second embodiment,

2 shows a device according to a third embodiment,

3 shows a device according to a fourth embodiment,

4 shows a device according to a fifth embodiment, and

5 shows an information element according to an embodiment.

1a shows a device according to an embodiment.

The device 100 includes a processor unit 110 which includes one or more processors.

Furthermore, the device comprises 100 a storage unit 120 that includes non-volatile memory.

Furthermore, the device comprises 100 an interface 130 for data transmission to an information element 900 and for receiving data from the information element 900 ,

Furthermore, the device comprises a group of operating system instances 140 . 141 . 142 , The group of operating system instances 140 . 141 . 142 includes one or more work environment instances 141 . 142 ,

Each operating system instance 140 . 141 . 142 the group of operating system instances 140 . 141 . 142 has data. The data of each operating system instance 140 . 141 . 142 the group of operating system instances 140 . 141 . 142 are in the nonvolatile memory of the storage unit 120 stored encrypted.

The device 100 is set up, when a check result has a first result, the data of a working environment instance 141 the one or more work environment instances 141 . 142 to decrypt decrypted data of this working environment instance 141 and depending on the decrypted data of that work environment instance 141 , one or more processes that this work environment instance 141 are assigned on the processor unit 110 perform.

Furthermore, the device 100 when the check result has a second result different from the first result, the data is not set to one of the one or more work environment instances 141 to decode.

Depending on the result of the check, it is therefore possible to decrypt and execute one of the working environment instances, or else the decryption and accordingly also the execution of one of the working environment instances is omitted.

For example, the first result of such a check result may say that the user input has been entered with a PIN that matches the PIN stored in the information item. For example, if the response message contains the second result, the second information may indicate that the user input has been a PIN that does not match the PIN stored in the information element.

Or, for example, a check result may compare a stored hash value and a computed hash value, wherein the stored and calculated hash values are related, for example, to said work environment instance. The first result may indicate, for example, a match of stored and calculated hash value, whereas the second result then indicates a deviation from the stored and calculated hash value.

In embodiments, processor unit 110 , Storage unit 120 and interface 130 attributable to the hardware. The operating system instances 140 . 141 . 142 In contrast, in embodiments are realized by software.

In 1a are two working environment instances 141 . 142 shown. However, a device may have a variety of work environment instances. In embodiments, while the device is in operation, new work environment instances may be created, and existing work environment instances 141 . 142 for example, provided that the user who initiates this has the necessary authorization.

In the device 100 it is preferably a communication unit that is designed to send messages to and from other communication units of a wireless or wired network other communication units to receive messages. It is particularly preferred when it comes to the device 100 is a mobile communication unit designed to send messages to other communication units of a wireless or wired network and to receive messages from these other communication units. For example, the device is 100 to a mobile communication unit, such. As a smartphone or tablet.

The information element 900 is also called a "safe element".

1b shows a device 100 according to a further embodiment. In such an embodiment, the group of operating system instances may be 140 . 141 . 142 for example, a login instance 140 include. The interface can be 130 be set up by the information element 900 to receive cryptographic information or other data.

The device 100 may be arranged for, based on the cryptographic information or the other data, the data of the registration authority 140 to decrypt decrypted data of the login instance 140 and, depending on the decrypted data of the login instance 140 , one or more processes belonging to the login instance 140 are assigned on the processor unit 110 to provide a graphical user interface that allows user input.

Furthermore, in such an embodiment, the interface 130 be configured to the user input or a send message, which depends on the user input to the information element 900 to submit, with the interface 130 Furthermore, it may be arranged to receive a response message comprising the check result after this transmission.

Depending on the result of the check, the decryption and execution of one of the working environment instances will then occur 141 . 142 or the decryption and, correspondingly, the execution of one of the working environment instances 141 . 142 omitted.

Looking at in 1b the overall system that the device 100 and the information element (secure element) 900 In embodiments, the information element 900 be set up for the interface 130 the device 100 to transmit a cryptographic information.

For example, from the device 100 Data is sent, then from the information unit 900 be decrypted and back to the device 100 sent. Such data can z. B. cryptographic information, so a symmetric key for storage encryption.

The device 100 is set up, based on this cryptographic information, the data of the login instance 140 to decrypt to decrypted data of the login instance 140 and, depending on the decrypted data of the login instance 140 , one or more processes belonging to the login instance 140 are assigned on the processor unit 100 to provide a graphical user interface that allows user input. the interface 130 the device 100 is adapted to the user input or a send message that depends on the user input to the information element 900 to convey.

The information element 900 is configured to perform a comparison between stored information and the receive information (eg, between a stored PIN and a PIN entered by the user), the receive information depending on the user input and the send message, respectively. Furthermore, the information element 900 adapted to generate a response message and to transmit to the device, wherein response message comprises a verification result, which has either a first result depending on the comparison, or a second result, which is different from the first result.

the interface 130 the device 100 is set up to receive the reply message. The device 100 is arranged for, if the check result has the first result (the first result indicating, for example, that the input PIN was correct), the data of a working environment instance 141 the one or more work environment instances 141 . 142 to decrypt decrypted data of this working environment instance 141 and depending on the decrypted data of that work environment instance 141 , one or more processes that this work environment instance 141 are assigned on the processor unit 110 the device 100 perform. Furthermore, the device 100 set up, if the check result has the first result (the first result indicating, for example, that the entered PIN was incorrect), the data is not one of the one or more working environment instances 141 . 142 to decrypt (and accordingly none of the one or more work environment instances 141 . 142 execute).

An alternative embodiment, however, does without a login instance, but the integrity protection remains realized.

In embodiments, the PIN may be in the information element 900 be changed. For example, a PIN may consist of (very) many characters, e.g. B. even from any data.

In embodiments, the information element 900 an internal state, which is changed by a correct PIN input and whereby the decryption functionality of the information element is enabled.

Another embodiment is, for example, a virtualized system based on system virtualization. Then there is an operating system kernel per instance and including a hypervisor, e.g. Xen.

2 shows a device 200 according to a further embodiment. In 2 is the kernel 150 the device 200 shown. The operating system kernel 150 is set up based on the above at 1b mentioned cryptographic information, the data of the registration authority 140 to decrypt the decrypted data of the login instance 140 and, depending on the decrypted data of the login instance 140 , the one or more processes mentioned above, the login instance 140 are assigned on the processor unit 110 to provide the graphical interface that allows user input.

Furthermore, the operating system kernel 150 for, when the check result comprises said first result, the data of said work environment instance is established 141 to decrypt the decrypted data of this working environment instance 141 and depending on the decrypted data of that work environment instance 141 , the one or more processes that this work environment instance 141 are assigned to execute on the processor unit. Furthermore, the operating system kernel 150 when the check result has the said second result different from the first information, the data is not set to any of the one or more working environment instances 141 . 142 to decode.

It is further preferred if each of the operating system instances 140 . 141 . 142 based on the operating system Android. In this case, the isolation can preferably be realized on the basis of namespaces. A second option for an operating system would be, for example, GNU / Linux.

It is further preferred if each of the operating system instances is based on Linux. For example, the operating system instances may be implemented as the LinuX container (LXC) known from the prior art discussed above.

3 shows a device 300 According to another embodiment, the device further comprises an operating system instance management layer 160 having. The operating system instance management layer 160 can also act as container management layer 160 be designated.

The operating system instance management layer 160 is formed when the check result has the first result, the kernel 150 submit one or more commands, causing the kernel to read the data of said work environment instance 141 to decrypt the decrypted data of this working environment instance 141 and depending on the decrypted data of that work environment instance 141 , the one or more processes that this work environment instance 141 are assigned on the processor unit 110 and, wherein the operating system instance management layer 160 is formed, if the check result has the second result, the operating system kernel 150 no command to convey through which the kernel 150 would cause the data of one of the working environment instances 141 . 142 to decode.

In this case, in embodiments, the data is not immediately and completely decrypted. Rather, in such embodiments, the key is stored in the Linux kernel and then used as soon as accesses to the file system are made; and even then only the currently used blocks are encrypted or decrypted. For example, in such embodiments, the blocks are additionally cached for faster access.

In the following, preferred embodiments of the invention will be explained in detail.

If the mobile communication unit, for example a smartphone, is started, embodiments of the invention require that the user be provided with a graphical user interface in order to allow the user to enter a PIN. This is known per se from the prior art. In embodiments of the invention, however, there are already one or more of the following peculiarities which distinguish the device according to the invention from the usual state of the art.

On the one hand, the graphical user interface is provided by its own operating system instance, for example by its own LinuX container mentioned above or its own virtual operating system instance. This operating system instance can be called a login instance (or instance0 or android0). Like the other operating system instances, too the logon instance is isolated from the other operating system instances of the device. Thus, in embodiments, it is ensured that the user can not access the data and processes of the operating system instances that provide the actual work environments for the user without correct PIN entry.

If you compare the login instance with a smartphone that uses a lock screen, there are clear differences here as well. On the one hand, in such a state of the art lock screen, the access is protected by a code input which is stored on the smartphone. In contrast, in the mobile communication unit according to the invention, the PIN is not on the mobile communication unit, but on the secure element having an integrated circuit, such as a smart card.

Further, in a prior art smartphone, the lock screen is provided by the underlying operating system. If it is possible to bypass or deactivate the lock, all data and processes of the operating system can be accessed. If, on the other hand, it were possible to bypass the lock screen in the mobile communication unit according to the invention, nothing would be gained, then the attacker would only have access to the login instance, but not to the other operating system instances of the mobile communication unit that are isolated from the login instance include protective data and processes.

Optionally, in one embodiment, the login instance is further encrypted, for example, and can only be decrypted using the secure element.

For example, the logon instance is encrypted in the nonvolatile memory of the mobile communication unit. Furthermore, the registration instance z. B. encrypted by a symmetric key. In turn, these symmetric locks may have been encrypted with a secure-item public asymmetric key, with the thus encrypted symmetric key then being stored in the non-volatile memory of the mobile communications unit. The private asymmetric key of the secure element in turn resides only on the secure element that has an integrated circuit or processor, such as a smart card. This ensures that the symmetric key can only be decrypted using the secure element.

Upon starting the mobile communication unit, the secure element would then decrypt with its private asymmetric key the encrypted symmetric key with which the login instance was encrypted, and then pass that symmetric key to the operating system kernel, for example, by passing the decrypted symmetric key to an operating system instance Management layer (also referred to as container management layer, CML), which passes the decrypted symmetric key to the operating system kernel. The operating system kernel then decrypts with the obtained symmetric key of the login instance. It is advantageous that the operating system kernel decrypts the logon instance and that the secure element, such as the smart card, does not decrypt because the kernel generally has much larger computational resources and as a rule performs the decryption much faster, as this would be possible for the chip card. Furthermore, it is often advantageous to decrypt the login instance with a symmetric key rather than an asymmetric key because symmetric encryption and decryption is usually faster than asymmetric encryption and decryption.

The fact that the symmetric key for encryption and decryption of the login instance are secured by means of the asymmetric key of the secure element, it follows that the login authority is decrypted only if the associated secure element, so for example, the mobile communication unit associated with the right smart card in the mobile communication unit has been inserted. In other words, this achieves a link between the mobile communication unit and the secure element.

A bond can on the one hand between z. As a smartphone and a secure element and between an operating system instance and a secure element. This can be realized, for example, by storing the public key of the respective communication partner during an initial provisioning phase in the smartphone or an instance or a secure element. This public key can also be stored in encrypted form. The communication partners can then establish a secure channel based on these keys. In one embodiment, it can be guaranteed that communication is continued only with the communication partner used at the time of the provisioning.

As far as the secure element is concerned, in some embodiments it may be designed to take the form of a microSD card, SIM card or micro SIM card, as well as inserting it into the communication unit.

In addition, as a secure element, for example, smart cards are also conceivable, via an internal smart card reader or external smart card reader, z. B. are connected via a USB port to the mobile communication unit. In order to increase security, the user could remove the smart card again and again from the communication unit or the smart card reader after use of the communication unit, and store it in a location that is different from the mobile communication unit. This ensures that if the mobile communication unit is lost, it is not possible to access the login instance of the mobile communication unit.

Furthermore, the secure element can also be designed so that it communicates by means of near field communication (near field communication) with the communication unit, without being inserted directly into the communication unit or into a reading device.

In the near field communication, in turn, different embodiments are conceivable. On the one hand, the software for accessing NFC-based secure elements in the operating system core 150 or in the operating system instance management layer 160 or in the login instance 140 , Or in a hypervisor. Or in a TEE (English: Trusted Execution Environment). In particular NFC and Bluetooth are so complex that realization in the registration instance 140 easiest to implement. To prefer would be realization in the operating system core 150 or in the operating system instance management layer 160 ,

Also, the secure element may be configured to communicate with the communication unit via Bluetooth. Furthermore, the secure element can also communicate via LAN, WLAN, or a telecommunication network, in particular a mobile radio network with the communication unit, in which case as a rule the communication between the communication unit and the secure unit ensues encrypted.

Embodiments of the invention further verify the data integrity of the filing instance. For example, the login instance may be secured by one or more hash values.

Some embodiments provide a hash value that represents a cryptographic hash over the data of the unencrypted login instance.

In preferred embodiments, a standard method of encryption, e.g. For example, cryptsetup uses aes-cbc-essiv: sha256 or aes-xts-plain64 for luks, and a cryptographic hash uses a secure hash algorithm (SHA). SHA1 or SHA256.

In some embodiments, the hash value is stored in the nonvolatile memory of the communication unit. It may be preferable to instead store the hash value of the login instance on the secure element. As a result, the security of data integrity is further increased, especially against deliberate falsification.

In particular, the hash value can be included in the PIN (together with the user's PIN) or for the login instance, the hash value itself can be the PIN. This unlocks the secure item only when the correct hash value is known on the smartphone. In a "foreign" smartphone, the secure element could not be used with the user PIN. This in turn achieves a coupling of the smartphone and the secure element.

After decrypting the login instance, the data integrity of the login instance is checked by, for example, the operating system kernel, e.g. For example, a Linux kernel now itself calculates the hash value for the login instance and compares it to the hash value that is stored, for example, in the nonvolatile memory of the communication unit or on the secure element.

The integrity check preferably takes place before decryption. It is particularly preferred if this performs the operating system management layer. In embodiments, however, this can also take over a hypervisor in a virtualized system.

Only if the calculated and stored hash values match, data integrity of the login instance is assumed. If the calculated and stored hash values do not match, it is assumed that data integrity is not present.

In one embodiment, the logon process is then aborted to prevent access to a compromised system. Or, access is not possible because the secure element can not be unlocked with the correct PIN. In another embodiment, the logon process continues, but a warning message is issued indicating that there is no data integrity and the system may have been tampered with.

In some embodiments, as an alternative or in addition to providing a hash value for the decrypted logon instance, a hash value is provided for the encrypted logon instance. This hash value of the encrypted login instance is stored, for example, either in the non-volatile memory of the communication unit or, preferably, on the secure element. Before the login instance is decrypted, a hash value for the encrypted operating system instance is then calculated and compared to the stored hash value in the same manner. If the calculated and stored hash values match, then data integrity of the login instance is assumed. If the calculated and stored hash values do not match, it is assumed that data integrity is not present. Consequence in the absence of data integrity can be, for example, canceling the logon process or issuing a warning message.

Or the secure element is simply not released. If the secure element is not released with the correct PIN (which can be included in hash embodiments), it can not decrypt the symmetric key for storage encryption. In addition, one (or more) asymmetric keys in the secure element could also be used for other use cases (eg VPN, e-mail decryption, e-mail signature, SSL authentication, linked to the integrity of the instances where they are used), which is also not possible because the secure element is still lured.

However, if the logon instance could be decrypted and the integrity of the logon instance can be assumed, the logon instance is started (for example, by the operating system instance management layer) and a graphical user interface (GUI) is displayed by means of which the user can enter a PIN.

For example, the user inputs a PIN via the user interface and the PIN is transmitted to the secure element. The secure item checks to see if the PIN matches the one on the secure item, and determines if the user is authorized to access it.

If the user is not authorized to access, for example, according to one embodiment, the secure unit stores on the secure unit that further PIN entries are no longer possible, and the logon process is aborted.

For example, it can also be provided that after a predefined number of consecutive incorrect PIN entries, for. For example, if three consecutive incorrect PIN entries are stored on the secure device, further PIN entries are no longer possible, and the login process is aborted. For example, the trycounter would then be placed in the nonvolatile memory of the secure element and it would be permanently lured after n attempts. In embodiments, for example, a PUK may be unsocked again.

Thus, the secure element can detect when starting the mobile communication unit, for example based on this stored value, whether further PIN entries are still allowed. If this is not the case, for example, it can abort the registration process immediately after the start of the mobile communication unit.

If, on the other hand, the user has entered the correct PIN, it can be provided that the user is then shown a menu of a selection of all (further) operating system instances available on the communication unit. The user can then select one of the operating system instances via the menu. These other operating system instances then provide the user with the processes and files that are actually of interest to the user. In that regard, one can refer to these other operating system instances, in contrast to the login instance as a "working environment instance".

In an alternative embodiment, only one working environment instance is present on the communication unit besides the login instance. In this case, for example, after the PIN has been entered correctly, the user will not be presented with a selection menu, but this single working environment instance will be started immediately after entering and checking the PIN.

In other embodiments, each of the work environment instances has its own PIN stored on the secure element. In such embodiments, after the communication device is started by the login instance, the user would first be presented with a graphical menu listing the various available work environment instances. After selecting one of the work environment instances, the user is then prompted to enter the PIN of that work environment instance. The entered PIN is then transmitted (preferably encrypted, eg with a public secure key public asymmetric key) to the secure element and checked by the secure element. If the entered PIN matches the stored PIN, the corresponding working environment instance becomes started. If the PIN does not match then either immediately, or z. For example, after one or more consecutive incorrect PIN entries, access to that operating system instance, or in other embodiments to all operating system instances of the communication unit, is disabled. If the respective operating system instance is disabled, this can be done by storing a bit in the secure element indicating that the respective operating system instance or the communication unit is disabled and that the communication unit queries when the respective operating system instance is to be started. If, in another embodiment, access to all operating system instances of the communication unit is blocked in the case of an (optionally repeated) incorrect PIN entry of an operating system instance, this can be done by storing a bit in the secure element indicating that all operating system instances of the communication unit are locked, and that is queried by the communication unit, for example, when the communication unit is turned on, or started.

In embodiments, there are several secure elements. For example, in one embodiment, in the NFC use case, there may be one NFC smartcard / token for each container.

Further, in embodiments in NFC-all, a PAKE protocol is also implemented, similar to the new ID card. This then establishes a secure channel between the secure element and the smartphone (which in this case plays the role of a terminal).

In some embodiments, the entered PIN is first encrypted. The PIN is then passed in encrypted form to the secure element. For example, the public asymmetric key of the secure element can be used for encryption. The secure element is only able to decrypt the encrypted PIN if it is in possession of the correct private asymmetric key, ie if the correct secure element is inserted in the mobile communication unit or is connected to the communication unit. Thus, for example, it can be prevented that the PIN entered by the user is transmitted in clear text and is intercepted unencrypted by an attacker. Alternatively, the use of the above-mentioned PAKE protocol would be.

Furthermore, it can also be prevented that an attacker exchanges a secure element with a spy element, this spy element then posing as a secure element, and then logs the user-entered PIN in plain text. Such a spy element can not decrypt the received PIN, then it does not have the private asymmetric key of the true secure element.

Not only the login instance can be in encrypted form. In preferred embodiments, the one or more work environment instances are also encrypted. Again, one or more symmetric keys can be used for encryption.

In one embodiment, the same symmetric key is always used to encrypt each of the operating system instances. A private asymmetric key is stored on the secure element, and the associated public asymmetric key is used to encrypt the one symmetric key. The encrypted symmetric key is then stored in the non-volatile memory of the communication unit or on the secure element.

In another embodiment, a different symmetric key is always used to encrypt each of the operating system instances. A private asymmetric key is stored on the secure element and the associated public asymmetric key is used to encrypt each of the symmetric keys. Each of the symmetric keys thus encrypted is then stored in the non-volatile memory of the communication unit or on the secure element. This increases security compared to the previous embodiment because if an unencrypted symmetric key is detected by an attacker, the other operating system instances are still protected.

Important here, however, is the other side, ie a symmetric storage key with several asymmetrical keys (English: keys) and thus secure elements to encrypt. Then the symmetric key is encrypted several times with different asymmetric keys stored in the smartphone. This allows the use of an instance with different smart cards and is particularly useful when the validity of a smart card expires and the user receives a new one with a different asymmetric key.

In another embodiment, a different symmetric key is always used to encrypt each of the operating system instances. Furthermore, a different public asymmetric key is used to encrypt each of the symmetric keys. The respective private asymmetric key to each of the public asymmetric keys is on the saved secure element. Each of the symmetric keys thus encrypted is then stored in the non-volatile memory of the communication unit or on the secure element. Security is very high compared to the previous embodiments because even if the attacker were to gain possession of one of the private asymmetric keys, the other operating system instances are still protected.

In one embodiment, the device is 100 ; 200 ; 300 for example, trained to be one of the operating system instances 140 . 141 . 142 in a communication network. Thus, according to one embodiment, the device 100 ; 200 ; 300 For example, a communication unit of a communication network, wherein the device 100 ; 200 ; 300 designed to be one of the operating system instances 140 . 141 . 142 the device 100 ; 200 ; 300 in the communication network to another communication unit of the communication network. Such a communication network may be, for example, a wireless or wired telecommunication network or a computer network.

Furthermore, a system is provided which is a first device 100 ; 200 ; 300 as described above and a second device 100 ; 200 ; 300 as described above. The first device 100 ; 200 ; 300 is designed to be one of the operating system instances 140 . 141 . 142 the first device 100 ; 200 ; 300 from the first device 100 ; 200 ; 300 to the second device 100 ; 200 ; 300 transferred to. The second device 100 ; 200 ; 300 is designed, the said one of the operating system instances 140 . 141 . 142 the first device 100 ; 200 ; 300 from the first device 100 ; 200 ; 300 to recieve.

Thus, in another embodiment, instances are transferred from one smartphone to another (eg, via a backend server to which the file system image of the first smartphone is uploaded and from which the second smartphone downloads this file system image again, including the encrypted one symmetric key). Will then z. For example, if the NFC-based smartcard is held on a second smartphone, the container can be decrypted there. In one embodiment, this is done - a corresponding backend provided - transparent to the user, z. B. in that the user holds his smart card to a smartphone and its instance (s) are automatically downloaded from the backend. The only prerequisite would be that the devices involved are mutually trustworthy, supported by a common PKI.

In one embodiment, the device 100 ; 200 ; 300 be set up, a first to be encrypted working environment instance of the operating system instances 140 . 141 . 142 encrypt with a first cryptographic key, for example, a first symmetric key, wherein the device 100 ; 200 ; 300 Furthermore, it may be configured to include a second work environment instance of the operating system instances to be encrypted 140 . 141 . 142 encrypted with a second cryptographic key, for example a second symmetric key, and wherein the first cryptographic key and the second cryptographic key have a different key length.

Thus, in one embodiment, a symmetric key characteristic may be made dependent on a protection status of an operating system instance. If the required protection for one operating system instance is lower than for another, a key can be used to encrypt the operating system instance with the lower protection required, while providing a lower level of protection but ensuring faster encryption. Conversely, to encrypt the operating system instance with the greater protection required, a key can be used that, while slower in encryption, provides greater protection. For example, keys with different key lengths can be used, with z. For example, larger-key-length keys may be used when greater protection is needed for an operating system instance, as compared to shorter-key length keys when less protection is required for an operating system instance. For example, the key length of the symmetric key may vary depending on the protection status, e.g. B. 128 bits, 256 bits or 512 bits. For example, the protection status can be defined by an administrator or by a user at runtime, or predefined.

With regard to the one or more public asymmetric keys that are used by the communication unit for encryption of the one or more symmetric keys and possibly for encryption of the PIN, these can be permanently stored in the communication unit in the non-volatile memory of the communication unit.

In preferred embodiments, the communication unit receives the one or more public asymmetric keys from a certification authority. For example, the one or more public asymmetric keys may be transmitted from the certification authority to the communication unit as needed.

In this PKI scenario, every smartphone (or its administrative or container management layer) would have a certificate and each one Secure Element One or more certificates, all signed by the CA or an intermediary instance. The trustworthiness of the other can then be checked against the public certificate of the CA without the counterparty having been previously known.

In embodiments, the data integrity of the one or more work environment instances is also secured. As described above for the login instance, a hash value may also be calculated for the work environment instance (s), which is then stored in the non-volatile memory of the communication unit or on the secure element.

In embodiments, the calculation of the hash value for a work environment instance may be calculated after encryption of the work environment instance. Accordingly, the comparison is then made as to whether the particular work environment instance has data integrity before the work environment instance has been decrypted.

For example, in embodiments, the encrypted hard disk image file is hashed to then possibly send that hash to the secure element, with the help of which, in turn, then the decryption is possible.

The calculation of the hash value for a work environment instance can be calculated before encryption of the work environment instance. Accordingly, then, the comparison is made as to whether the respective work environment instance has data integrity after the work environment instance has been decrypted and before the decrypted work environment instance is started. The hash value creation after decryption of the respective work environment instance is done in the same way as the hash value was formed before the work environment instance was encrypted. For example, a cryptographic hash (eg SHA) is used.

If the stored and decrypted hash values match, then data integrity is assumed. On the other hand, if the hash values do not match, then data integrity is assumed to be missing.

In one embodiment, in the case of lack of data integrity, the working environment instance is not started. Instead, for example, the user is given an error message indicating the lack of data integrity.

In an alternative embodiment, instead, a warning message may be issued informing the user of the lack of data integrity of the work environment instance, and the communication unit may attempt to start the work environment instance anyway. The condition is that the hash does not flow into the PIN. Otherwise, the secure element would not release the symmetric key for decryption.

The formation of a hash value prior to encryption of the operating system instance is advantageous, since after decryption on the one hand it can be checked whether an attacker changed the working environment instance and also whether the decryption of the working environment instance was carried out correctly.

In another embodiment, however, it may also be provided to form the hash value only after encryption. If, for example, an operating system instance is first compressed, a smaller amount of data is created by compression, which is then encrypted. It may be advantageous to perform the hash on the compressed encrypted data set, as this may make the hash computation faster, as the case may be, thereby increasing the efficiency of the hash computation.

For both the one or more work environment instances and the login instance, the instance to be encrypted may also be compressed according to some embodiments. If the corresponding instance is to be started later, decompression takes place in addition to the decryption. This is done in embodiments not for the entire file system image, but in one embodiment, for example, block-wise.

Instead of checking the data integrity only with regard to an operating system instance, for example, a hash value can also be formed across all operating system instances present in the communication unit. For example, it can then be checked at start of the communication unit by calculation of the total hash value and by comparison with the stored value, whether there is data integrity for all operating system instances of the communication unit.

For this procedure, the Trusted Computing Base (TCB) should be included here. For example, for the integrity of an instance, not only the instance itself must be integer, but also all other components that influence that instance. This applies in particular to the kernel, the administrative layer and the login instance. All of these must be trustworthy and not compromised by an attacker. Otherwise an attacker could, depending on which component he compromised, if necessary Access to keys, PIN etc. Received. Therefore, this would be to hurry all these components together or calculate a hash chain.

In some embodiments, the operating system instances are always encrypted and / or the corresponding hash values are formed when the user issues a command to turn off the communication unit or the operating system of the communication unit shuts down. In embodiments, it may be provided that, in the case of a critical almost empty battery state, the operating system instances are encrypted and / or the corresponding hash values are formed. In particular, it is generally provided that a hash value for an operating system instance is formed and / or this operating system instance is encrypted when the execution of this operating system instance is ended.

In other embodiments, during their execution, the operating system instances are continuously encrypted at timed intervals and, if appropriate, the hash is also formed. In embodiments, the encryption may be block-based, for example.

In actual embodiments, the actual persistent storage actually occurs at intervals and the data is otherwise cached. This is especially useful if the hash is to flow into the PIN of a secure element. Then the PIN must be changed every time the hash is changed, which can not be done indefinitely with slow, secure elements. Here you would then save two states in the smartphone, once for the old hash and thus for the PIN and once for the new hash and thus for the PIN. The old state can then be deleted as soon as the secure element confirms the PIN change.

In some embodiments, after each instruction execution of an operating system instance, the hash for that operating system instance is formed and the operating system instance is encrypted.

Some embodiments use a transaction concept: prior to the execution of a transaction by an operating system instance, the respective operating system instance is encrypted and, after the transaction has been carried out, the operating system instance is again encrypted. The transactions are defined so that, prior to and after the completion of the transaction, the operating system instance is in a state where data integrity prevails.

There are special encryption modes to encrypt block-based symmetric, eg. CBC or XTS, see above. For example, in embodiments, these encryption modes may be used.

If the communication unit crashes during the execution of a transaction or, for example, its power supply is interrupted, then this is not a problem, because a new start of the communication unit and at the start of this operating system instance, the encrypted operating system instance is decrypted, which then exists in a state where data integrity exists ,

The essential tasks that are associated with the encryption and decryption, possibly the compression of operating system instances and possibly the hash value formation, for example, by the operating system instance management layer 160 (or Container Management Layer called CML) are controlled and monitored. Such an operating system instance management layer may e.g. For example, be set up the operating system kernel 150 to instruct to encrypt or decrypt and compress the respective operating system instance. Also, the operating system instance management layer 160 to compare a detected hash value for an operating system instance with the hash value determined for that operating system instance.

4 shows a device according to another embodiment. The login instance is referred to as "android0" and the working environment instance as "android1" and "android2". One can also generally call the working environment instances an "androidX" instance. The block of in 4 the hardware 135 In one embodiment, the processor unit comprises 110 , the storage unit 120 and the interface 130 of the 1a to 3 ,

In embodiments, the integrity of the operating system instances in the operating system instance management layer is enforced at runtime for all encrypted operating system instances. For this purpose, as explained above, the secure element and the (communication) unit, as shown above, bound together, for. B. by asymmetric keys. This means that one (communication) unit is bound to a certain secure element (SE) and does not work with another. For example, in embodiments, the secure element may store hash values of all protected operating system instance images and operating system instance configuration files in the system that are accessible again only when a correct PIN is entered and hash values to be determined with the corresponding hash values match the last run of the operating system instance.

In embodiments, a secure item that is locked does not grant access to stored keys. For example, an operating system instance that does not have a valid hash will not be decrypted - at least if the operating system instance management layer has not been tampered with. For each of the work environment instances, a key may be stored in the secure element that is protected by its own PIN (eg, a private asymmetric key that can be used to decrypt, for example, a symmetric key that encrypted that work environment instance ).

According to embodiments, the key of the login instance (in 4 "Android0") (eg, a symmetric key used to encrypt the login instance) is encrypted in the secure element, but is not protected by a PIN because it has to be decrypted before providing a GUI for PIN entry (this GUI is provided by the login instance). Since the login instance does not store user data, this does not pose a security risk. In another embodiment, the PIN is the login instance hash.

In embodiments, work environment instances, and, in some of these embodiments, also the login instance, may be implemented as an operating system instance implementing an Android system. Here you can then call the login instance as "android0" and the working environment instance as "android1", "android2", etc. or generally as "androidX".

4 exemplifies the integrity protection for the login instance (android0) and for the working environment instances (androidX). Specifically shows 4 a realization of a system of an embodiment as a layered architecture. Some of the units of the layered architecture are classified as trustworthy. These would usefully count to the TCB and correspond with include in the hash calculation of the individual instances (directly or as a hash chain). You could also include the boot loader, etc., then we would have a secure boot-based system. For other units protection is realized by means of encryption.

In other embodiments, the operating system is Linux-based. At least two operating system instances exist which are realized as different Linux systems. So z. For example, one of the operating system instances will implement a Firefox OS system, another one of the operating system instances will implement an Ubuntu system, and a third of the operating system instances will implement an Android system.

In some embodiments, updates to the system also require a valid cryptographic signature that, for example, is validated by the secure element in one embodiment.

Returning to the 1a to 3 , in one embodiment, may interface with the cryptographic encryption backup 130 be set up by the information element 900 as the cryptographic information to obtain a first symmetric cryptographic key. In this case, the device 100 ; 200 ; 300 be set up based on the first symmetric cryptographic key, the data of the login instance 140 to decrypt decrypted data of the login instance 140 to create. Furthermore, the device 100 ; 200 ; 300 be arranged to send the user input with a public asymmetric cryptographic key to generate the said transmission message. Furthermore, the interface can be designed to transmit the transmission message to the information element.

According to another embodiment, in the non-volatile memory of the memory unit 120 stored an encrypted second symmetric cryptographic key. the interface 130 is configured to apply the encrypted second symmetric cryptographic key to the information element 900 in order to obtain from the information element an unencrypted second cryptographic key. The device 100 ; 200 ; 300 is set up the data of the said one working environment instance 141 the one or more work environment instances 141 . 142 using the unencrypted second cryptographic key to decrypt the decrypted data of that working environment instance 141 and depending on the decrypted data of that work environment instance 141 , the one or more processes that this work environment instance 141 are assigned on the processor unit 120 perform.

In a further embodiment, the device 100 ; 200 ; 300 be configured to provide another graphical interface that allows the user to select one of the working environment instances 141 ; 142 as a selected work environment instance 141 and the data of the selected work environment instance 141 to decrypt decrypted data of the selected working environment instance 141 and depending on the decrypted data the selected work environment instance 141 , one or more processes belonging to the selected work environment instance 141 are assigned on the processor unit 110 perform.

In terms of integrity protection by hash values, in one embodiment, the device 100 ; 200 ; 300 be arranged for, if the check result has the first result, the data of a 141 the one or more work environment instances 141 . 142 to decrypt decrypted data of this working environment instance 141 to generate, the device 100 ; 200 ; 300 is further adapted to perform a hash computation of the decoded data of that working environment instance 141 depends on a calculated hash value for this work environment instance 141 to get and the device 100 ; 200 ; 300 is set up the calculated hash value for this work environment instance 141 with a stored hash value for this work environment instance 141 to compare.

According to one embodiment, the device 100 ; 200 ; 300 be set up based on the cryptographic information, the data of the login instance 140 to decrypt decrypted data of the login instance 140 to generate, the device 100 ; 200 ; 300 is further adapted to perform a hash computation of the decoded data of the logon instance 140 depends on a calculated hash value for the login instance 140 and wherein the device is adapted to receive the computed hash value for the login instance 140 with a stored hash value for the login instance 140 to compare.

What the system comprising the device 100 ; 200 ; 300 and the information element 900 of the 1a - 3 In one embodiment, the information element 900 be set up for the interface 130 the device 100 ; 200 ; 300 to transmit a first cryptographic key as cryptographic information. The device 100 ; 200 ; 300 can be set up for this, based on the cryptographic key, the data of the login instance 140 to decrypt decrypted data of the login instance 140 and, depending on the decrypted data of the login instance 140 , one or more processes belonging to the login instance 140 are assigned on the processor unit 110 the device 100 ; 200 ; 300 to provide a graphical user interface that allows user input. The device 100 ; 200 ; 300 may be configured to encrypt the user input to obtain encrypted user input.

the interface 130 the device 100 ; 200 ; 300 may be configured to encrypt the encrypted user input to the information element 900 to convey. Furthermore, while the information element 900 be configured to decrypt the encrypted user input to obtain a decrypted user input. In embodiments, the concepts presented above are implemented.

The information element 900 may be configured to perform a comparison between a stored PIN and the decrypted user input. Furthermore, the information element 900 be formed to generate a response message and to the interface 130 the device 100 ; 200 ; 300 the verification result comprising the first result when the stored PIN and the decrypted user input match, and wherein the verification result has the second result when the stored PIN and the decrypted user input do not match.

5 shows an information element 900 (also referred to as "secure element") according to one embodiment.

The information element 900 includes a storage unit 910 comprising non-volatile memory, a processor unit 920 , and an interface 930 ,

In the nonvolatile memory of the storage unit 910 One or more private cryptographic keys of one or more asymmetric key pairs are stored.

the interface 930 is configured to receive an encrypted cryptographic key or other data (in embodiments, the information element may also be used, for example, after activation, for example, for e-mail signatures, VPN, SSL, etc.), the encrypted cryptographic key using the private cryptographic key Key is decryptable.

The processor unit 920 is configured to decrypt the encrypted cryptographic key or other data using the one or more private cryptographic keys to obtain a decrypted cryptographic key or decrypted data.

the interface 930 is configured to output the decrypted cryptographic key or the decrypted data. Furthermore, the interface 930 configured to receive an encrypted PIN that is decryptable using the private cryptographic key or the decrypted data.

The processor unit 920 is configured to decrypt the encrypted PIN using the private cryptographic key or the decrypted data to obtain a decrypted PIN. Furthermore, the processor unit 920 adapted to compare the decrypted PIN with a stored PIN to obtain a verification result, wherein the stored PIN in the non-volatile memory of the memory unit 910 is stored. In this case, the check result either has a first result if the check result indicates that the decrypted PIN and the stored PIN match, or it has a second result different from the first result if the check result indicates that the decrypted PIN and the stored PIN do not match.

In embodiments, changing the PIN is possible.

According to embodiments, a locked PIN can be re-enabled by using a PUK.

Furthermore, the processor unit 920 configured to generate a response message comprising the verification result. the interface 930 is configured to output the response message.

Embodiments realize integrity protection, such as coupling instances to cryptographic keys in secure elements, coupling smartphones to secure elements, releasing secure elements only after correct PIN entry, which in turn derives from the cryptographic hash of all involved software components, utilizing the secure elements in others Scenarios such as VPN after a successful integrity check and / or hash changes and associated PIN changes from the secure element, alternatively changing the stored hash in the secure element.

Although some aspects have been described in the context of a device, it will be understood that these aspects also constitute a description of the corresponding method, so that a block or a component of a device is also to be understood as a corresponding method step or as a feature of a method step. Similarly, aspects described in connection with or as a method step also represent a description of a corresponding block or detail or feature of a corresponding device. Some or all of the method steps may be performed by a hardware device (or using a hardware device). Apparatus), such as a microprocessor, a programmable computer or an electronic circuit. In some embodiments, some or more of the most important method steps may be performed by such an apparatus.

Depending on particular implementation requirements, embodiments of the invention may be implemented in hardware or in software. The implementation may be performed using a digital storage medium such as a floppy disk, a DVD, a BluRay disc, a CD, a ROM, a PROM, an EPROM, an EEPROM or FLASH memory, a hard disk, or other magnetic or optical Memory are stored on the electronically readable control signals are stored, which can cooperate with a programmable computer system or cooperate such that the respective method is performed. Therefore, the digital storage medium can be computer readable.

Thus, some embodiments according to the invention include a data carrier having electronically readable control signals capable of interacting with a programmable computer system such that one of the methods described herein is performed.

In general, embodiments of the present invention may be implemented as a computer program product having a program code, wherein the program code is operable to perform one of the methods when the computer program product runs on a computer.

The program code can also be stored, for example, on a machine-readable carrier.

Other embodiments include the computer program for performing any of the methods described herein, wherein the computer program is stored on a machine-readable medium. In other words, an embodiment of the method according to the invention is thus a computer program which has a program code for performing one of the methods described herein when the computer program runs on a computer.

A further embodiment of the inventive method is thus a data carrier (or a digital storage medium or a computer-readable medium) on which the computer program is recorded for carrying out one of the methods described herein.

A further embodiment of the method according to the invention is thus a data stream or a sequence of signals, which represent the computer program for performing one of the methods described herein. The data stream or the sequence of signals may be configured, for example, to be transferred via a data communication connection, for example via the Internet.

Another embodiment includes a processing device, such as a computer or a programmable logic device, that is configured or adapted to perform one of the methods described herein.

Another embodiment includes a computer on which the computer program is installed to perform one of the methods described herein.

Another embodiment according to the invention comprises a device or system adapted to transmit a computer program for performing at least one of the methods described herein to a receiver. The transmission can be done for example electronically or optically. The receiver may be, for example, a computer, a mobile device, a storage device or a similar device. For example, the device or system may include a file server for transmitting the computer program to the recipient.

In some embodiments, a programmable logic device (eg, a field programmable gate array, an FPGA) may be used to perform some or all of the functionality of the methods described herein. In some embodiments, a field programmable gate array may cooperate with a microprocessor to perform one of the methods described herein. In general, in some embodiments, the methods are performed by any hardware device. This may be a universal hardware such as a computer processor (CPU) or hardware specific to the process, such as an ASIC.

The embodiments described above are merely illustrative of the principles of the present invention. It will be understood that modifications and variations of the arrangements and details described herein will be apparent to others of ordinary skill in the art. Therefore, it is intended that the invention be limited only by the scope of the appended claims and not by the specific details presented in the description and explanation of the embodiments herein.

Claims (21)

Contraption ( 100 ; 200 ; 300 ), comprising: a processor unit ( 110 ), which comprises one or more processors, a memory unit ( 120 ), which includes non-volatile memory, an interface ( 130 ) for data transmission to an information element ( 900 ) and for receiving data from the information element ( 900 ), and a group of operating system instances ( 140 . 141 . 142 ), where the group of operating system instances ( 140 . 141 . 142 ) one or more working environment instances ( 141 . 142 ), each operating system instance ( 140 . 141 . 142 ) of the group of operating system instances ( 140 . 141 . 142 ) Data, the data of each operating system instance ( 140 . 141 . 142 ) of the group of operating system instances ( 140 . 141 . 142 ) in the nonvolatile memory of the memory unit ( 120 ) are stored encrypted, the device ( 100 ; 200 ; 300 ) is set up, if a check result has a first result, the data of a ( 141 ) of the one or more working environment entities ( 141 . 142 ) to decrypt data of this working environment instance ( 141 ) and depending on the decrypted data of that work environment instance ( 141 ), one or more processes that this working environment instance ( 141 ) are assigned to the processor unit ( 110 ), and wherein the device ( 100 ; 200 ; 300 ) is arranged for, if the check result has a second result different from the first result, the data of none of the one or more work environment instances ( 141 . 142 ) to decode. Contraption ( 100 ; 200 ; 300 ) according to claim 1, wherein the group of operating system instances ( 140 . 141 . 142 ) a registration authority ( 140 ), wherein the interface ( 130 ) is adapted from the information element ( 900 ) to obtain cryptographic information or other data, the device ( 100 ; 200 ; 300 ) is set up, based on the cryptographic information or other data, the data of the filing authority ( 140 ) to decrypt data of the login instance ( 140 ) and, depending on the decrypted data of the login instance ( 140 ), one or more processes, the login instance ( 140 ) are assigned to the processor unit ( 110 ) to provide a graphical user interface that allows user input where the interface ( 130 ) is adapted to the user input or a send message, which depends on the user input, to the information element ( 900 ) and the interface ( 130 ) is arranged to receive, after this transmission, a response message comprising the verification result. Contraption ( 100 ; 200 ; 300 ) according to claim 2, wherein the interface ( 130 ) is adapted from the information element ( 900 ) as the cryptographic information to obtain a first symmetric cryptographic key, the device ( 100 ; 200 ; 300 ) is adapted, based on the first symmetric cryptographic key, the data of the login instance ( 140 ) to decrypt data of the login instance ( 140 ), and wherein the device ( 100 ; 200 ; 300 ) is adapted to send the user input with a public asymmetric cryptographic key to generate said broadcast message, and wherein the interface ( 130 ), the send message to the information element ( 900 ). Contraption ( 100 ; 200 ; 300 ) according to one of the preceding claims, wherein in the non-volatile memory of the memory unit ( 120 ) an encrypted second symmetric cryptographic key is stored, wherein the interface ( 130 ) is adapted to the encrypted second symmetric cryptographic key to the information element ( 900 ) to transmit from the information element ( 900 ) to obtain an unencrypted second cryptographic key, the device ( 100 ; 200 ; 300 ) is set up to store the data of said one ( 141 ) of the one or more working environment entities ( 141 . 142 ) using the unencrypted second cryptographic key to decrypt the decrypted data of that working environment instance ( 141 ) and, depending on the decrypted data of that work environment instance ( 141 ), the one or more processes that this work environment instance ( 141 ) are assigned to the processor unit ( 110 ). Contraption ( 100 ; 200 ; 300 ) according to claim 2 or 3, wherein the device ( 100 ; 200 ; 300 ) is arranged to provide another graphical interface that allows the user to select one of the working environment instances ( 141 ) as a selected work environment instance ( 141 . 142 ) and the data of the selected work environment instance ( 141 ) to decrypt data of the selected working environment instance ( 141 ) and depending on the decrypted data of the selected working environment instance ( 141 ), one or more processes corresponding to the selected work environment instance ( 141 ) are assigned to the processor unit ( 110 ). Contraption ( 100 ; 200 ; 300 ) according to one of the preceding claims, wherein the device ( 100 ; 200 ; 300 ) an operating system kernel ( 150 ), wherein the operating system kernel ( 150 ) is arranged for, if the check result comprises said first result, the data of said work environment instance ( 141 ) to decrypt the decrypted data of this work environment instance ( 141 ) and depending on the decrypted data of that work environment instance ( 141 ), the one or more processes that this work environment instance ( 141 ) are assigned to the processor unit ( 110 ) and the operating system kernel ( 150 ) is arranged for, if the check result has the said second result different from the first result, the data of none of the one or more work environment instances ( 141 . 142 ) to decode. Contraption ( 100 ; 200 ; 300 ) according to claim 6, wherein the operating system kernel ( 150 ) is a Linux kernel. Contraption ( 100 ; 200 ; 300 ) according to claim 7, wherein each operating system instance ( 140 . 141 . 142 ) of the group of operating system instances ( 140 . 141 . 142 ) based on Linux. Contraption ( 100 ; 200 ; 300 ) according to one of claims 6 to 8, wherein the device ( 100 ; 200 ; 300 ) further comprises an operating system instance management layer, the operating system instance management layer ( 160 ) is formed, if the check result has said first result, the operating system kernel ( 150 ) one or more commands, causing the kernel ( 150 ), the data of the said work environment instance ( 141 ) to decrypt the decrypted data of this work environment instance ( 141 ) and depending on the decrypted data of that work environment instance ( 141 ), the one or more processes that this work environment instance ( 141 ) assigned to the processor unit ( 110 ) and the operating system instance management layer ( 160 ) is formed, if the check result has the said second result, the operating system kernel ( 150 ) do not convey a command through which the kernel ( 150 ) would cause the data of one of the working environment instances ( 141 . 142 ) to decode. Contraption ( 100 ; 200 ; 300 ) according to one of the preceding claims, wherein the device ( 100 ; 200 ; 300 ) is arranged for, if the check result has said first result, the data of the one ( 141 ) of the one or more working environment entities ( 141 . 142 ) to decrypt data of this working environment instance ( 141 ), the device ( 100 ; 200 ; 300 ) is further adapted to perform a hash computation based on the decrypted data of that working environment instance ( 141 ) depends on a calculated hash value for this work environment instance ( 141 ) and wherein the device ( 100 ; 200 ; 300 ) is set up to calculate the calculated hash value for that work environment instance ( 141 ) with a stored hash value for that work environment instance ( 141 ) to compare. Contraption ( 100 ; 200 ; 300 ) according to claim 2, wherein the device ( 100 ; 200 ; 300 ) is set up, based on the cryptographic information, the data of the login instance ( 140 ) to decrypt data of the login instance ( 140 ), the device ( 100 ; 200 ; 300 ) is further adapted to perform a hash computation based on the decoded data of the log-in instance ( 140 ) to obtain a computed hash value for the login instance, and wherein the device ( 100 ; 200 ; 300 ) is set up to calculate the computed hash value for the login instance ( 140 ) with a stored hash value for the login instance ( 140 ) to compare. Contraption ( 100 ; 200 ; 300 ) according to one of the preceding claims, wherein the device ( 100 ; 200 ; 300 ) is a communication unit designed to send messages to other communication units of a wireless or wired network and to receive messages from these other communication units. Contraption ( 100 ; 200 ; 300 ) according to any one of claims 1 to 11, wherein the device ( 100 ; 200 ; 300 ) is a mobile communication unit configured to send messages to and receive messages from other communication units to other communication units of a wireless or wired network. Contraption ( 100 ; 200 ; 300 ) according to one of the preceding claims, wherein the device ( 100 ; 200 ; 300 ), a first work environment instance to be encrypted ( 141 . 142 ) of the operating system instances ( 140 . 141 . 142 ) with a first cryptographic key, the device ( 100 ; 200 ; 300 ), a second work environment instance to be encrypted ( 141 . 142 ) of the operating system instances ( 140 . 141 . 142 ) with a second cryptographic key, and wherein the first cryptographic key and the second cryptographic key have a different key length. Contraption ( 100 ; 200 ; 300 ) according to one of the preceding claims, wherein the device ( 100 ; 200 ; 300 ) is a communication unit of a communication network that is adapted to one of the operating system instances ( 140 . 141 . 142 ) of the device ( 100 ; 200 ; 300 ) in the communication network to another communication unit of the communication network. A system comprising: a device ( 100 ; 200 ; 300 ) according to one of claims 1 to 15, and an information element ( 900 ) the information element ( 900 ) is adapted to the interface ( 130 ) of the device ( 100 ; 200 ; 300 ) to transmit cryptographic information, the device ( 100 ; 200 ; 300 ) is set up, based on this cryptographic information, the data of the login instance ( 140 ) to decrypt data of the login instance ( 140 ) and, depending on the decrypted data of the login instance ( 140 ), one or more processes that the login instance ( 140 ) are assigned to the processor unit ( 110 ) to provide a graphical user interface that allows user input where the interface ( 130 ) of the device ( 100 ; 200 ; 300 ) is adapted to the user input or a send message, which depends on the user input, to the information element ( 900 ), the information element ( 900 ) is adapted to perform a comparison between a stored information and the reception information, wherein the reception information depends on the user input or on the transmission message to obtain a check result, the check result having either a first result or a second result depending on the comparison which is different from the first result, wherein the information element ( 900 ) is adapted to generate a response message and to the device ( 100 ; 200 ; 300 ), the response message comprising the check result, the interface ( 130 ) of the device ( 100 ; 200 ; 300 ) is adapted to receive the response message, the device ( 100 ; 200 ; 300 ) is set up, if the check result has the first result, the data of a ( 141 ) of the one or more working environment entities ( 141 . 142 ) to decrypt data of this working environment instance ( 141 ) and depending on the decrypted data of that work environment instance ( 141 ), one or more processes that this working environment instance ( 141 ) are assigned to the processor unit ( 110 ) of the device ( 100 ; 200 ; 300 ), and wherein the device ( 100 ; 200 ; 300 ) is arranged for, if the check result has the second result, the data of none of the one or more work environment instances ( 141 . 142 ) to decode. A system according to claim 16, wherein the information element ( 900 ) is adapted to the interface ( 130 ) of the device ( 100 ; 200 ; 300 ) to transmit a first cryptographic key as cryptographic information, the device ( 100 ; 200 ; 300 ) is set up, based on the cryptographic key, the data of the login instance ( 140 ) to decrypt data of the login instance ( 140 ) and, depending on the decrypted data of the login instance ( 140 ), one or more processes that the login instance ( 140 ) are assigned to the processor unit ( 110 ) of the device ( 100 ; 200 ; 300 ) to provide a graphical user interface allowing user input, the device ( 100 ; 200 ; 300 ) is adapted to encrypt the user input in order to obtain an encrypted user input, the interface ( 130 ) of the device ( 100 ; 200 ; 300 ) is adapted to the encrypted user input to the information element ( 900 ), the information element ( 900 ) is adapted to decrypt the encrypted user input in order to obtain a decrypted user input, wherein the information element ( 900 ) is adapted to perform a comparison between a stored PIN and the decrypted user input, wherein the information element ( 900 ) is adapted to generate a response message and to the interface ( 130 ) of the device ( 100 ; 200 ; 300 ), the check result comprising the first result when the stored PIN and the decrypted user input match, and wherein the check result has the second result if the stored PIN and the decrypted user input do not match. Information element ( 900 ), comprising: a memory unit ( 910 ) comprising nonvolatile memories, a processor unit ( 920 ), and an interface ( 930 ), wherein in the non-volatile memory of the memory unit ( 910 ) one or more private cryptographic keys of one or more asymmetric key pairs are stored, where the interface ( 930 ) is adapted to receive an encrypted cryptographic key or other data, wherein the encrypted cryptographic key is decryptable using the private cryptographic key, wherein the processor unit ( 920 ) is adapted to decrypt the encrypted cryptographic key or the other data using the one or more private cryptographic keys to obtain a decrypted cryptographic key or decrypted data, the interface ( 930 ) is adapted to output the decrypted cryptographic key or the decrypted data, the interface ( 930 ) is adapted to receive an encrypted PIN which can be decrypted using the private cryptographic key or the decrypted data, wherein the processor unit ( 920 ) is adapted to decrypt the encrypted PIN using the private cryptographic key or the decrypted data to obtain a decrypted PIN, the processor unit ( 920 ) is adapted to compare the decrypted PIN with a stored PIN to obtain a check result, wherein the stored PIN in the non-volatile memory of the memory unit ( 910 ), the check result having either a first result if the check result indicates that the decrypted PIN and the stored PIN match, or has a second result different from the first result if the check result indicates that the decrypted PIN and the stored PIN do not match, and where the processor unit ( 920 ) is adapted to generate a response message comprising the check result, the interface ( 930 ) is configured to output the response message. A system comprising: a first device ( 100 ; 200 ; 300 ) according to one of claims 1 to 15, and a second device ( 100 ; 200 ; 300 ) according to one of claims 1 to 15, wherein the first device ( 100 ; 200 ; 300 ), one of the operating system instances ( 140 . 141 . 142 ) of the first device ( 100 ; 200 ; 300 ) from the first device ( 100 ; 200 ; 300 ) to the second device ( 100 ; 200 ; 300 ), and wherein the second device ( 100 ; 200 ; 300 ), the said one of the operating system instances ( 140 . 141 . 142 ) of the first device ( 100 ; 200 ; 300 ) from the first device ( 100 ; 200 ; 300 ) to recieve. A method comprising: when a check result has a first result, decrypting data from a working environment instance ( 141 ) one or more working environment instances ( 141 . 142 ) a group of operating system instances ( 140 . 141 . 142 ), decrypted data of this working environment instance ( 141 ), each operating system instance ( 140 . 141 . 142 ) of the group of operating system instances ( 140 . 141 . 142 ) Data, the data of each operating system instance ( 140 . 141 . 142 ) of the group of operating system instances ( 140 . 141 . 142 ) in the non-volatile memory of a memory unit ( 120 ) are stored encrypted, and, depending on the decrypted data of the said work environment instance ( 141 ), Executing one or more processes that this work environment instance ( 141 ) are assigned to a processor unit ( 110 ), and if the check result has a second result different from the first result, no decrypting of the data of the one or more work environment instances ( 141 . 142 ). Computer program with a program code for carrying out the method according to claim 20.

Images