PROCESSING SYSTEM AND METHOD USING A TWEAKABLE CODE-BASED MASKING

Abstract

A processing system executes a processing function in response to receipt of an input information word including information symbols, including a protection device to protect execution of the processing function using a tweakable code-based masking, and a processing unit to execute the processing function, by decomposing its execution into basis operations including elementary operations including at least a component-wise multiplication operation. The processing unit includes a multiplier. The protection device determines an encoding matrix A from an information code and a masking code, being linear codes and determined randomly, the processing device including an encoder to encode the input information word, and each operand of an elementary operation, prior to execution using encoding matrix A. The multiplication operation performed by multiplier is masked using the pseudo-inverse matrix A−1 of the encoding matrix A, and a pseudo-inverse transpose matrix A−T of the encoding matrix A, such that (AT)−1=(A−1)T.

Description

CROSS-REFERENCE TO RELATED APPLICATION

This application claims priority to foreign European patent application No. EP 23307230.5, filed on Dec. 15, 2023, the disclosure of which is incorporated by reference in its entirety.

FIELD OF THE INVENTION

The invention generally relates to the protection of processing devices and, in particular, to a processing system configured to protect the execution of a processing function.

BACKGROUND

As part of huge endeavors to enhance the security of processing systems, such as including smartcards, mobile devices, smart IoT devices, etc., secure implementations are required to be compliant to international/national standards before being deployed on the market.

A processing system such as a cryptographic system can implement a processing function applied to an input information word, such as in the AES cryptographic algorithm for example which apply an AES function to an input information word.

In order to implement a processing function, several elementary operations are generally executed such as additions and multiplications.

However, the elementary operations performed to execute a processing function must be secured against non-invasive attacks that attempt to correlate the leakage of some operations with a hypothetical model.

Non-invasive attacks can use power consumption, electromagnetic (EM) radiation, and timing measurements to extract information. The measurement techniques rely on the data-dependent internal behavior of the underlying system. Exemplary non-invasive attacks include power analysis attacks. Power analysis can be used to identify the specific portions of the program being executed to induce timing glitches that may be used to bypass key checking.

A known solution to protect arithmetic operations against such attacks threat is masking as described in Stefan Mangard, Elisabeth Oswald, and Thomas Popp. Power Analysis Attacks: Revealing the Secrets of Smart Cards. Springer, December 2006. ISBN 0-387-30857-1. “Masking” refers to a change of intermediate variables of the computation into randomized versions which are thus decorrelated from the unprotected variables, each being a potential target for a side-channel attack.

In particular, the mainstream approach consists in using purely Boolean Masking (BM). This is the case of widely used and standardized ciphers, such as DES (Data Encryption Standard) and AES (Advanced Encryption Standard). In both DES and AES examples, most cryptographic operations (except from simple data move, which does not leak by itself) are implemented using XORs and in look-up-tables (LUTs). Boolean masking (BM) shall be configured to achieve higher-order protections. However, the Boolean masking has merely no protection when the noise level is low, and the usual transitional leakages can downgrade the protection.

Another approach to perform masking is called inner product masking (IPM). IPM shall reduce or even prevent transitional leakages. However, such approach also suffers from noise level dependence. More generally, IPM can be further enhanced by utilising better linear codes, and extended to other masking schemes.

Besides, the processing system can also be victim of physical perturbations, which can lead to a corruption of the result. Such malfunction is harmful to both the processing system safety and cybersecurity. Indeed, from a safety point of view, incorrect results likely yield unspecified behaviours, with severe impacts unless detected. From a cybersecurity point of view, attacks can result in exploitation paths leading to cryptanalysis. Detection is one technique to protect against this devastating consequence. However, usually, detection is hard to build into the processing system, and can also be contradictory with the passive side-channel protections.

There is consequently a need for improved systems, methods, and computer program products for improving the protection of a processing function implemented by a processing system against non-invasive attacks.

SUMMARY OF THE INVENTION

To address these and other problems, there is provided a processing system (1) configured to execute a processing function ƒ(x) in response to the receipt of an input information word x comprising k information symbols, the processing system comprising a protection device configured to protect the execution of the processing function. The processing system comprises a processing unit configured to execute the processing function, the processing unit being configured to decompose the processing function ƒ into one or more basis operations comprising one or more elementary operations between two operands, the elementary operations comprising at least a component-wise multiplication operation. The processing unit comprises a multiplier configured to perform the multiplication operation, and the protection device comprises at least:

• • an encoding matrix determination unit configured to randomly determine an information code C and a masking code D being linear codes, the information code and the masking code satisfying one or more predefined code properties, and to determine the encoding matrix A from the information code and the masking code, the encoding matrix A being determined by vertically stacking the vectors of the information code and of the masking code;
  • an encoder configured to apply an encoding operation to an encoder input comprising information symbols, the encoding operation consisting in encoding the encoder input using the encoding matrix A, which provides an encoded word corresponding to the encoder input.

The processing device is configured to apply the encoder to the input information word x, and to each operand of an elementary operation, each elementary operation being applied to the encoded words determined by the encoder for each operand,

The multiplication operation performed by the multiplier is further masked using the pseudo-inverse matrix A⁻¹ of the encoding matrix A, and the pseudo-inverse transpose matrix A^−T of the encoding matrix A, such that (A^T)−1=(A⁻¹)^T.

In some embodiments, the encoding matrix A may be applied by the encoder to pad k information symbols of an encoder input with m random numbers, the output of the encoder being a masked vector x of length n, with n≥k+m, the masked vector {circumflex over (x)} belonging to , the encoding matrix A being an (k+m)×n matrix in the field .

In some aspects, in response to the receipt of an encoder input X, the encoder is configured to determine random masks M_X∈ and an error indicator ϵ_X∈ in association with the encoder input X, and to encode the encoder input using the encoding matrix A, the random masks M_X and the error indicator ϵ_X.

In some embodiments, the encoder output x may be determined as:

{circumflex over (X)}=(X,M_X,ϵ_X)A

The encoding matrix belongs to and n′=k+m+e.

In some aspects, in response to the receipt of two inputs {circumflex over (X)} and Ŷ masked by the encoder, the multiplier may be configured to:

• • determine the cross-product W of the masked vectors and of the random matrix as W={circumflex over (X)}^TŶ;
  • apply a flatten function to A^−TW which provides a flattened matrix T defined as T=flatten (A^−TW), where A^−T is the pseudo-inverse transpose matrix of the encoding matrix A;
  • determine the result of the multiplication {circumflex over (Z)} by performing the product of the flattened matrix T and of the matrix Ŝ such that {circumflex over (Z)}=TŜ.

In response to the receipt of two inputs x and Y masked by the encoder, the multiplier may be configured to:

• • determine a random seed sd uniformly in ;
  • determine, a random matrix {circumflex over (R)} from the random seed;
  • determine the sum W of the cross-product of the masked vectors and of the random matrix as ={circumflex over (X)}TŶ+{circumflex over (R)};
  • apply a flatten function to A^−TW which provides a flattened matrix T defined as T=flatten (A^−TW), where A^−T is the pseudo-inverse transpose matrix of the encoding matrix A;
  • determine the result of the multiplication {circumflex over (Z)} by performing the product of the flattened matrix T and of the matrix Ŝ such that {circumflex over (Z)}=TŜ.

In some aspects, the elementary operations may further comprise a component-wise addition operation and the processing device may comprise an adder configured to perform the addition operation using inputs previously encoded by the encoder.

In some aspects, the protection device may further comprise a decoder configured to apply a decoding operation to word {circumflex over (X)} previously encoded by the encoder, the decoder being configured to provide a decoder output comprising original data X, using the encoded word {circumflex over (X)} and the pseudo-inverse matrix A⁻¹ of the encoder matrix A.

The decoder output may further comprise random masks M_X∈ and an error indicator ϵ_X∈ in association with the output original data X, and the decoding operation DEC_msk applied by the decoder may be defined by:

${\mathrm{DEC}}_{\mathrm{msk}}\left(\hat{X}\right)=\hat{X}{A}^{-1}=\left(X,M_X,{ϵ}_X\right)$

In some aspects, the protection device may further comprise a refreshing unit configured to perform a refreshing operation, at one or more instant times during the execution of the processing function, the refreshing operation consisting in determining a refreshed encoded word {circumflex over (X)}′ for an encoder input word X previously applied to the decoder to determine encoded word {circumflex over (X)} such that both encoded word {circumflex over (X)} and the refreshed encoded word {circumflex over (X)}′ correspond to the same input information word X, the refreshing unit being configured to replace the encoded word {circumflex over (X)} by the refreshed encoded word {circumflex over (X)}′.

In some aspects, the protection device may further comprise a checking unit configured to perform a checking operation consisting in checking if a computing error occurred in the operations performed by the encoder, the adder, or the multiplier.

The checking unit may be configured to check whether the error indicator variable ϵ_X associated with the word X meets the condition ϵ_X=cst where cst is a predefined constant, and to detect whether an error occurred from the condition.

Wherein no error is detected if ϵ_X=cst, and if the error indicator variable ϵ_X is different from the predefined constant cst, the checking unit may be configured to further apply a syndrome decoding technique using syndromes of linear codes to determine if an error occurred.

In some aspects, the masking code may have the largest possible dual distance, in the finite field of interest for the application to satisfy a security code criteria and/or the masking code may be sparse or structured to satisfy a performance power area (PPA) code criteria.

In some aspects, the information code and the random code, used to generate the encoding matrix A, have no intersection of non-zero codewords.

In one embodiment, the encoding matrix A may be generated from a Vandermonde matrix.

There is also provided a method, implemented in a processing system, for executing a processing function ƒ(x) in response to the receipt of an input information word x comprising k information symbols, the method comprising protecting the execution of the processing function. The execution of the processing function comprises decomposing the processing function ƒ into one or more basis operations comprising one or more elementary operations between two operands, the elementary operations comprising at least a multiplication operation, the multiplication being a component-wise multiplication, the processing function execution step comprising:

