Protection of integrity
The method generates and verifies a sequence of bits using a PRNG to address integrity and fault detection in cryptographic schemes like Kyber and Dilithium, ensuring secure and efficient cryptographic operations.
Patent Information
- Application Number
- FR2024004377
- Authority / Receiving Office
- FR · FR
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2023-05-19
- Filing Date
- 2024-04-26
- Publication Date
- 2024-11-22
AI Technical Summary
The Kyber and Dilithium network-based cryptographic schemes face challenges in ensuring the integrity of the large random matrix A, which is specific to each key pair, particularly due to the risk of side-channel attacks and fault injection, and require efficient methods for verifying the integrity of long sequences of bits.
A method is proposed to generate and verify the integrity of a sequence of bits using a pseudo-random number generator (PRNG) based on a seed, where additional control bits are generated and stored with the key, allowing for recalculations during operations to detect faults and ensure correct matrix compilation.
This approach provides a cost-effective mechanism to detect fault injections during matrix compilation, ensuring the correct execution of the PRNG and verifying the integrity of the generated bits, enhancing security in cryptographic operations.
Smart Images

Figure 00000000_0000_ABST
Abstract
Description
Title of the invention: Integrity protection
[0001] The Kyber [ABD+21] and Dilithium [LDK+21] lattice-based cryptographic schemes, both of which are chosen by NIST for standardization purposes, use a large random matrix A. This matrix A is specific for each key pair, is defined during a key generation, and includes both the public and private keys. This applies to both Kyber and Dilithium.
[0002] In order to accommodate limited memory space, only a part of the matrix A is stored. A random seed g is generated and stored as part of both the public and private keys. Matrix A is then (re-)compiled deterministically from this seed g when needed. In more detail, seed g is used to feed a pseudo-random number generator (PRNG) to generate a sequence of random bits, which is then subjected to a sampling algorithm that derives values in the desired output format, i.e., coefficients in a range [0, q-1]. Kyber and Dilithium use SHAKE as their PRNG.
[0003] Since the seed g is public (i.e., part of the public key), the recompiled matrix A may not need to be secured against side-channel attacks. However, there is still the problem that an attack may inject faults into the matrix A, which requires measures to provide assurance that the matrix A is compiled correctly. Another problem that arises is to find an efficient solution to provide means to verify the integrity of long bit sequences.
[0004] This is achieved according to the characteristics of the invention.
[0005] The examples which are proposed in the present specification may be based in particular on at least one of the following solutions. Combinations of the following features may be used to obtain the desired result. The features of the method could be combined with any other feature of the device, installation or system or vice versa.
[0006] A method for generating a bit sequence based on a primer is proposed, - in which a generator is used to generate a first set of bits based on the seed, - wherein the generator is used to generate a second set of bits, the second set of bits being based on the first set of bits or on a portion of the first set of bits, - wherein the bit sequence comprises the first set of bits and the second set of bits.
[0007] This solution allows a verification of the integrity of the bit sequence by recalculating the second set of bits. A verification of this type can be used to confirm the integrity of the generator since it can in particular detect (injected) faults.
[0008] Note that "based on X" does not limit the reference only to X; rather, it means that it "also relies on X", i.e., on X and other inputs or X and intermediate results. The first set of bits relies, for example, on the seed, where the first set of bits may be determined in parts of bits, each subsequent part of bits also relying on the seed and (e.g., all) previous parts of bits. Accordingly, the second set of bits relies on the first set of bits (i.e., all parts thereof) and on the seed.
[0009] It will further be noted that the generator may often be referred to as a random number generator or as a pseudo-random number generator. In the context used herein, it is not decisive whether the randomness of the generated numbers is true randomness, pseudo-randomness or even relates to numbers calculated in a deterministic manner. The generated numbers may in particular at least appear - to some extent - arbitrary. In this respect, there is no particular requirement of the entropy level.
[0010] Advantageously, the solution described in the present specification can be used in the case where the bit sequence, which can in particular be an at least partially random bit sequence, is generated or regenerated from any seed.
[0011] The seed may comprise multiple bits, while the bit sequence may comprise (substantially) more bits than the seed.
[0012] Bits may be generated in successive processing stages, each subsequent stage relying on the result of the previous stage. In one example, the second set of bits may be generated in (at least) one subsequent stage that relies on the first set of bits. Alternatively, the second set of bits may rely on a portion of the first set of bits that originates from previous stages, while the remaining portion of the first set of bits and the second set are the result of the recent (last) processing stage.
[0013] According to one embodiment, the generator operates in cycles, each cycle depending on the previous cycle and using a function /
[0014] Thus, the generator can operate as a state machine comprising several cycles (i.e. processing stages), in which each cycle relies on the calculation of the previous cycle. The seed is processed in an absorption phase. The first set of bits and the second set of bits are determined in a cryptographic sponge compression phase.
[0015] According to one embodiment, the generator is a pseudorandom number generator, PRNG, which uses an absorption phase absorbing the seed and a compression phase to determine the first set of bits and the second set of bits.
[0016] According to one embodiment, SHAKE is used as the PRNG.
[0017] According to one embodiment, the second set of bits are bits of a checksum to verify the bit sequence.
[0018] The bits of the checksum can thus be used to verify the integrity of the generator. This verification can be done, for example, during decapsulation (in the case of Kyber) or during signature (in the case of Dilithium).
[0019] According to one embodiment, the sequence of bits is verified by recalculating the second set of bits based on the seed and comparing this recalculated second set of bits to the bits of the checksum.
[0020] According to one embodiment, the second set of bits is calculated during a key generation and stored together with the key.
[0021] According to one embodiment, the method is used in the context of a network-based cryptography method.
[0022] According to one embodiment, the bit sequence is determined to compile a matrix for a key pair which is used in particular in Kyber or Dilithium.
[0023] According to one embodiment, the method is carried out at least in part on one of the following: - a safety device, - a secure cloud, - a secure service, - an integrated circuit, - a hardware security module, - a trusted platform module, - a cryptographic unit, an FPGA, - a processing unit, - a control unit, - a smart card.
[0024] A device for generating a bit sequence based on a primer is further provided, wherein the device is arranged to perform the following steps: - creation of a first set of bits based on the primer, - creating a second set of bits, the second set of bits based on the first set of bits or on a portion of the first set of bits, wherein the sequence of bits comprises the first set of bits and the second set of bits.
[0025] The device may be used in any processing unit for performing such steps. This processing unit may comprise at least one, in particular several means which are arranged to perform the steps of the method described herein. The means may be logically or physically separated; in particular several logically separated means could be combined into at least one physical unit. The processing unit may comprise at least one processor and / or a micro-control unit (MCU).
[0026] According to one embodiment, the device is one of the following or comprises at least one of the following: - a safety device, - a secure cloud, - a secure service, - an integrated circuit, - a hardware security module, - a trusted platform module, - a cryptographic unit, an FPGA, - a processing unit, - a control unit, - a smart card.
[0027] Also provided is a computer program product which can be loaded into a memory of a digital processing device, comprising software code portions for performing the method steps described herein.
[0028] Embodiments are shown and illustrated with reference to the drawings. The drawings serve to illustrate the basic principle, so that only aspects necessary to understand the basic principle are illustrated. The drawings are not to scale. In the drawings, like reference characters designate like features.
[0029] [Fig.l] represents a schematic state diagram of a sponge construction used in SHAKE;
[0030] [Fig.2] is a schematic diagram visualizing an embodiment as example of determining additional control bits;
[0031] [Fig.3] represents an exemplary diagram visualizing stages of the way in which one can check the integrity of a long sequence of bits;
[0032] [Fig.4] shows an exemplary arrangement of a processing device comprising a CPU, RAM, non-volatile memory, a crypto module, an analog module, an input / output interface and a hardware random number generator;
[0033] [Fig.5] shows an alternative arrangement having a hardware security module (HSM).
[0034] Solutions described in this document make it possible to provide a cost-effective path for detecting a fault injection during the compilation of the matrix 3- In particular, the correct execution of the PRNG while transforming the seed p into a long sequence of pseudo-random bits is ensured. The PRNG can thus pass on an unprotected device, for example an accelerator.
[0035] This is achieved by using the PRNG to generate more output bits than are needed. These extra output bits can then be used as checksums (i.e., checksum bits) to verify the correct computation of (the entire) output of the PRNG.
[0036] Optionally, the checksum bits can be calculated during key generation and stored with the secret key. During an operation with the secret keys (i.e., decapsulation in the case of Kyber or signing in the case of Dilithium), the checksum can be recalculated and tested against these previously stored checksum bits.
[0037] The fault detection capabilities of this solution depend on the PRNG used and the position of the check bits. As noted, Kyber and Dilithium use SHAKE as their PRNG: SHAKE is an extensible output function belonging to the SHA-3 family of algorithms. SHAKE is described in FIPS PUB 202 [Natl5]. It is a cryptographic sponge construction, meaning that a so-called absorption phase is followed by a so-called compression phase.
[0038] [Fig.l] shows a schematic state diagram of a SHAKE sponge construction according to [Natl5]. The input A is first filled up to a multiple of the block length r. Each such block is XORed to a part of the state. After each XOR of a block, a function / is applied to the respective state, which leads to a stepwise absorption of the input A based on operations of previous blocks. After the entire input A is absorbed, an output Z of length d is extracted in blocks, in which, after each extraction of r-bit block, the function / is applied.
[0039] To generate the matrix a (in Kyber or Dilithium), the input A is seeded p. The output Z is sent to a sampling algorithm transforming the random bits into samples of the desired distribution. The output length d necessary is not known a priori. Instead, block extraction takes place in the compression phase until the number d of output bits is generated.
[0040] In other words, during the compression phase with each application of the function / , a number of r bits are generated, this can be done until a sufficient number of bits are available.
[0041] The parameter c is a security parameter: the larger the parameter c, the higher the security level.
[0042] As an example, SHA-3 / SHAKE uses states, each of which has a dimension of 1600 bits, i.e.
[0043] r + c = 1600 bits.
[0044] The actual dimensions of r and c may depend on the particular use case. The parameter r is also referred to as "rate" and the parameter c as "capacity".
[0045] Examples described herein propose determining additional Y check bits using the PRNG, which are then used for fault detection purposes.
[0046] [Fig.2] shows an exemplary embodiment of determining and using additional Y control bits. After determining all the bits needed for output Z, the function / is called (at least) once more on the current (last) state, resulting in an additional block of e Y control bits. Using the Y control bits allows faults to be detected with a high probability, i.e. does not detect faults within the function / with a probability of only Ze.
[0047] The fault bits Y are determined in a block 201 which is added with respect to the example shown in [Fig.l].
[0048] This procedure may be performed first during key generation, the check Y bits could then be stored as part of the private key. During secret key operations, the procedure may be repeated and the check Y bits may be compared to the previously stored values.
[0049] In Kyber and Dilithium, each material input is a polynomial, each such polynomial is generated using a separate call to SHAKE, e.g., in the form
[0050] SHAKE (p, matrix index).
[0051] Thus, separate control bits may have to be stored for each such SHAKE call.
[0052] [Fig. 3] shows an exemplary diagram visualizing stages of how the integrity of a long bit sequence can be verified. A primer is loaded at stage 301, which allows a generator to generate (e.g., in several stages of an absorption phase or a subsequent compression phase) several A bits resting on this primer. Then, in a stage 302 B bits can be determined according to one of the following solutions:
[0053] 1) The bits are determined in a subsequent stage (i.e. call / of function). Thus, the B bits rely on all previous bits, especially the previously generated A bits.
[0054] 2) The B bits are taken from the last function call that also contributed to the remaining A bits. This recent function call results in more bits than needed for A bits. Some or all of these extra bits can be used as B bits.
[0055] 3) A first part of the B bits is determined according to solution 2 and a second part of bits B is determined according to solution 1, i.e. in a subsequent function call. This can be useful, if more bits are needed than the first part of bits.
[0056] In a stage 305, the B bits are stored. This can be done together with the A bits or without the A bits.
[0057] In a stage 303, A* bits are generated based on the seed and in a stage 304, B* bits are generated. These generation stages 303 and 304 operate similarly to stages 301 and 302. All stages 301 to 304 preferably occur on one generator and / or may use the same generation algorithm.
[0058] In a stage 306, the stored B bits and B* bits are compared with each other. If they are identical, the verification of the integrity of the generator is successful (stage 307), otherwise the verification is not successful (stage 308).
[0059] Note that the B bits and the B* bits can also be designated as control bits.
[0060] It should further be noted that the term X bits "rest on" Y bits may include an iterative use of a function, with each (intermediate) function call using the output of the previous function call. Thus, the X bits may be considered as an input (direct or indirect) to derive the Y bits in several stages, with each stage (e.g., function call) possibly yielding a portion of the Y bits.
[0061] In the example of [Fig.2], the Z bits are "compressed" from the input A bits by applying the function / multiple times. The output of each function call is used as input for the next function call. To this extent, the Z bits rely on input N, as well as on any intermediate results of the function calls. Thus, the control Y bits (following [Fig.2]) rely on input N, as well as on the Z bits.
[0062] Other examples and embodiments
[0063] A generic integrity protection solution involves multiple computations of the same operation. For example, a particular operation may be performed twice and the output checked for equivalence. The solution presented herein may be used accordingly in this context. The control bits of both operations may be tested.
[0064] It is another option that unused bits, for example bits from the last block that extend beyond the simple Z output, set the Y control bits. This may give an even cheaper solution, but some defects in the last compression phase may not be detected. This may apply in particular in the case where SHAKE is used as a PRNG.
[0065] The solution presented in the present specification is not limited to the recompilation of the matrix X. Instead, this solution can be applied in the case where a random data is (re-)generated from a seed. Such a seed can in particular be known in advance and can possibly be constant.
[0066] For example, both Kyber and Dilithium use key pair generation based on a random (secret) seed. However, the remaining stages of key pair generation, including the recompilation of the entire private key, then proceed in a deterministic manner and depend (only) on this initial seed.
[0067] In memory-limited scenarios for storing private keys, one solution may be to store only the secret seed used for key generation and reuse this seed to regenerate the (private) key if necessary. Such (re-)generation implies that the PRNG (SHAKE) operates with a fixed secret seed, in accordance with the solution described herein.
[0068] [Fig.4] shows a processing device 500 comprising a CPU 500, a RAM 502, a non-volatile memory 503 (NVM), a crypto-module 504, an analog module 506, an input / output interface 507 and a hardware random number generator 512.
[0069] In this example, the CPU 501 has access to at least one crypto-module 504 via a shared bus 505, to which each crypto-module 504 is connected. Each crypto-module 504 may in particular comprise one or more crypto-cores for performing certain cryptographic operations. Examples of crypto-cores are: an AES 509 kernel, a SHA 510 kernel, an ECC 511 core, and a 508 network-based crypto-kernel.
[0070] The CPU 501, the hardware random number generator 512, the NVM 503, the crypto-module 504, the RAM 502 and the input / output interface 507 are connected to the bus 505. The input / output interface 507 may have a connection to other devices which may be similar to the processing device 500.
[0071] The crypto-module 504 may or may not be equipped with hardware-based security features.
[0072] The bus 505 itself may be hidden or in clear text. Instructions for carrying out the steps described herein may in particular be stored in the NVM 503 and processed by the CPU 505. The processed data may be stored in the NVM 503 or in the RAM 502. Support functions may be provided by the crypto-modules 504 (e.g., expansion of pseudo-random data).
[0073] The method steps described herein may be performed exclusively or at least in part on the crypto-module 504, for example on the network-based crypto-kernel 508.
[0074] The processing device 500 may be a smart card powered by direct electrical contact or by an electromagnetic field. The processing device 500 may be a fixed circuit or based on reconfigurable hardware (e.g., a field-programmable gate array, FPGA). The processing device 500 may be connected to a personal computer, a microcontroller, an FPGA, or a smartphone.
[0075] The solution described herein may be used by a customer who intends to provide a secure implementation of network-based cryptography on a smart card or any security element.
[0076] [Fig. 5] shows another example of a processing device 600. The processing device 600 includes a hardware security module 601, a non-volatile memory (NVM) 608, a random access memory (RAM) 609, an interface 610 for communication with other devices and an application processor 607, which is connected to the hardware security module (HSM) 601, the RAM 609, the NVM 608 and the interface 610.
[0077] The HSM 601 includes a control unit 602, a hardware random number generator (HRNG) 606, and at least one crypto-module 603. The crypto-module 603 includes, by way of example, an AES kernel 604 and a network-based crypto-kernel (LBC) 605.
[0078] According to one embodiment, the HSM 601 and the application processor 607 may be fabricated on the same physical chip in close connection. The HSM 601 provides cryptographic services and secure key storage, while the application processor may perform intensive computing tasks (e.g., image recognition, communication, motor control). The HSM 601 can only be accessed through a defined interface and is considered independent of the rest of the system, in that
[0079] meaning that a compromise on the security of the application processor 607 has only a limited impact on the security of the HSM 601. The HSM 601 may perform all or a subset of the tasks described in connection with the processing device 600 using the control unit 602, the LBC 605, supported by, for example, an AES 604 and the HRNG 606. It may execute the procedures described herein (at least in part) either controlled by an internal control unit or in the form of a CMOS circuit. In addition, the application processor 607 may also perform the methods described herein (at least in part, for example in cooperation with the HSM 601).
[0080] The processing device 600 with this application processor 607 and the HSM 601 can be used as a central communication gateway or as an (electrical) engine control unit in automobiles or other vehicles.
[0081] In one or more examples, the functions described herein may be implemented at least in part in hardware, such as in the form of specific hardware components or a processor. More generally, the techniques may be implemented in hardware in processors, software, firmware, or combinations thereof. If implemented in software, the functions may be stored or transmitted as one or more instructions or codes on a computer-readable medium and executed by a hardware-based processing unit.Computer-readable media may include computer-readable storage media, which correspond to a tangible medium, such as data storage media or communication media including any medium that facilitates a transfer of a computer program from one location to another, for example, following a communication protocol. Computer-readable media may thus, generally, correspond to (1) tangible computer-readable storage media that are not transient or (2) a communication medium, such as a signal or a carrier wave. Data storage media may be any available medium that can be accessed by one or more computers or one or more processors to retrieve instructions, code, and / or data structures for an implementation of the techniques described herein.A computer program product may include a computer-readable medium.
[0082] By way of example and without limitation, such computer-readable storage media may include RAM, ROM, EEPROM, CD-ROM, or other optical disk memory, magnetic disk memory, or other magnetic memory devices, flash memory, or any other medium that can be used to store desired program code in the form of instructions or data structures and that can be accessed by a computer. Any link is also properly referred to as a computer-readable medium, i.e., a computer-readable transmission medium. If, for example, instructions are transmitted from a website, server, or other remote source using coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies, such as infrared, radio, and microwave, coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies, such as infrared, radio, and microwave are included in the definition of medium.It is understood, however, that computer-readable storage media and data storage media do not include connections, carrier waves, signals, or other transient media, but rather refer to tangible, non-transitory storage media. Disk and disc, as used herein, include a compact disc (CD), a laser disc, an optical disc, a digital versatile disc (DVD), a floppy disk, and a blu-ray disc, in which disks typically reproduce data magnetically, while discs reproduce data optically by lasers. Combinations of the foregoing are also to be included within the scope of computer-readable media.
[0083] Instructions may be executed by one or more processors, such as one or more central processing units (CPUs), digital signal processors (DSPs), general purpose microprocessors,
[0084] application specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), or other equivalent integrated circuit or discrete logic circuit. Accordingly, the term "processor," as used herein, may refer to any of the foregoing structures or any other structure specific to an implementation of the techniques described herein. Further, in some aspects, the functionality described herein may be achieved in dedicated hardware and / or software modules configured for encoding and decoding or incorporated into a combined codec. The techniques may also be implemented completely in one or more circuits or logic elements.
[0085] The techniques of this disclosure may be implemented in a wide variety of devices or installations, including in a wireless handset, an integrated circuit (IC), or an integrated circuit assembly (e.g., a chip assembly). Various components, modules, or units are described in this disclosure to emphasize functional aspects of devices configured to perform the techniques. described, but do not necessarily require implementation by different hardware units. Rather, as described above, various units may be combined into a single hardware unit or achieved by a collection of interoperating hardware units, including one or more processors, as described above, in conjunction with appropriate software and / or firmware.
[0086] Although various exemplary embodiments of the invention have been described, it will be obvious to those skilled in the art that various changes and modifications can be made that will provide some of the advantages of the invention, without departing from the spirit and scope of the invention. It will be obvious to those skilled in the art that they can be replaced by other components performing the same functions. It should be mentioned that features explained with reference to a specific figure can be combined with features of other figures, even in cases where this has not been explicitly mentioned. Furthermore, the methods of the invention can be carried out in all software embodiments using the
[0087] suitable processor instructions or in hybrid embodiments that use a combination of hardware logic and software logic to achieve the same results. Such modifications of the inventive concept are intended to be included within the invention. References
[0088] [ABD+21] Roberto Avanzi, Joppe Bos, Léo Ducas, Eike Kiltz, Tancrète Lepoint, Vadim Lyubashevsky, Jhon M. Schank, Peter Schwabe, Gregor Seiler, and Damien Stehlé. CRYSTALS-Kyber: Algorithm specification and supporting documentation (version 3.02). Submission to the NIST Post-Quantum Cryptography Standardization Project [NIS16], 2021. Specification document: https: / / pq-crystals.org / kyber / data / kyber-specification-round3-20210804.pdf. Website: https: / / pq-crystals.org / kyber.
[0089] [LDK+21] Vadim Lyubashevsky, Léo Ducas, Eike Kiltz, Tancrète Lepoint, Peter Schwabe, Gregor Seiler, et Damien Stehlé. CRYSTALS-Dilithium : Algorithm spécification and supporting documentation (version 3.1). Soumission au NIST Post-Quantum Cryptography Standardization Project [NIS16], 2021. Spécification document : https / / pq-crystals.org / dilithium / data / dilithium-specification-round3-20210208.pdf. Website : https / / pq-crystals.org / dilithium.
[0090] [Natl5] National Institute of Standards and Technology. FIPS 202, SHA-3 Standard : Permutation-Based Hash and extendable-Output Functions, 2015. Disponible à : https / / nvlpubs.nist.gov / nistpubs / FIPS / NIST.FIPS.202.pdf.
[0091] [NIST Computer Security Division. Post-Quantum Cryptography Standardization, 2016. Website : https / / csrc.nist.gov / Projects / Post-Quantum-Cryptography.
Claims
Claims
1. A method of generating a bit sequence based on a seed, - wherein a generator is used to generate a first set of bits based on the seed, - wherein the generator is used to generate a second set of bits, the second set of bits based on the first set of bits or on a part of the first set of bits, - wherein the bit sequence comprises the first set of bits and the second set of bits.
2. A method according to claim 1, wherein the generator operates in cycles, wherein each cycle depends on the previous cycle and uses a function /
3. A method according to any preceding claim, wherein the generator is a pseudo-random number generator, PRNG, which uses an absorption phase absorbing the seed and a compression phase determining the first set of bits and the second set of bits.
4. The method of claim 3, wherein SHAKE is used as the PRNG.
5. A method according to any preceding claim, wherein the second set of bits are checksum bits for verifying the bit sequence.
6. A method according to claim 5, wherein the bit sequence is verified by recalculating the second set of bits based on the seed and comparing this recalculated second set of bits to the bits of the checksum.
7. A method according to any preceding claim, wherein the second set of bits are calculated during key generation and stored together with the key.
8. A method according to any preceding claim, wherein the method is used in the context of a network-based cryptography method.
9. A method according to any preceding claim, wherein the bit sequence for compiling a matrix for a key pair, which is used especially in Kyber or Dilithium.
10. A method according to any one of the preceding claims, wherein the method is carried out at least in part on one of the following: - a security device, - a secure cloud, - a secure service, - an integrated circuit, - a hardware security module, - a trusted platform module, - a cryptographic unit, an FPGA, - a processing unit, - a control unit, - a smart card.
11. Device for generating a sequence of bits based on a seed, wherein the device is arranged to perform the following steps: - creating a first set of bits based on the seed, - creating a second set of bits, the second set of bits based on the first set of bits or on a part of the first set of bits, wherein the sequence of bits comprises the first set of bits and the second set of bits.
12. A device according to claim 11, wherein the device is one of, or comprises at least one of: - a security device, - a secure cloud, - a secure service, - an integrated circuit, - a hardware security module, - a trusted platform module, - a cryptographic unit, an FPGA,
13. - a processing unit, - a control unit, - a smart card. A computer program product loadable directly into the memory of a digital processing device, comprising software code portions for carrying out the steps of the method according to any one of claims 1 to 10, when the software code portions are executed by a processing unit.