• • randomly determining an information code and a masking code, being linear codes, the information code and the masking code satisfying one or more predefined code properties,
  • determining an encoding matrix A from the information code and the masking code, the matrix A being determined by vertically stacking the vectors of the information code and of the masking code;
  • applying an encoding operation to the input information word x, and to each operand of an elementary operation, prior the execution of the elementary operation, the encoding operation consisting in encoding the input received in the encoding step using the encoding matrix A;
  • executing the one or more elementary operations by applying the elementary operations to the operands encoded in the encoding step;
  • wherein the multiplication operation is further masked using the pseudo-inverse matrix A⁻¹ of the encoding matrix A, and the pseudo-inverse transpose matrix A^−T of the encoding matrix A.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate various embodiments of the invention and, together with the general description of the invention given above, and the detailed description of the embodiments given below, serve to explain the embodiments of the invention.

FIG. 1 depicts a processing system, in accordance with embodiments of the invention;

FIG. 2 is a detailed view of the protected system, according to some embodiments;

FIG. 3 is a flowchart depicting a masked encoding method, according to some embodiments of the invention.

FIG. 4 is a flowchart depicting a masked multiplication method, according to some embodiments of the invention.

FIG. 5 is a flowchart depicting a masked multiplication method using internal randomness, according to some embodiments of the invention.

FIG. 6 is a flowchart depicting the method implemented by the checking unit to detect errors, according to some embodiments of the invention.

FIG. 7 is a flowchart depicting the method of executing a processing function, according to some embodiments of the invention.

DETAILED DESCRIPTION

Embodiments of the invention provide a processing system and a method that protects a processing function implemented by the processing system using an improved masking scheme.

Referring to FIG. 1, an operating environment in accordance with embodiments of the invention is shown. The operating environment includes a processing system 1 according to embodiments of the invention. The processing system 1 is configured to execute a processing function ƒ on an input information word X comprising k information symbols (the input information word can be also denoted X_in).

The processing function ƒ may be any function that is executed by a processing system 1 that can be decomposed into elementary operations including one or more additions and/or multiplications, and possibly additional operations. The processing function may be for example a cryptographic function (e.g. AES or SM4 function), an inference function, a statistics function on input data, a mean function, or a variance function, etc.

Indeed, these two elementary operations (addition and multiplication) are universal in that any digital computation involved in a processing performed by a processing system 1 can be achieved by interleaving them. They amount to evaluate arbitrary polynomials, which interpolate the processing function. More additional operations can be added, such as scaling (i.e., multiplication by a constant), exponentiation (i.e., iterated multiplications), etc. The decomposition of a processing function into basis operations (elementary operations and additional operation) may be determined so as to optimize performances.

The processing system 1 may be any information processing system, device, chip or circuit executing a processing function such as for example and without limitation a smartcard, a mobile device, a smart IoT device, or a crypto system. The following description of some embodiments of the invention will be mainly made with reference to a crypto system for illustration purpose only.

The processing system 1 comprises a protection device 10 configured to protect the execution of the processing function by applying an improved masking scheme, referred to hereinafter as a tweakable code-based masking (TCBM) scheme, against non-invasive physically attacks, such as side-channel attacks, and against (semi-) invasive attacks such as fault injection attacks, simultaneously under proper configurations.

Advantageously, the masking scheme depends on an encoded matrix A that is generated using at least two linear codes comprising an information code C and a masking code D without non-zero codeword in their intersection (i.e. the information code C and the random code D, used to generate the encoding matrix A, have no intersection of non-zero codewords). The masking scheme uses these two linear codes to determine a random sharing of a key-dependent sensitive variable by confusing the information words with random words. The random words may be generated by an in-chip true random number generators (TRNG), or input directly to the protection device 10.

The processing system 1 comprises a processing device 11 configured to execute the processing function, the processing device being configured to decompose the processing function ƒ into one or more basis operations comprising one or more elementary operations, and possibly one or more additional operations.

An additional operation may be for example and without limitations an operation among a scaling operation (such as a multiplication with a constant), an exponentiation (such as a self-multiplication performed a given number of times), an inverse operation, etc.

As used herein, an elementary operation refers to an addition operation or a multiplication operation. The addition operation and the multiplication operation are component-wise operations.

FIG. 2 represents the detailed structure of the processing system 1, according to some embodiments.

As shown in FIG. 2, the processing device 11 may comprise an adder 104 configured to perform an addition operation, and a multiplier 105 configured to perform a multiplication operation.

The protection device 10 may comprise an encoding matrix determination unit 101 configured to randomly determine the information code C and the masking linear codes D. The information code C and the masking code D satisfy predefined code property. The encoding matrix determination unit 101 is further configured to determine the encoding matrix A from the linear codes C and D.

Each of the information code C and the masking code D may be represented by a vector structure comprising a set of vectors. The matrix A is determined by stacking vertically vectors of information code C and of the masking code D.

The protection device 10 further comprises an encoder 102 configured to apply an encoding operation to the original input information word X and to each input (operand) of the elementary operations (addition, multiplication), the encoding operation consisting in encoding the received input using an encoding technique, which provides an encoded information word. Advantageously, the encoded operation applied by the encoder 102 is masked with the encoding matrix A. The encoding matrix A used by the encoder may subsequently remain the same for the execution of a series of elementary operations (additions, and multiplications) into which the processing function is decomposed. In particular, the encoding matrix A shall remain consistent end to end until the computation of the processing function is terminated, at which point the decoder 110 can be called. It should be noted that decoding and re-encoding afresh (i.e., with a new matrix A) is technically possible. However, refreshing the encoding matrix A during the execution of the processing function might lead to weak spots inbetween, that is a divulgation of an unmasked variable or undetected corruption of a variable, in both cases the “inner computation” variable having a risk to be sensitive (i.e., depending on a secret, or critical for the computation integrity).

Further, the multiplication operation performed by the multiplier 105 is masked using the pseudo-inverse matrix A⁻¹ of the encoding matrix A, and the pseudo-inverse transpose matrix A^−T of the encoding matrix A. As used herein, A^−T is a shortcut notation of (A⁻¹)^T.

In the embodiments where A is a square matrix, the pseudo-inverse matrix A⁻¹ of the encoding matrix A is the inverse matrix, and the pseudo-inverse transpose matrix A^−T of the encoding matrix A is the inverse transpose matrix (the term “pseudo-inverse” is therefore used herein for the general case where the encoding matrix is rectangular).

In some aspects, the encoder 102 may be configured to encode all internal variables involved in the execution of the basis operations including the internal variable involved in the additional operations. In such embodiments, only the initial data input X (also denoted X_in) and final output of f(X) can be in plain-text (non-encoded). The initial data input X may be initially in plain-text (not encoded), but when it is used to execute the processing function, the initial data input X is encoded.

In some embodiments, the encoding matrix A specifies a general code-based masking (CBM) scheme consisting in padding the k symbols with m random numbers to determine a masked vector of length n (n≥ k+m) belonging to , the encoding matrix A being a (k+m)×n matrix with elements in the field .

In some embodiments, the random determination of the information code C and the masking code D comprise selecting the information code C and the random D such that the codes C and D satisfy one or more code properties, which may include security properties and/or efficiency properties in terms of PPA (Performance, Power & Area).

For example, in aspect, the masking code D may be determined such as it has the largest possible dual distance, in the finite field of interest for the application to satisfy a security property.

In another aspect, the masking code D may be sparse (even in its subfield, e.g., , when the main field is composite) or structured to satisfy a performance power area (PPA) criteria.

In some embodiments, the information code C and the masking code D are determined such that they do not overlap (except in {0}) and span a subspace.

The protection device 10 may further comprise a decoder 110 configured to apply a decoding operation to words which have been previously encoded by the encoder 102 during the execution of the processing function (input data x received by the processing system 1 and/or inputs of the elementary functions). In response to a received encoded input {circumflex over (X)}, the decoder 110 is configured to provide a decoder output comprising the original data X, using the received encoded input x and the pseudo-inverse matrix A⁻¹ of the encoder matrix A.

In some aspects, the protection device 10 may further comprise a refreshing unit 106 configured to perform a refreshing operation, at one or more instant times during the execution of the processing function, the refreshing operation consisting in determining a refreshed encoded word {circumflex over (X)}′ for an encoder input word X previously applied to the encoder 102 to deliver an encoded word {circumflex over (X)} such that both encoded word X and the refreshed encoded word X′ correspond to the same input information word X, the refreshing unit 106 being configured to replace the encoded word {circumflex over (X)} by the refreshed encoded word {circumflex over (X)}′.

The protection device 10 may also comprise a checking unit 108 (also called ‘fault detection unit’) configured to perform a checking operation consisting in checking if a computing error occurred in the operations performed by the encoder 102, the adder 104, and or the multiplier 105.

The embodiments of the invention enable protecting information against side-channel analysis (SCA) and fault injection attacks (FIA) using masking. The protection against side-channel analysis requires code-based masking with random numbers, whereas protecting against fault injection attacks requires error-detection coding on top of masked information.

The protection device 10 is configured to ensure side-channel protection against side-channel attacks and to perform fault injection detection.

To facilitate the understanding of the following description of some embodiments, the following definitions are provided.

It is considered that the information processing system 1 manipulates information word represented as vectors of information symbols, the information symbols belonging to a finite field , which can be:

• • a binary field, i.e. =, when symbols are bit vectors of length q, or simply
  • a prime field, i.e. =, where p is a prime number, when symbols are natively integers modulo p.

The following description of some embodiments of the invention will be essentially made with reference to any finite field F of characteristic p (p being a prime number, equal to 2 or more). The notation F will be therefore used to represent the considered finite field. For instance:

• • In an application of the invention where the processing function is an AES or SM4 function, == (byte-oriented),
  • In an application of the invention where the processing function is a lightweight ciphers PRESENT function, == (nibble-oriented),
  • In an application of the invention where the processing function is a Post-Quantum Cryptographic algorithm, such as Crystals Kyber function, == or Crystals Dilithium function, ==.

An input information word x, to which the execution function ƒ is to be applied, consists in k symbols, which can be protected together (e.g., utilizing concept of “cost amortization”).

The side-channel protection leverages m independent random masks y.

The fault detection is applied on top, and allows inserting some redundancy to be able to verify that the data z be not altered. It consists in applying a word of e symbols and checking for its value at some points in the function execution method. For example, these e words are null. The fact that the redundancy “covers” the masked data allows to avoid this protection from diminishing (interfering negatively) with it.

In the following description of some embodiments, the following notations will be used:

uppercase letters (e.g., X) will be used for random variables and lowercase letters (e.g., x) will be used for their realizations.

Vectors and matrices (e.g., X) will be generally written in bold characters and subscripts (e.g., X_i or X_i,j) are used to index the elements of such data structures.

the parameters k, m, e and n will be used to denote respectively the size of information symbols, the size of random masks, the size of error detection indicators and the size of masking sharing.

The parameters k, m, e and n are such that n≥k+m+e. In the following description, it will be considered that n′=k+m+e for the sake of simplification and for illustration purpose only, so that n≥n′.

All the computations performed by the protection device 10 and the processing device 11 are performed in the finite field .

Further:

• • The notation X will be used to denote any information variable (also called ‘information word’) that is encoded by the protection device 10 with includes the initial input received by the processing system 1 to which the processing function ƒ is to be applied, but also one of the inputs to which on elementary operation is to be applied (the other input being noted Y);
  • Then notation M_X will be used to denote the mask variable associated with X;
  • The notation ϵ_X will be used to denote the error indicator variable associated with X;
  • The notation {circumflex over (X)} will be used to denote the encoded variable (Ŷ for the other input Y);
  • The notation {circumflex over (Z)} or {circumflex over (Z)}′ will be used to denote the output resulting from the execution of an elementary operation, corresponding to original data Z or Z′ respectively.

Further, some intermediary functions used in relation with embodiments of the invention are further defined.

A first intermediary function is called flatten function. A flatten function serializes a matrix to a vector by concatenating each row in the matrix. Specifically, the operator flatten turns an I×J matrix M, defined according to equation 1, with elements in , into a vector which contains all elements albeit laid out in a linear arrangement:

$\begin{array}{cc}M=\left(\begin{array}{ccc}{m}_{1,1}& \cdots & m_{1,J}\\ m_{2,1}& \cdots & m_{2,J}\\ ⋮& \ddots & ⋮\\ m_{I,1}& \cdots & m_{I,J}\end{array}\right)& \left(1\right)\end{array}$

Taking a matrix M as in equation (1), the way the flatten function operates is defined according to formula (2):

$\begin{array}{cc}\mathrm{flatten}:{𝔽}^{I\times J}\to {𝔽}^{1\times \mathrm{IJ}}& \left(2\right)\end{array}$ $\mathrm{flatten}\left(M\right)=\left(m_{1,1},\dots ,m_{1,J},\dots ,m_{2,1},\dots ,m_{2,J},\dots ,m_{I,1},\dots ,m_{I,J}\right)$

The inverse operation of the flatten function, denoted flatten⁻¹, reshapes a vector to a matrix. More specifically, taking a (row) vector ∈, the inverse flatten function flatten⁻¹ operates according to equation (3):

$\begin{array}{cc}{\mathrm{flatte}}^{-1}:{𝔽}^{1\times \mathrm{IJ}}\to {𝔽}^{I\times J}& \left(3\right)\end{array}$ ${\mathrm{flatten}}^{-1}\left(V\right)=\left(\begin{array}{ccc}{v}_1& \cdots & v_{1J}\\ v_{J+\mathrm{\cdots 1}}& \cdots & v_{2J}\\ ⋮& \ddots & ⋮\\ v_{\left(I-1\right)J+1}& \cdots & v_{\mathrm{IJ}}\end{array}\right)$

As used herein, the notation with the exponent 1×IJ is used to indicate that the vector is horizontal.

A second intermediary function used in connection with embodiments of the invention is called ‘pick function’. The pick function picks some elements in a vector. The pick function can be expressed by using the vectorized operation by multiplying with a matrix S.

While the flatten operator will yield an I·J-long vector when fed with a I×J matrix, the pick operator picks the first element in the first J-symbol chunk, then the second element in the second J-symbol chunk, etc. It will be considered in the following description, that I≤J.

By induction, the matrix S in pick operator is defined as:

$\begin{array}{cc}S=\left(\frac{\frac{S_1}{S_2}}{\frac{⋮}{S_I}}\right)=\left(\begin{array}{cccc}1& 0& \cdots & 0\\ 0& 0& \cdots & 0\\ ⋮& ⋮& \ddots & ⋮\\ \underset{\_}{0}& \underset{\_}{0}& \underset{\_}{\cdots }& \underset{\_}{0}\\ 0& 0& \cdots & 0\\ 0& 1& \cdots & 0\\ ⋮& ⋮& \cdots & ⋮\\ \underset{\_}{0}& \underset{\_}{0}& \underset{\_}{\cdots }& \underset{\_}{0}\\ \underset{\_}{⋮}& \underset{\_}{⋮}& \underset{\_}{\ddots }& \underset{\_}{⋮}\\ 0& 0& \cdots & 0\\ ⋮& ⋮& \cdots & ⋮\\ 0& 0& \cdots & 1\\ ⋮& ⋮& \cdots & ⋮\end{array}\right)\in {𝔽}^{\mathrm{IJ}\times J}& \left(4\right)\end{array}$

In formula (4), each term S_i has a size J×I and has only single non-zero element (S_i)_i,i, for 1≤i≤I. If I≠J, then S is not a square matrix, but the pick operator keeps the same.

More formally, taking a vector X∈, the pick function is defined according to formula (5):

$\begin{array}{cc}\mathrm{pick}:{𝔽}^{1\times \mathrm{IJ}}\to {𝔽}^{1\times I}& \left(5\right)\end{array}$ $\mathrm{pick}\left(X\right)=\mathrm{XS}$

By combining the two operators flatten and pick, the following nominal operation to execute is obtained by taking two vectors x, y ∈ and I=J:

$\begin{array}{cc}\mathrm{pick}\left(\mathrm{flatten}\left(x^{T}y\right)\right)=\mathrm{flatten}(\left(x^{T}y\right)S=\left(x_1{y}_1,\dots ,x_I{y}_I\right)& \left(6A\right)\end{array}$

The combined operator pick (flatten (x^Ty)) actually selects the diagonal elements of the targeted matrix in a vectorial fashion so that:

$\begin{array}{cc}\mathrm{diag}\left(x^{T}y\right)=\mathrm{pick}(\mathrm{flatten}(x^{T}y\left)\right)=\mathrm{flatten}(\left(x^{T}y\right)S& \left(6B\right)\end{array}$

In the following description of some embodiments, the size of S will be specified depending on the operation context.

The encoding matrix A used by tweakable code-based masking scheme is a matrix that turns k symbols of information and m symbols of masking material into a masked vector of length n (recall that n≥n′=k+m+e), which shall detect e faults. The matrix A is therefore a rectangle n′×n matrix in IF.

In some embodiments, the encoding matrix A may be a square matrix for example.

The encoding matrix A specifies a general code-based masking scheme.

The inverse matrix of A is denoted as A⁻¹ and the pseudo-inverse transpose matrix of A is denoted A^−T. Therefore A⁻¹ and A^−T satisfy the equation:

${\left(A^T\right)}^{-1}={\left(A^{-1}\right)}^T$

It should be noted that if the encoding matrix A is not square, the encoding matrix A may be defined using a Vandermonde matrix V, of size n×n. A Vandermonde matrix V is related to Reed-Solomon codes. as the generator matrix of a Reed-Solomon code is a Vandermonde matrix. The use of Vandermonde matrices to generate the encoding matrix is particularly advantageous, as reed-Solomon codes are optimal codes, in the sense that they reach the Singleton bound. Moreover, random Vandermonde matrices are easy to build. It is sufficient to select n different non-zero field elements α₁, . . . , α_n, and to define the matrix V as V=(α_j^i-1), where 1≤i≤n is the row index and 1≤j≤n the column index. In such case, the encoding matrix A can be written:

$A=\left(I_{n^{\prime }}0\right)V\in {𝔽}^{n^{\prime }\times n}$

As a result, the pseudo-inverse matrix of A, also denoted by A⁻¹, is equal to:

$A=V^{-1}\left(\begin{array}{c}{I}_{n^{\prime }}\\ 0\end{array}\right)\in {𝔽}^{n\times n^{\prime }}$

As mentioned, a Vandermonde matrix is a matrix with the terms of a geometric progression in each row (a sequence of non-zero numbers where each term after the first in the row is found by multiplying the previous one by a fixed, non-zero number also referred to as “common ratio”). Therefore, the entries of the V matrix denoted V_i,j meet the relation V_i,j=v_i^j, with v_i^j being the j-ème power of the number v_i, for all zero-based indices i and j.

Considering the above construction of A and A⁻¹, then:

$\begin{array}{cc}A·A^{-1}=I_{n^{\prime }}\in {𝔽}^{n^{\prime }\times n^{\prime }}& \left(7\right)\end{array}$

For each received input vector X∈, the protection device is further configured to determine random masks M_X∈ and an error indicator ϵ_X∈. The random masks may be refreshed as often as possible. The error indicator ϵ_X may be for example set to the zero constant. The random masks M_X may be initialized by taking random values over , that is uniformly distributed.

We can add a sentence saying that random masks are generated (initialized) randomly.

The matrix A may be pre-computed and then used to encode any input data X.

FIG. 3 is a flowchart depicting the masked encoding operation applied by the encoder 102 using a generated encoding matrix A, according to some embodiments.

The encoding matrix A enables taking k information symbols to process an input information word x, and padding those symbols with m random numbers and e nulls to get a masked vector {circumflex over (x)}∈.

In step 300, the input information vector X∈ is received.

In step 301, the associated random masks M_X∈ and the associated error indicator ϵ_X∈ are determined.

In step 302, the generated encoding matrix A is received.

In step 303, the input information vector X∈ is encoded (or masked) using the encoding matrix A and random masks M_X. More specifically, given the information X∈, the random masks M_X∈ and the error indicator ϵ_X∈, the encoder matrix A∈ is applied in step 202 to mix X, M_X, and ϵ_X such that the unprotected input information vector X becomes a masked vector {circumflex over (X)}∈ defined by:

$\begin{array}{cc}\hat{X}=\left(X,M_X,{ϵ}_X\right)A& \left(8\right)\end{array}$

In equation (8), (X, M_X, ϵ_X) is multiplied by the matrix A.

In step 304, the masked X, also referred hereinafter as a CBM-protected vector, is returned. The masked vector X can advantageously resist side-channel attacks up to order d_s=d−1, where d is the dual distance of the linear code D generated by the matrix and is equal to the m lines of A after the first k lines (i.e. the linear code D is generated by lines k+1 to k+m in the encoding matrix A).

In particular, d_s may equal m if A has a full rank.

The multiplication by the matrix A as defined in equations (7) and (8) implements the generic encoder 102, where n′ is defined by n′=k+m+e.

The protection device 10 may include a further fault detection capability denoted by d_f such that d_f=e implemented by the checking unit 108.

Among the elementary operations into which a processing function can be decomposed, the multiplication is usually the most costly operation in masking scheme over .

The multiplication operation performed by the multiplier 105 corresponds to a component-wise product. The component-wise product of the k information symbols is not a natural operation. The outer product is, but yields k² cross-coupled products. Therefore, there is a need to manage the return from k² intermediate results into the k ones that matter.

A prior art component-wise product, without masking, refers to the operation that computes, given two input vectors X and Y having the same length k:

$\begin{array}{cc}\mathrm{prod}:{𝔽}^k\times {𝔽}^k\to {𝔽}^k& \left(9\right)\end{array}$ $Z=\mathrm{prod}\left(X,Y\right)=\left(X_1{Y}_1,X_2{Y}_2,\dots ,X_k{Y}_k\right)$

In should be noted that the parameter k in equation (9) is an arbitrary positive integer, not limited to the length of information words. In the presence of masking, the component-wise product involves all n shares, making it more complicated to achieve.

An elementary operation performed by the adder 104 or by the multiplier 105 involves two operands that will be noted hereinafter x and y, or X and Y in their vector representation, which correspond to input variables applied to an elementary operation associated with the execution of the processing function. Although the same notation x or X is used to designate one of the inputs of the adder or the multiplier, and the initial input received by the processing system 1 on which the execution function ƒ is to be applied, it should be noted that they refer to distinct variable. Such similar notation is in particular used to simplify the description of the encoding performed by the encoder 104 as it applies not only to the initial data received by the processing system 1 (otherwise referred to as X_in) but also to the inputs received by the adder 104 or by the multiplier 105, prior to the execution of the addition or multiplication operation.

Indeed, according to some aspects, prior to executing the addition operation or the multiplication operation, the two inputs received by the adder 104 or the multiplier 105 respectively, namely the vectors x and y, are protected by the encoder 102, according to the encoding method described with reference to FIG. 3, which provides the masked vectors {circumflex over (x)} and ŷ, or {circumflex over (X)} and Y in their vector representation, defined respectively by {circumflex over (x)}=(x, M_X, ϵ_X)A and ŷ=(y, M_y, ϵ_y) A. Further, any intermediate variable involved in the multiplication may be equally masked.

The multiplier 105 is configured to apply a masked component-wise product function prod_msk to inputs {circumflex over (X)} and Ŷ being the masked vectors of X and Y respectively, defined as:

$\begin{array}{cc}{\mathrm{prod}}_{\mathrm{msk}}:{𝔽}^n\times {𝔽}^n\to {𝔽}^n& \left(10\right)\end{array}$ $\hat{Z}={\mathrm{prod}}_{\mathrm{msk}}\left(\hat{X},\hat{Y}\right)$

Equation (10) is such that the demasked variable is defined by:

$Z=\mathrm{prod}\left(X,Y\right)=\left(X_1{Y}_1,X_2{Y}_2,\dots ,X_k{Y}_k\right).$

The masked component-wise product function may be redefined as:

$\begin{array}{cc}\hat{Z}={\mathrm{prod}}_{msk}\left(\hat{X},\hat{Y}\right)=\mathrm{flatten}\left(A^{-T}\left({\hat{X}}^T\hat{Y}\right)\right)\hat{S}& \left(11\right)\end{array}$

In equation (11), the matrix S is an initialization of equation (4), with I=J=n′, and Ŝ∈ is defined according to formula (12):

$\begin{array}{cc}\hat{S}=\left(\begin{array}{cccc}{A}^{-1}& 0& \dots & 0\\ 0& A^{-1}& \dots & 0\\ ⋮& ⋮& \ddots & ⋮\\ 0& 0& \dots & A^{-1}\end{array}\right)\mathrm{SA}& \left(12\right)\end{array}$

Indeed, equation (8) can be simplified using the following notations:

$\begin{array}{cc}a=\left(X,M_X,{ϵ}_X\right)A\in {𝔽}^{n^{\prime }}\Rightarrow \hat{X}=\mathrm{aA}& \left(13\right)\end{array}$ $b=\left(Y,M_Y,{ϵ}_Y\right)A\in {𝔽}^{n^{\prime }}\Rightarrow \hat{Y}=\mathrm{bA}$

Accordingly, it comes:

$\begin{array}{cc}{A}^{-T}\left({\left(\mathrm{aA}\right)}^T\left(\mathrm{bA}\right)\right)=\left(a^{T}b\right)A=a^T\left(\mathrm{ba}\right)=\left(\begin{array}{c}\left(a_1{b}_1,\dots ,a_1{b}_{n^{\prime }}\right)A\\ \left(a_2{b}_1,\dots ,a_2{b}_{n^{\prime }}\right)A\\ ⋮\\ \left(a_{n^{\prime }}{b}_1,\dots ,a_{n^{\prime }}{b}_{n^{\prime }}\right)A\end{array}\right)& \left(14\right)\end{array}$

Therefore, the right-hand side of Equation (11) can therefore be written according to formula (15):

$\begin{array}{cc}\begin{array}{c}\mathrm{flatten}\left(A^{-T}\left({\hat{X}}^T\hat{Y}\right)\right)\hat{S}=\mathrm{flatten}\left(A^{-T}\left({\left(\mathrm{aA}\right)}^T\left(\mathrm{bA}\right)\right)\right)\hat{S}\\ =\mathrm{flatten}\left(\begin{array}{c}\left(a_1{b}_1,\dots ,a_1{b}_{n^{\prime }}\right)A\\ \left(a_2{b}_1,\dots ,a_2{b}_{n^{\prime }}\right)A\\ ⋮\\ \left(a_{n^{\prime }}{b}_1,\dots ,a_{n^{\prime }}{b}_{n^{\prime }}\right)A\end{array}\right)\hat{S}\\ =\left(\mathrm{flatten}\left(a^{T}b\right)S\right)A\\ =\left(a_1{b}_1,a_2{b}_2,\dots ,a_{n^{\prime }}{b}_{n^{\prime }}\right)A\\ =\hat{Z}\end{array}& \left(15\right)\end{array}$

FIG. 4 is a flowchart depicting the method for determining a masked component-wise multiplication {circumflex over (Z)}=prod_msk ({circumflex over (X)}, Ŷ) from two masked variables x and Ŷ received as inputs.

In step 410, the two masked variables {circumflex over (X)} and Ŷ are received.

In step 412, the pseudo-inverse matrix A⁻¹ of A, the pseudo-inverse transpose matrix A^−T of A and the matrix Ŝ defined by formula 12 are retrieved. The pseudo-inverse matrix A⁻¹ of A, the pseudo-inverse transpose matrix A^−T of A and the matrix S defined by formula 12 may be precomputed and used for the complete execution of the processing function (which may comprise a series of elementary operation such as for example a series of additions and multiplications in the case of the AES algorithm).

In step 414, the cross-product W of the masked vectors is determined from the first masked variable X and the second masked variable Ŷ such that W={circumflex over (X)}^TŶ.

In step 416, the result of the multiplication is flattened by applying the flatten function to A^−TW which provides the flattened matrix T defined as T=flatten (A^−TW).

In step 418, the protected multiplication {circumflex over (Z)} is determined by performing the product of the flattened matrix T and of the matrix Ŝ such that {circumflex over (Z)}=TŜ.

In step 410, the result is returned {circumflex over (Z)}.

The end-to-end masked equation (11) is inspired by the computation specified in equation (6).

In equation (15), the following variables are all masked:

• • The variables (aA) and (bA);
  • The variable (flatten(a^Tb)S)A.

In equation (11), the expressions are to be evaluated in the order governed by the parentheses. Besides, in some embodiments, the left-wise application of A^−T of equation (11) may be delayed.

It should be noted that the matrix S may be pre-computed for speed-up online computation, instead of computing it in step 412 in the same step as the pseudo-inverse matrix A⁻¹ of A, the pseudo-inverse transpose matrix A^−T of A.

In some cases, if step 416 is not performed as expected, certain vulnerabilities might appear (for example unintended demasking of either {circumflex over (X)} or Ŷ). To prevent such vulnerabilities, in some embodiments, some internal randomness may be added to enhance the side-channel resistance in step 416 (flattening step).

In such embodiments using internal randomness, the method of determining a masked component-wise multiplication may comprise a generation of a random matrix and use the random matrix to enhance the side-channel resistance in step 416.

To introduce the internal randomness and generate the random matrix, a parameter γ∈{0, . . . , n²−1} may be introduced, representing a linear indexing of a matrix of size n×n and defined by γ=μn+λ, where μ and λ ϵ{0, . . . , n−1}. For the sake of simplifications, the notation B=A^−T and B′=A⁻¹ will be also used.

The random matrix {circumflex over (R)}∈ may be determined such that diag(A^−T{circumflex over (R)}A⁻¹)=diag(B′{circumflex over (R)}B′)=0_n′, where diag denotes the diagonal elements of the matrix and 0_n, is a zero-vector of length n′.

The element (i, i) of B{circumflex over (R)}B′ for 0≤i≤n′, is equal to:

$\begin{array}{cc}{\sum }_{\mu ,\lambda }{B}_{i,\mu }{\hat{R}}_{\mu ,\lambda }{B}_{\lambda ,i}^{\prime }={\sum }_{\mu ,\lambda }{\hat{R}}_{\mu ,\lambda }\left(B_{\mu ,i}^{\prime }{B}_{\lambda ,i}^{\prime }\right)={\sum }_{\gamma }{\hat{R}}_{\gamma }\left(B_{\gamma ÷n,i}^{\prime }{B}_{\gamma \mathrm{mod}n,i}^{\prime }\right)& \left(16\right)\end{array}$

In formula (16), R is the linearized vector of the matrix {circumflex over (R)} of length n², and is defined by R=flatten({circumflex over (R)}). Then the solution exists in:

$\begin{array}{cc}\overline{R}M=0_{n^{\prime }}& \left(17\right)\end{array}$

In equation (17), M is an n²×n′ matrix, whose (i, j) coefficient is:

$\begin{array}{cc}{M}_{i,j}=B_{i÷n,j}^{\prime }{B}_{i\mathrm{mod}n,j}^{\prime }& \left(18\right)\end{array}$

For example, the solution to equation (18) may be given in Magma computer algebra system by using the KernelMatrix.

The generation of the random matrix R may then comprise:

• • Determining a random seed sd uniformly in ;
  • Determining the kernel matrix of M, denoted as ker(M);
  • Determining the random matrix {circumflex over (R)}=flatten⁻¹(sd·ker(M)).

Using equations (16) and (17), each element (i, i) of A^−T{circumflex over (R)} A⁻¹ equals 0 for 1≤i<n′. Therefore, the generated random matrix R satisfies the following equation (19):

$\begin{array}{cc}\mathrm{diag}\left(A^{-T}\hat{R}{A}^{-1}\right)=\mathrm{diag}\left(B\hat{R}C\right)=0_{n^{\prime }}& \left(19\right)\end{array}$

The determination of the masked component-wise product defined in equation (11) can be enhanced by adding internal randomness according to equation (20):

$\begin{array}{cc}\hat{Z}=pro{d}_{msk}\left(\hat{X},\hat{Y}\right)=\mathrm{flatten}\left(A^{-T}\left({\hat{X}}^T\hat{Y}+\hat{R}\right)\right)\hat{S}& \left(20\right)\end{array}$

The matrices S and S used in equation (20) are the same as the ones used in equation 11.

Indeed, given a matrix M, according to equation (6B), the diagonal elements of the matrix M are defined by:

$\mathrm{diag}\left(M\right)=\mathrm{pick}(\mathrm{flatten}(M))=\mathrm{flatten}\left(M\right)S$

Equation (19) further indicates that flatten (A^−TR A⁻¹) S=0_n′

Therefore:

$\begin{array}{cc}\begin{array}{c}\mathrm{flatten}\left(A^{-T}\left({\hat{X}}^T\hat{Y}+\hat{R}\right)\right)\hat{S}=\mathrm{flatten}\left(A^{-T}\left({\hat{X}}^T\hat{Y}\right)+A^{-T}\hat{R}\right)\hat{S}\\ =\mathrm{flatten}\left(A^{-T}\left({\hat{X}}^T\hat{Y}\right)\right)\hat{S}+\mathrm{flatten}\left(A^{-T}\hat{R}\right)\hat{S}\\ =\mathrm{flatten}\left(A^{-T}\left({\hat{X}}^T\hat{Y}\right)\right)\hat{S}+\\ \mathrm{flatten}\left(A^{-T}\hat{R}{A}^{-1}\right)\mathrm{SA}\\ =\mathrm{flatten}\left(A^{-T}\left({\hat{X}}^T\hat{Y}\right)\right)\hat{S}+0_{n^{\prime }}A\\ =\mathrm{flatten}\left(A^{-T}\left({\hat{X}}^T\hat{Y}\right)\right)\hat{S}+0_{n^{\prime }}A\\ =\hat{Z}\end{array}& \left(21\right)\end{array}$

Accordingly, the determination of the masked component-wise product defined in equation (11) can be enhanced by adding internal randomness according to equation (20):

$\begin{array}{cc}\hat{Z}={\mathrm{prod}}_{msk}\left(\hat{X},\hat{Y}\right)=\mathrm{flatten}\left(A^{-T}\left({\hat{X}}^T\hat{Y}+\hat{R}\right)\right)\hat{S}& \left(20\right)\end{array}$

The matrices S and Ŝ are the same as the ones used in equation (11).

FIG. 5 is a flowchart depicting the method for determining a masked component-wise multiplication {circumflex over (Z)}=prod_msk({circumflex over (X)}, Ŷ) using the generated the random matrix {circumflex over (R)}, implemented by the multiplier 105 in response to the receipt of two inputs {circumflex over (X)} and Ŷ previously encoded by the encoder 102.

In step 501, the pseudo-inverse matrix A⁻¹ of A, the pseudo-inverse transpose matrix A^−T of A and the matrix Ŝ defined by formula 12 are retrieved. The pseudo-inverse matrix A⁻¹ of A, the pseudo-inverse transpose matrix A^−T of A and the matrix Ŝ may have been precomputed and used for all the computations performed by the encoder 102, the adder 104, the multiplier 105, and the decoder 110 during the execution of the processing function.

In step 502, the matrix M and the matrix ker(M) are pre-computed according to equation (18).

In step 503, determining a random seed sd is determined uniformly in

In step 504, the random matrix R is determined by performing {circumflex over (R)}=flatten⁻¹(sd·ker(M)).

In step 505, the sum W of cross-product of the masked vectors and of the random matrix is determined from the first masked variable {circumflex over (X)}, the second masked variable Ŷ and the random matrix {circumflex over (R)} such that W={circumflex over (X)}^TŶ+{circumflex over (R)}.

In step 506, the result of the multiplication is flattened by applying the flatten function to A^−TW which provides the flattened matrix T defined as T=flatten (A^−TW).

In step 507, the two masked variables x and Y are received.

In step 508, the protected multiplication 2 is determined by performing the product of the flattened matrix T and of the matrix Ŝ such that {circumflex over (Z)}=TŜ.

In step 510, the result is returned {circumflex over (Z)}.

Steps 502, 503, 504 and 505 have been added or modified with respect to the flowchart of figure NN. By using the random matrix {circumflex over (R)}, the potential vulnerability is fixed since it removes indirect demasking of {circumflex over (X)} and Ŷ.

It should be noted that the matrices M and ker(M) may be alternatively pre-computed instead of computing them in step 502, during the execution of the method.

The embodiments of the invention provide a tweakable code-based masking (TCBM) method and device against side-channel attacks by providing higher-order protection for crypto systems. Advantageously, the TCBM method and device be configured to detect faults against fault injection attacks.

Turning back to FIG. 1, by using the different blocks of the protection device 10 and of the processing device 11, any function ƒ of the processing system 1 (for example any cryptographic function such as AES (X) or any other function such as sqrt (X)) may be protected and implemented securely.

The tweakable code-based masking (TCBM) scheme enables to efficiently use masked protection and processing operations including:

• • The masked encoding operation ENC_msk applied by the encoder 102;
  • The masked decoding operation DEC_msk applied by the decoder 110;
  • The masked addition operation ADD_msk applied by the adder 102; and/or
  • The masked multiplication operation MULT_msk applied by the multiplier 105.

The masked protection and processing operations using the TCBM scheme may further include:

• • The masked refreshing operation REF_msk applied by the refreshing unit 106; and/or
  • The masked checking operation CHK_msk applied by the checking unit 108.

It should be noted that although some aspects of the instant disclosure are described herein conjointly (in particular the different component 102, 104, 105, 106, 108, 110), they can be used separately or independently or according to different combinations of components.

As described with reference to FIG. 3, the encoder 102 is configured to apply a masked encoding operation ENC_msk using the encoding matrix A defined by equation (8). Given an input information word vector X, the masked encoding operation comprises encoding X into a masked variable {circumflex over (X)} from X, the random mask M_X, the error indicator ϵ_X and the encoder matrix A such that:

$\begin{array}{cc}\hat{X}={\mathrm{ENC}}_{msk}\left(X,M_X,{ϵ}_X\right)=\left(X,M_X,{ϵ}_X\right)A& \left(22\right)\end{array}$

In some aspects, the decoder 110 may be configured to apply a masked encoding operation DEC_msk to an encoded input {circumflex over (X)} using the encoding matrix A. More specifically, given an input encoded word vector {circumflex over (X)}, the masked decoding operation outputs the original data X using {circumflex over (X)} and the inverse matrix A⁻¹ of the encoder matrix A such that:

$\begin{array}{cc}\left(X,M_X,{ϵ}_X\right)={\mathrm{DEC}}_{msk}\left(\hat{X}\right)=\hat{X}{A}^{-1}& \left(23\right)\end{array}$

In equation (23), A⁻¹ is the pseudo-inverse matrix of A, defined according to equation (7).

In some aspects, the adder 104 may be configured to determine the masked addition operation ADD_msk using the encoder matrix A. The masked addition operation performed by the adder 104 is a component-wise addition. More specifically, the adder 102 is configured to receive two encoded word vectors {circumflex over (X)} and Ŷ, which corresponds respectively to original data X et Y, previously encoded by the encoder 102 according to equation (20) using the encoding matrix A and to apply the masked addition operation to determine an encoded word {circumflex over (Z)}′, from Z′=X+Y=(X₁+Y₁, X₂+Y₂, . . . , X_n+Y_n)∈, {circumflex over (X)} and Ŷ such that:

$\begin{array}{cc}{\hat{Z}}^{\prime }={\mathrm{ADD}}_{msk}\left(\hat{X},\hat{Y}\right)=\left({\hat{X}}_1+{\hat{Y}}_1,{\hat{X}}_2+{\hat{Y}}_2,\dots ,{\hat{X}}_n+{\hat{Y}}_n\right)& \left(24\right)\end{array}$

The masked addition ADD_msk is also a component-wise addition.

It should be noted that the symbol ‘+’ used in the above two equations is equivalent to XOR in .

According to other aspects, the multiplier 105 may be configured to apply a masked multiplication operation MULT_msk using the encoding matrix A. The multiplier 105 is more specifically configured to receive two vectors {circumflex over (X)} and Ŷ, corresponding to original data X et Y, previously encoded by the encoder 102 according to equation (20) using the encoding matrix A, and to apply the masked multiplication operation to determine an encoded word such {circumflex over (Z)} which corresponds to Z such that Z=X·Y=(X₁Y₁, X₂Y₂, . . . , X_n Y_n)∈, {circumflex over (Z)} being defined according to equation (25):

$\begin{array}{cc}\hat{Z}={\mathrm{MULT}}_{msk}\left(\hat{X},\hat{Y}\right)={\mathrm{prod}}_{msk}\left(\hat{X},\hat{Y}\right)& \left(25\right)\end{array}$

{circumflex over (Z)} can be accordingly determined according to the multiplication method of FIG. 4 or 5 which determines prod_msk({circumflex over (X)}, Ŷ).

In some embodiments, the refreshing unit 106 may be configured to determine the masked refreshing operation REF_msk using the encoding matrix A. Given an input encoded word vector {circumflex over (X)}, previously encoded by the encoder 102 according to equation (20), the refreshing unit 106 is configured to output a new encoded word {circumflex over (X)}′ (‘refreshed encoded word’) using the encoder matrix A such that:

$\begin{array}{cc}{\hat{X}}^{\prime }={\mathrm{REF}}_{msk}\left(\hat{X}\right)={\mathrm{ADD}}_{msk}\left(\left(0,M_X^{\prime },0\right)A,\hat{X}\right)& \left(26\right)\end{array}$

The refreshed encoded word {circumflex over (X)}′ may be therefore determined by applying a component-wise addition between (0, M′_X, 0) A and the initially determined encoded word x.

The refreshing computation may be performed, anytime, for any input of the adder and/or the multiplier and/or only for the originally received input word. The frequency of the refreshing computation may vary depending on the application of the invention.

In some aspects, the checking unit 108 may be configured to perform a masked checking operation CHK_msk using the encoder matrix A.

FIG. 6 is a flowchart depicting the checking method implemented by the checking unit, according to some embodiments.

In step 600, an input encoded word vector x is received. Step 600 may further comprise receiving a predefined constant cst. The input encoded word vector x received in step 600 may be any word encoded by the encoding unit 102 that can be decoded and then checked. In particular, step 600 may apply to any encoded variable, including those input to the adder 104 and/or the multiplier 105.

In step 602, a first decoding of R is determined by the decoder 110 by performing (X, M_X, ϵ_X)=DEC_msk(X), using the encoding matrix A, according to equation (23), which provides the original vector X.

Step 603 consists in checking whether the error indicator variable ϵ_X associated with X meets ϵ_X=cst where cst is the predefined constant received in step 600.

In step 604, if it is determined that ϵ_X=cst, no error is detected (block 605).

In step 606, if it is determined that ϵ_X is different from cst (ϵ_X≠cst), it is checked whether an error occurred during the computation, by a syndrome decoding technique using syndromes of linear codes. Syndrome decoding is a method of decoding a linear code over a noisy channel, where errors may have been made. Syndrome decoding is a minimum distance decoding using a reduced lookup table.

If an error occurred (block 607), the error may be notified (block 608). Otherwise no error is detected (block 609).

It can be considered for example an encoding matrix A, generated from a Vandermonde matrix. Using a Vandermonde matrix for A has particular advantages as the linear codes generated by Vandermonde matrices are MDS (maximum distance separable) codes with maximized distances. The dual code of a MDS code is also a MDS code, so that the dual distance may be maximized, which can result in the optimal side-channel protection d_s. For instance, A is a (transposed) Vandermonde matrix that can be generated as:

$\begin{array}{cc}A=\left(\begin{array}{ccccc}1& 1& 1& \dots & 1\\ {\alpha }_1& {\alpha }_2& {\alpha }_3& \dots & {\alpha }_n\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ {\alpha }_1^{n^{\prime }-1}& {\alpha }_2^{n^{\prime }-1}& {\alpha }_3^{n^{\prime }-1}& \dots & {\alpha }_n^{n^{\prime }-1}\end{array}\right)& \left(29\right)\end{array}$

In the encoding matrix A according to definition (29), α_i≠α_j for any distinct i, j ∈[1, n]. The encoding matrix A can be optimized by selecting optimal elements α_i for 1≤i≤n in the sense that d_s is maximized at bit-level (e.g., over ).

Further, the following example will be made considering that q=8, and = like in the block ciphers AES or SM4, and the irreducible polynomial is: P(α)=α⁸=α⁴+α³+α²+1. Further, the parameters k, m, e, n and n′ are defined by k=2, m=2, e=1 and n=6, thus n′=5<n.

An irreducible polynomial is a polynomial that cannot be factored into the product of two non-constant polynomials and is used to generate a finite field.

The encoding matrix A is then randomly generated as follows:

$A=\left(\begin{array}{cccccc}1& 1& 1& 1& 1& 1\\ {\alpha }^{29}& {\alpha }^{230}& {\alpha }^{164}& {\alpha }^{149}& {\alpha }^{67}& {\alpha }^{183}\\ {\alpha }^{58}& {\alpha }^{205}& {\alpha }^{73}& {\alpha }^{43}& {\alpha }^{134}& {\alpha }^{111}\\ {\alpha }^{87}& {\alpha }^{180}& {\alpha }^{237}& {\alpha }^{192}& {\alpha }^{201}& {\alpha }^{39}\\ {\alpha }^{116}& {\alpha }^{155}& {\alpha }^{146}& {\alpha }^{86}& {\alpha }^{13}& {\alpha }^{222}\end{array}\right)\in {𝔽}^{5\times 6}$

The inverse matrix A⁻¹ of the encoding matrix A is then determined as:

$A^{-1}=\left(\begin{array}{ccccc}{\alpha }^{211}& {\alpha }^{59}& {\alpha }^{226}& {\alpha }^{175}& {\alpha }^{155}\\ {\alpha }^{138}& {\alpha }^{251}& {\alpha }^{37}& {\alpha }^{104}& {\alpha }^{199}\\ {\alpha }^{106}& {\alpha }^{13}& {\alpha }^{170}& {\alpha }^{221}& {\alpha }^{84}\\ {\alpha }^{243}& {\alpha }^{41}& {\alpha }^{72}& {\alpha }^{43}& {\alpha }^{82}\\ {\alpha }^{139}& {\alpha }^{199}& {\alpha }^{164}& {\alpha }^{52}& {\alpha }^{76}\\ {\alpha }^{68}& {\alpha }^{25}& {\alpha }^{121}& {\alpha }^{41}& {\alpha }^{134}\end{array}\right)\in {𝔽}^{6\times 5}$

The two following random vectors are then considered:

$\left(x,m_x,{ϵ}_x\right)=\left({\alpha }^{27},{\alpha }^{147},{\alpha }^{212},{\alpha }^8,{\alpha }^{151}\right)$ $\left(y,m_y,{ϵ}_y\right)=\left({\alpha }^{226},{\alpha }^{137},{\alpha }^{65},{\alpha }^{62},{\alpha }^6\right)$

The encoder 102 will then determine the corresponding masked vectors {circumflex over (x)} and ŷ as follows:

$\hat{x}=EN{C}_{msk}\left(x,m_x,{ϵ}_x\right)=\left(x,m_x,{ϵ}_x\right)A=\left({\alpha }^{160},{\alpha }^{79},{\alpha }^{133},{\alpha }^{34},{\alpha }^{194},{\alpha }^{167}\right)$ $\hat{y}=EN{C}_{msk}\left(y,m_y,{ϵ}_y\right)=\left(y,m_y,{ϵ}_y\right)A=\left({\alpha }^{244},{\alpha }^{254},{\alpha }^{208},{\alpha }^{197},{\alpha }^{187},{\alpha }^{51}\right)$

The adder 104 can then determine the sum of x and y using the masked addition operation ADD_msk according to the following equation:

${\hat{z}}^{\prime }={\mathrm{ADD}}_{msk}\left(\hat{x},\hat{y}\right)=\left({\alpha }^{200},{\alpha }^{167},{\alpha }^{77},{\alpha }^{216},{\alpha }^{44},{\alpha }^{10}\right)$

By decoding {circumflex over (z)}′ using DEC_msk, it can be verified that:

$DE{C}_{msk}\left({\hat{z}}^{\prime }\right)=\left(z,m_z,{ϵ}_z\right)=\left({\alpha }^{102},{\alpha }^{158},{\alpha }^{118},{\alpha }^{216},{\alpha }^{22}\right)$

• • with z′=(x₁+x₁, X₂+y₂)=(α¹⁰², α¹⁵⁸).

The multiplier 105 can further determine the product of x and y using the masked multiplication operation MULT_msk and output {circumflex over (Z)}=MULT_msk({circumflex over (x)}, ŷ), according to the method of FIG. 5 that uses the random matrix.

The matrices Ŝ, M and ker(M) are not shown below to simplify the description of this example.

In step 503 of FIG. 5, the random seed sd is determined in as n²−n′=31, as follows:

$\mathrm{sd}=\left({\alpha }^{172},{\alpha }^{100},{\alpha }^{165},{\alpha }^{253},{\alpha }^{207},{\alpha }^{200},{\alpha }^{155},{\alpha }^{250},{\alpha }^{133},{\alpha }^{51},{\alpha }^{204},{\alpha }^{138},{\alpha }^{213},{\alpha }^{58},{\alpha }^{18},{\alpha }^{129},{\alpha }^{47},{\alpha }^{45},{\alpha }^{180},{\alpha }^{11},{\alpha }^{109},{\alpha }^{244},{\alpha }^{142},{\alpha }^{96},{\alpha }^{186},{\alpha }^{145},{\alpha }^{72},{\alpha }^{56},{\alpha }^{242},{\alpha }^{101},{\alpha }^{199}\right)\in {𝔽}^{31}.$

In step 504 of FIG. 5, the random matrix {circumflex over (R)} is then determined by performing {circumflex over (R)}=flatten⁻¹(sd·ker(M)), as follows:

$\hat{R}={\mathrm{flatten}}^{-1}\left(\mathrm{sd}·\ker \left(M\right)\right)=\left(\begin{array}{cccccc}{\alpha }^{188}& {\alpha }^{57}& {\alpha }^{37}& {\alpha }^{154}& {\alpha }^{128}& {\alpha }^{172}\\ {\alpha }^{100}& {\alpha }^{165}& {\alpha }^{253}& {\alpha }^{207}& {\alpha }^{200}& {\alpha }^{155}\\ {\alpha }^{250}& {\alpha }^{133}& {\alpha }^{51}& {\alpha }^{204}& {\alpha }^{138}& {\alpha }^{213}\\ {\alpha }^{58}& {\alpha }^{18}& {\alpha }^{129}& {\alpha }^{47}& {\alpha }^{45}& {\alpha }^{180}\\ {\alpha }^{11}& {\alpha }^{109}& {\alpha }^{244}& {\alpha }^{142}& {\alpha }^{96}& {\alpha }^{186}\\ {\alpha }^{145}& {\alpha }^{72}& {\alpha }^{56}& {\alpha }^{242}& {\alpha }^{101}& {\alpha }^{199}\end{array}\right)\in {𝔽}^{6\times 6}$

It can be verified that:

$\mathrm{diag}\left(A^{-T}\hat{R}{A}^{-1}\right)=\mathrm{diag}\left(\begin{array}{ccccc}0& {\alpha }^{29}& {\alpha }^{196}& {\alpha }^{181}& {\alpha }^{154}\\ {\alpha }^{48}& 0& {\alpha }^{99}& {\alpha }^{40}& {\alpha }^{144}\\ {\alpha }^{48}& {\alpha }^{242}& 0& {\alpha }^{42}& {\alpha }^{89}\\ {\alpha }^{182}& {\alpha }^{214}& {\alpha }^{67}& 0& {\alpha }^{110}\\ {\alpha }^{129}& {\alpha }^{225}& {\alpha }^{99}& {\alpha }^{148}& 0\end{array}\right)=0_{n^{\prime }}$

In step 505, the matrix W is then determined as W={circumflex over (X)}^TŶ+{circumflex over (R)} from the first masked variable {circumflex over (X)}, the second masked variable Ŷ and the random matrix {circumflex over (R)},

$W={\hat{X}}^T\hat{Y}+\hat{R}=\left(\begin{array}{cccccc}1& {\alpha }^{23}& {\alpha }^{150}& {\alpha }^{243}& {\alpha }^{62}& {\alpha }^{23}\\ {\alpha }^{103}& {\alpha }^{245}& {\alpha }^{184}& {\alpha }^{82}& {\alpha }^{230}& {\alpha }^{131}\\ {\alpha }^7& {\alpha }^{107}& {\alpha }^{83}& {\alpha }^{59}& {\alpha }^{46}& {\alpha }^{110}\\ {\alpha }^{55}& {\alpha }^{51}& {\alpha }^{206}& {\alpha }^{85}& {\alpha }^{140}& {\alpha }^6\\ {\alpha }^{240}& {\alpha }^{149}& {\alpha }^{82}& {\alpha }^{72}& {\alpha }^{162}& {\alpha }^{13}\\ {\alpha }^{135}& {\alpha }^{19}& {\alpha }^{126}& {\alpha }^{104}& {\alpha }^{149}& {\alpha }^{36}\end{array}\right)\in {𝔽}^{6\times 6}$

which provides:

In step 506, the result of the multiplication is flattened by applying the flatten function to A^−TW which provides the following flattened matrix T defined as T=flatten (A^−TW):

$\begin{array}{c}T=\mathrm{flatten}\left(A^{-T}W\right)\\ ={\alpha }^{231},{\alpha }^{199},{\alpha }^{184},{\alpha }^{29},{\alpha }^{244},{\alpha }^{210},{\alpha }^{76},{\alpha }^{30},{\alpha }^{209},{\alpha }^{64},{\alpha }^{162},{\alpha }^{108},\\ {\alpha }^{243},{\alpha }^{43},{\alpha }^{225},{\alpha }^{142},{\alpha }^{73},{\alpha }^{162},{\alpha }^{254},{\alpha }^{98},{\alpha }^{126},{\alpha }^{208},{\alpha }^{36},{\alpha }^{168},\\ {\alpha }^4,{\alpha }^{87},{\alpha }^{223},{\alpha }^{138},{\alpha }^{204},{\alpha }^{70})\in {𝔽}^{30}.\end{array}$

In step 508, the protected multiplication {circumflex over (Z)} is determined by performing the product of the flattened matrix T and of the matrix Ŝ such that {circumflex over (Z)}=TŜ.

$\hat{Z}=T\hat{S}=\left({\alpha }^{218},{\alpha }^{100},{\alpha }^{44},{\alpha }^{97},{\alpha }^{89},{\alpha }^{212}\right)\in {𝔽}^6$

In step 510, the result {circumflex over (Z)} is returned.

By decoding {circumflex over (Z)} using DEC_msk, it can be verified that:

$DE{C}_{msk}\left({\hat{Z}}^{\prime }\right)=\left(Z,m_{Z^{\prime }},{ϵ}_{Z^{\prime }}\right)=\left({\alpha }^{253},{\alpha }^{29},{\alpha }^{22},{\alpha }^{70},{\alpha }^{157}\right)$

With Z=(x₁·x₂, y₁·y₂)=(α²⁵³, α²⁹).

As formally analysed in previous art works (such as for example in Wei Cheng, Sylvain Guilley, Claude Carlet, Jean-Luc Danger, and Sihem Mesnager. Information Leakages in Code-based Masking: A Unified Quantification Approach. IACR Trans. Cryptogr. Hardw. Embed. Syst., 2021 (3): 465-495, 2021; or in Wei Cheng, Sylvain Guilley, Claude Carlet, Sihem Mesnager, and Jean-Luc Danger. Optimizing Inner Product Masking Scheme by a Coding Theory Approach. IEEE Trans. Inf. Forensics Secur., 16:220-235, 2021), the side-channel resistance of a processing system is upper limited by the security order in the encodings (or decodings) of CBM.

The protection device 10 according to the embodiments of the invention being based on the improved TCBM scheme, the security order is determined by the dual distance of the underlying linear code, generated by the encoding matrix A.

Considering that d_s denotes the side-channel security order, the encoding matrix A may be split (or divided) into three sub-matrices as follows:

$\begin{array}{cc}A=\left(\begin{array}{c}\underset{\_}{A_k}\\ \underset{\_}{A_m}\\ A_e\end{array}\right)\in {𝔽}^{n^{\prime }\times n}& \left(27\right)\end{array}$

In Equation (27), the sub-matrix A_k∈, the sub-matrix A_m∈ and the sub-matrix A_e∈.

Each sub-matrix resulting from the division of the encoding matrix A respectively corresponds to a linear code (i.e. a sub-matrix generates a respective linear code). The sub-matrix A_k is thereby associated with a linear code C, the sub-matrix A_m is associated with a linear code D and the sub-matrix A_e is associated with a linear code E.

Considering the matrix subdivision defined by equation (27), the side-channel security order of TCBM is defined by:

$\begin{array}{cc}{d}_S=d_D^{\perp }-1& \left(28\right)\end{array}$

In equation (28), the linear code D is generated by the sub-matrix A_m.

Advantageously, the protection device 10 may provide a fault detection capability against fault injection attack, which is another important threat to cryptographic implementations.

In some embodiment, the checking unit 108 may be configured to cover the computations performed by the different components of the protection device 10 and of the processing device 11, and in particular the computations performed inside the components by the different components 102, 104, 105, 106, 110. For instance, given two masked input vectors (x, m_x, ϵ_X) and (y, m_y, ϵ_y), the masked multiplication performed by the multiplier 105 returns not only the k pairwise products of information, but also the m pairwise products of masks and the e pairwise products of ϵ_x and ϵ_y. Further, the refresh operation performed by the refreshing unit 106 may happen on the full codeword or selectively on the encoding of the (information, mask). This allows not altering the redundancy injected in the e elements.

Several fault detection strategies may be implemented by the checking unit 108.

For example, the randomness (independent of the sensitive information) may be fed in the e elements, and it can be checked at any point of the method implemented by the protection device 10 or the processing device 11 that the same operations have been carried out on the random elements than on the actual data. Such random elements are also referred to as ‘canaries’ in the security field. For example, if the processing function is related to AES, if k=e, one protected AES and another AES on other unrelated data can be carried out. As the end-to-end masking mangles the k and e elements, and error on codewords is very likely to impact the independent AES, this can be verified at the end on the ciphertext.

The e elements can also be a checksum on the masked data, which allows for fresh-ness of the canaries, though at the expense of causing more leakage if inadequately or defectively implemented.

A constant cst can be injected, which waives the requirement to verify the extra AES, since the output will be the same across AES invocations.

According to another fault detection strategy, a fault detection analysis may be performed in the elementary operations like the additions and multiplications performed by the adder 104 and the multiplier 105.

For example, considering two input vectors (x, m_x, ϵ_X) and (y, m_y, ϵ_y) and the constant cst:

For the addition operation performed by the adder 104, as the addition uses two input operands (even), the parameters ϵ_X and ϵ_y will be cancelled out if there is no fault, so that the constant cst may be compensated one more time. For example, taking e=1 for detection of a single uniformly distributed fault and if there is any fault that makes either ϵ_X≠cst or ϵ_y≠cst, the faults can be detected at the end, with the fault coverage probability being 100% for one error indicator over .

For the multiplication operation performed by the multiplier 105, after the component-wise multiplication, it comes ϵ′=prod(ϵ_X, ϵ_y). Assuming there is no fault, then ϵ′ is component-wise square; then the inverse of cst has to be multiplied for compensation. This can be achieved by performing a multiplication with empty information and mask, but with the error indicator part being inverse of cst. In this case, cst is a nonzero element. Taking the same setting with e=1 for detection of a single uniformly distributed fault, the fault coverage probability is given by:

$100\%\times \frac{255}{256}+0\times \frac{1}{256}=\frac{255}{256}$

(The former part for ϵ_x≠0, and the later for ϵ_x=0).

The same reasoning holds for ϵ_y for one error indicator over .

Accordingly, the fault detection capability implemented by the checking unit 108 may be mainly determined by e error indicators ϵ, which typically results in high fault detection coverage in computations under mild conditions.

FIG. 7 is a flowchart depicting the method of executing a f processing function in response to the receipt of an initial information word x (also denoted x_in) comprising k information symbols, according to some embodiments. The method is implemented to determine securely ƒ(x) (also denoted ƒ(x_in)).

In step 700, the initial information word x (also denoted x_in) comprising k information symbols are received.

In step 702, the encoding matrix A is determined from an information code C and a masking code D.

In step 704, the processing function is decomposed into basis operations including one or more elementary operations and possibly one or more additional operations. The elementary operations comprise one or more elementary operations including at least a multiplication operation. The elementary operations may also comprise one or more addition operation.

It should be noted that steps 702 and 704 may be performed according to a different order (inverse order or in parallel). Further, the step 704 may be performed previously and step 704 be replaced by a step consisting in using the precomputed decomposition of the processing function into elementary operations and additional operations.

In step 706, the encoding operation ENC_msk is applied to the initial information word x (also denoted x_in) and to each input of an elementary operation resulting from the decomposition, which provides encoded variables.

In step 708, the elementary operations are executed using the variables encoded in step 706 (protected variables) instead of the corresponding original variables (unprotected variables). The elementary operations may comprise one or more additions ADD_msk (step 709) and/or one or more multiplications MULT_msk (step 710). In particular, the multiplication operation MULT_msk is masked using the pseudo-inverse matrix A⁻¹ of said encoding matrix A, and the pseudo-inverse transpose matrix A^−T of said encoding matrix A.

The additional operations may also be executed until all the basis operations are executed. The encoded variables may be refreshed once or at different instant times.

In step 712, in response to the computation of all basis operations, the variable encoded in step 706 or only some of them may be decoded using the decoding operation DEC_msk ( ).

A checking step may be implemented to detect if failure occurred in the previous computations, at different phases of the processing, and if an error is detected an error notification may be generated.

In step 714, if an error was detected, the error notification is returned. Otherwise the result of the execution function ƒ(x) (also denoted ƒ(x_in)) is returned.

The processing system may be used in various applications such as in various consumer, commercial, industrial, and infrastructure applications. The skilled person will readily understand that the invention is not limited to cryptosystems and can be applied to other processing systems 1 such as safety-critical systems (industrial systems, automotive systems, satellite systems, etc.) complying to standards such as IEC 62443, ISO 26262 & ISO/SAE 21434, etc. Those standards mandate fault detection capability, whilst at the same time ability to resist attacks, including side-channel attacks.

Embodiments of the present disclosure can take the form of an embodiment containing software only, hardware only or both hardware and software elements.

Furthermore, the methods described herein can be implemented by computer program instructions supplied to the processor of any type of computer to produce a machine with a processor that executes the instructions to implement the functions/acts specified herein. These computer program instructions may also be stored in a computer-readable medium that can direct a computer to function in a particular manner. To that end, the computer program instructions may be loaded onto a computer to cause the performance of a series of operational steps and thereby produce a computer implemented process such that the executed instructions provide processes for implementing the functions specified herein. In particular, the methods described herein may be implemented in a computer system.

It should be noted that the functions, acts, and/or operations specified in the flow charts, sequence diagrams, and/or block diagrams may be re-ordered, processed serially, and/or processed concurrently consistent with embodiments of the disclosure. For example steps 410 and 412 may be performed according to a different order or even in parallel. Moreover, any of the flow charts, sequence diagrams, and/or block diagrams may include more or fewer blocks than those illustrated consistent with embodiments of the disclosure.

While embodiments of the disclosure have been illustrated by a description of various examples, and while these embodiments have been described in considerable detail, it is not the intent of the applicant to restrict or in any way limit the scope of the appended claims to such detail. In particular, the invention is not limited to an encoding matrix A generated using a Vandermonde matrix. Indeed the encoding matrix may be generally generated from any matrix which meets a number of properties including at least security properties, the encoding matrix A being generated to meet security objectives in terms of dual distance. These properties may also include a property related to a PPA metric, the encoding matrix A being generated to reach a structure or a sparsity, which improves the PPA metric.

Additional advantages and modifications will readily appear to those skilled in the art. The disclosure in its broader aspects is therefore not limited to the specific details, representative methods, and illustrative examples shown and described.

Claims

1. A processing system configured to execute a processing function ƒ(x) in response to the receipt of an input information word x comprising k information symbols, the processing system comprising a protection device configured to protect the execution of the processing function, wherein the processing system comprises a processing unit configured to execute the processing function, the processing unit being configured to decompose the processing function ƒ into one or more basis operations comprising one or more elementary operations between two operands, the elementary operations comprising at least a component-wise multiplication operation, the processing unit comprising a multiplier configured to perform said multiplication operation, wherein the protection device comprises at least: an encoding matrix determination unit configured to randomly determine an information code and a masking code being linear codes, said information code and said masking code satisfying one or more predefined code properties, and to determine the encoding matrix A from the information code and the masking code, said encoding matrix A being determined by vertically stacking the vectors of the information code and of the masking code; andan encoder configured to apply an encoding operation to an encoder input comprising information symbols, said encoding operation consisting in encoding the encoder input using the encoding matrix A, which provides an encoded word corresponding to the encoder input;wherein the processing device is configured to apply said encoder to said input information word x, and to each operand of an elementary operation, each elementary operation being applied to the encoded words determined by the encoder for each operand,wherein the multiplication operation performed by said multiplier is further masked using the pseudo-inverse matrix A−1 of said encoding matrix A, and the pseudo-inverse transpose matrix A−T of said encoding matrix A, such that (AT)−1=(A−1)T.

2. The processing system of claim 1, wherein the encoding matrix A is applied by the encoder to pad k information symbols of an encoder input with m random numbers, the output of the encoder being a masked vector {circumflex over (x)} of length n, with n≥k+m, the masked vector x belonging to , the encoding matrix A being an (k+m)×n matrix in the field .

3. The processing system of claim 1, wherein in response to the receipt of an encoder input X, the encoder is configured to determine random masks MX∈ and an error indicator ϵX∈ in association with the encoder input X, and to encode the encoder input using the encoding matrix A, the random masks MX and the error indicator ϵX.

4. The processing system of claim 3, wherein the encoder output X is determined as: {circumflex over (X)}=(X,MX,ϵX)A.

5. The processing system of claim 1, wherein in response to the receipt of two inputs {circumflex over (X)} and Ŷ masked by the encoder, the multiplier is configured to: determine the cross-product W of the masked vectors and of the random matrix as W={circumflex over (X)}TŶ;apply a flatten function to A−TW which provides a flattened matrix T defined as T=flatten (A−TW), where A−T is the pseudo-inverse transpose matrix of the encoding matrix A; anddetermine the result of the multiplication {circumflex over (Z)} by performing the product of the flattened matrix T and of an encoded matrix Ŝ such that {circumflex over (Z)}=TŜ, Ŝ corresponding to the encoding of an original matrix by the encoder S∈, the matrix S being divided into/sub-matrices Si into such that each sub-matrix Si has a size J×I and has only single non-zero element (Si)i,i, for 1≤i≤I.

6. The processing system of claim 1, wherein in response to the receipt of two inputs x and Y masked by the encoder, the multiplier is configured to: determine a random seed sd uniformly in ;determine, a random matrix {circumflex over (R)} from the random seed;determine the sum W of the cross-product of the masked vectors and of the random matrix as ={circumflex over (X)}TŶ+{circumflex over (R)};apply a flatten function to A−TW which provides a flattened matrix T defined as T=flatten (A−TW), where A−T is the pseudo-inverse transpose matrix of the encoding matrix A;determine the result of the multiplication {circumflex over (Z)} by performing the product of the flattened matrix T and of an encoded matrix Ŝ such that {circumflex over (Z)}=TŜ, Ŝ corresponding to the encoding of an original matrix by the encoder S∈, the matrix S being divided into/sub-matrices Si into such that each sub-matrix Si has a size J×I and has only single non-zero element (Si)i,i, for 1≤i≤I.

7. The processing system of claim 1, wherein said elementary operations further comprise a component-wise addition operation and the processing device comprises an adder configured to perform said addition operation using inputs previously encoded by the encoder.

8. The processing system of claim 1, wherein the protection device further comprise a decoder configured to apply a decoding operation to word {circumflex over (X)} previously encoded by the encoder, the decoder being configured to provide a decoder output comprising original data X, using the encoded word {circumflex over (X)} and the pseudo-inverse matrix A−1 of the encoder matrix A.

9. The processing system of claim 3, wherein the protection device further comprise a decoder configured to apply a decoding operation to word & previously encoded by the encoder, the decoder being configured to provide a decoder output comprising original data X, using the encoded word R and the pseudo-inverse matrix A−1 of the encoder matrix A, and wherein the decoder output further comprises random masks MX∈ and an error indicator ϵX∈ in association with the output original data X, and the decoding operation DECmsk applied by the decoder is defined by:

10. The processing system of claim 1, wherein the protection device further comprise a refreshing unit configured to perform a refreshing operation, at one or more instant times during the execution of the processing function, said refreshing operation consisting in determining a refreshed encoded word {circumflex over (X)}′ for an encoder input word X previously applied to the decoder to determine encoded word {circumflex over (X)} such that both encoded word {circumflex over (X)} and the refreshed encoded word {circumflex over (X)}′ correspond to the same input information word X, the refreshing unit being configured to replace the encoded word {circumflex over (X)} by the refreshed encoded word {circumflex over (X)}′.

11. The processing system of claim 1, wherein the protection device further comprises a checking unit configured to perform a checking operation consisting in checking if a computing error occurred in the operations performed by the encoder, the adder, or the multiplier.

12. The processing system of claim 3, wherein the protection device further comprises a checking unit configured to perform a checking operation consisting in checking if a computing error occurred in the operations performed by the encoder, the adder, or the multiplier, and wherein the checking unit is configured to check whether the error indicator variable ϵX associated with the word X meets the condition ϵX=cst where cst is a predefined constant, and detect whether an error occurred from said condition.

13. The processing system of claim 12, wherein no error is detected if ϵX=cst, and if the error indicator variable ϵX is different from the predefined constant cst, the checking unit is configured to further apply a syndrome decoding technique using syndromes of linear codes to determine if an error occurred.

14. The processing system of claim 1, wherein the encoding matrix A is generated from a Vandermonde matrix.

15. A method, implemented in a processing system, for executing a processing function ƒ(x) in response to the receipt of an input information word x comprising k information symbols, the method comprising protecting the execution of the processing function, wherein the execution of the processing function comprises decomposing the processing function ƒ into one or more basis operations comprising one or more elementary operations between two operands, the elementary operations comprising at least a multiplication operation, the multiplication being a component-wise multiplication, the processing function execution step comprising: randomly determining an information code and a masking code, being linear codes, said information code and said masking code satisfying one or more predefined code properties,determining an encoding matrix A from the information code and the masking code, said matrix A being determined by vertically stacking the vectors of the information code and of the masking code;applying an encoding operation to the input information word x, and to each operand of an elementary operation, prior the execution of the elementary operation, said encoding operation consisting in encoding the input received in the encoding step using the encoding matrix A; andexecuting the one or more elementary operations by applying an elementary operation to the operands encoded in the encoding step;wherein the multiplication operation is further masked using the pseudo-inverse matrix A−1 of said encoding matrix A, and the pseudo-inverse transpose matrix A−T of said encoding matrix A.