METHOD FOR ENCRYPTING OR DECRYPTING A N-TUPLE OF DATA WITH A N-TUPLE OF PREDETERMINED SECRET KEYS

Abstract

The present invention relates to a method for encrypting or decrypting a n-tuple of data with a n-tuple of secret keys , the method being characterized in that it comprises data-processing means (11a) of equipment (10a) implementing steps of: (a) For each element (ai), determination of m>n first internal states by application of m first operations, each being: represented by a stored table (Tij), anddefined as the combination of a single bijective internal encoding (Gij), of a non-linear splitting function (Di, Ei, Fi . . . ), and of a given non-linear permutation function (ƒ) parameterized with the secret key (ki) corresponding;(b) For each n-tuple of first internal states , determination of a second internal state (zj) by application of a second operation being: represented by a table (TLj) stored, anddefined as the combination of a second single bijective internal encoding (GLj), a linear multiplexing function (L), and the inverses of said first bijective internal encodings (Gij).

Description

GENERAL TECHNICAL FIELD

The present invention relates to the field of cryptography, and in particular an encryption/decryption method of “white box” type.

PRIOR ART

A function is considered as a “black box” when there can be no access to its internal operation, i.e. its inputs and outputs can be known but not its secret parameters or its intermediate states.

Cryptographic algorithms (for example for encryption or signature) are thus conventionally supposed as black boxes when their reliability is evaluated (resistance to attacks).

For example, in the case of typical cryptographic algorithms such as DES (“Data Encryption Standard”) or AES (“Advanced Encryption Standard”), these work on blocks of size 64 or 128 bits (and tomorrow 256 bits), but in a single operation cannot process such a block (there are already over 10¹⁹ possible values of blocks of 64 bits). It is necessary to work inside a block on smaller elements, typically of size 8 bits (only 256 possibilities) by chaining non-linear (bijective) operations with linear (non-injective) operations.

In reference to FIG. 1a, these algorithms can be illustrated in a highly simplified way by the formula a₀, a₁→L(ƒ(a₀+k₀), ƒ(a₁+k₁)), where ƒ designates a non-linear operation, for example on 8 bits, L designates a linear function (for example a XOR, “eXclusive OR”) in the example transforming two words of 8 bits of a block into one word of 8 bits, a₀ and a₁ are bytes of text to be encrypted and k₀ and k₁ are secret data (the “keys” of the algorithm). Said formula is applied iteratively to process the whole block.

The hypothesis of black box in this case supposes that the data k₀ and k₁ or the intermediate states ƒ(a₀+k₀) and ƒ(a₁+k₁) are inaccessible.

This hypothesis imposes a major restriction on the storage and handling of these parameters. But tools have recently been published to enable automation of attacks on hardware implementation, so-called side channel or fault attacks.

Today, for many cases of use including payment on mobile, it is necessary to deploy cryptographic algorithms by making as few assumptions as possible on the security of the target hardware. Secure storage and handling of secret parameters must be ensured at the application level.

The cryptography known as white box aims to respond to this challenge by proposing implementations of cryptographic algorithms which are supposed to make extraction of secrets impossible, even in case of attack allowing the attacker full access to the software implementation of the algorithm. More exactly, a function is considered as a “white box” when its mechanisms are visible and enable understanding of its operation. In other terms, the direct assumption is made that the attacker has access to everything he wants (the binary is completely visible and modifiable by the attacker who has complete control of the operation platform). Consequently, implementation itself is the sole line of defense.

To protect implantation of a pattern such as described earlier, it has first been proposed to merge keys k₀ and k₁ with the function ƒ by representing computations by tables. For the example studied, in reference to FIG. 1b, this comes down to storing in memory (e.g. ROM or Flash) three tables T₀, T₁ and T_L representing respectively the functions a₀→T₀[a₀]=ƒ(a₀+k₀), a₁→T₁[a₁]=ƒ(a₁+k₁) and (y₀, y₁)→T_L[y₀, y₁]=L(y₀, y₁)=z.

This ploy avoids having the keys in the clear, but is not enough to resist an attack consisting of exhaustively testing all possible keys k₀ (respectively k₁) to the point of finding the one which verifies y₀=ƒ(a₀+k₀) (respectively y₁=ƒ(a₁+k₁)).

It has been proposed to “mask” the internal states by random permutations G₀, G₁, G₂ (unknown but constant) called internal encodings. More precisely, as shown by FIG. 1c, this produces the internal states G₀[y₀] and G₁[y₁], from which the keys cannot be retrieved by directly testing all possibilities. Using the linear function G₂ ∘T_L∘(G₀⁻¹, G₁⁻¹) gives G₂ ∘T_L∘(G₀⁻¹∘G₀[y₀], G₁⁻¹∘G₁[y₁])=G₂ ∘T_L[y₀, y₁]=G₂ [z].

But attacks have shown that patterns such as above could still be attacked when the encoding was linear by exploiting the correlation between the encoded datum and the sensitive datum (i.e. y_i or z in the example above), cf. the article “Differential Computation Analysis: Hiding Your White-Box Designs is Not Enough” at CHES2016.

This pattern is also sensitive to other attacks known as collision attacks which exploit the non-injective character of linear transformations (here T_L) to build algebraic relations giving information on the key (the pair (k₀, k₁) in the example above), cf. the article “Cryptanalysis of a White Box AES Implementation” published at SAC2004.

More precisely, couples of pairs can be found (a₀, a₁) and (a₀′, a₁′) such as G₂ ∘T_L[ƒ(a₀+k₀), ƒ(a₁+k₁)]=G₂ ∘T_L[ƒ(a₀′+k₀), ƒ(a₁′+k₁)], i.e. T_L[ƒ(a₀+k₁), ƒ(a₁+k₁)]=T_L[ƒ(a₀′+k₀), ƒ(a₁′+k₁)] to make of the non-injective character of T_L. Random permutations are thus eliminated and if there are enough couples, the values of keys k₀, k₁, can again be exhaustively tested which is long though feasible.

Applications EP2924677, EP2922234 and EP2996278 have consequently proposed a breakdown of internal states into a sum of fragments called “splits”, so as to execute the non-linear function fragment by fragment. For this, a linear splitting function D_i(y) for fragmenting y, is used and the random permutations at G₀₀, G₁₀, G_L0, G₀₁, G₁₁, G_L1 corresponding to one or the other of the fragments are duplicated.

However, this pattern remains sensitive to some attacks, in particular by collision: assuming the computations are simpler than T_L is the eXclusive OR function, “XOR”, which does not diminish the generality of the idea since any linear function can decompose into a succession of XORs and scalar products with constants, if for given z, the set of pairs (x₀, x₁) is built such that z=G_L0∘(D₀(y₀)+D₁(y₁)), then for each pair (x₀, x₁)∈, D₀(y₀)+c_z=D₁(y₁), i.e. y₁=D₁⁻¹(D₀(y₀)+c_z) can be posed.

This builds the function φ_{{circumflex over (k)}0, {circumflex over (k)}1}: ŷ₀→ŷ₁ (where ŷ₀, ŷ₁ are the pairs associated with all the (x₀, x₁) ∈, for any pair of keys {circumflex over (k)}₀, {circumflex over (k)}₁), whereof it can be shown that the case ({circumflex over (k)}₀, {circumflex over (k)}₁)=(k₀, k₁) is distinguishable, which goes back to the keys. In fact, in the right example, the function φ_{{circumflex over (k)}0, {circumflex over (k)}1} is a linear function (or affine) whereas it is not when ({circumflex over (k)}₀, {circumflex over (k)}₁)≠(k₀, k₁).

As a consequence, it would be preferable to have a novel solution of “white box” encryption using standard mechanisms such as DES and AES which is completely resistant to all known attacks (by channel analysis, by collision, etc.).

PRESENTATION OF THE INVENTION

According to a first aspect, the present invention relates to a method for encrypting or decrypting a n-tuple of data with a n-tuple of predetermined secret keys, n≥2, for a given non-linear permutation function and a given linear multiplexing function, the method being characterized in that it comprises data-processing means of equipment implementing steps of:

• • (a) For each element of said n-tuple of data, determination of m>n first internal states by application to said element of first operations, each being:
    • represented by a table stored on data-storage means of the equipment, and
    • defined as the combination of a single bijective internal encoding, of a non-linear splitting function, and of the non-linear permutation function parameterized with the corresponding secret key, said non-linear splitting functions forming m collections such that the n functions of a collection split any input datum in n fragments whereof the sum is equal to the input datum;
  •  all of said first internal states determined for all said elements forming n-tuples of internal states;
  • (b) For each n-tuple of first internal states, determination of a second internal state by application to said internal states of the n-tuple of first internal states of a second operation being:
    • represented by a table stored on the data-storage means of the equipment, and
    • defined as the combination of a second single bijective internal encoding, of the linear multiplexing function, and of the inverses of said first bijective internal encodings.

According to other advantageous and non-limiting features:

• • ∀i∈0, n−1, y_i0=T_i0[a_i]=G_i0∘D_i∘ƒ(a_i+k_i), y_i1=T_i1[a_i]=G_i1∘E_i∘ƒ(a_i+k_i), y_i2=T_i2[a_i]=G_i2∘F_i∘ƒ(a_i+k_i), etc.;
  • z_j=T_Lj[y_0j, y_ij . . . ]=G_Lj∘L(G_0j⁻¹[y_0j]G_1j⁻¹[y_1j] . . . );
  • ∀i∈0, n−1, ∀x, x=D_i(x)+E_i(x)+F_i(x)+ . . . ;
  • The method comprises a previous step (a0) for random generation by data-processing means of a server connected to the equipment of m−1 non-linear splitting functions for each collection, from which the m-th non-linear splitting function is built;
  • step (a0) further comprises random generation of internal encodings, construction of tables, and their transmission to the equipment for storage on the storage means;
  • repetition of steps (a) and (b) so as to encrypt or decrypt a set of data comprising those of said n-tuple;
  • the method further comprises a determination step (c) of the encrypted/decrypted of said n-tuple of data by application to said second internal states of a third operation being:
    • represented by a table stored on the data-storage means of the equipment, and
    • defined as the sum of the inverses of said second bijective internal encodings.
  • z=T_z[]=Σ_j=0^m-1G_Lj⁻¹[z_j];
  • n=2;
  • said linear multiplexing function is the eXclusive OR function;
  • m=3;
  • each element of said n-tuple of data has a size of one byte or of one half-byte;
  • said non-linear permutation function is that of a cryptographic algorithm selected from DES and AES.

According to a second and a third aspect, the invention proposes a computer program product comprising code instructions for executing a method according to the first aspect for encrypting or decrypting a n-tuple of data with a n-tuple of predetermined secret keys; and storage means legible by computer equipment on which a computer program product comprises code instructions for executing a method according to the first aspect for encrypting or decrypting a n-tuple of data with a n-tuple of predetermined secret keys.

PRESENTATION OF THE FIGURES

Other features and advantages of the present invention will become more apparent upon reading the following description of a preferred embodiment. This description will be given in reference to the appended drawings, in which:

FIGS. 1a-1c illustrate three known cryptographic algorithms;

FIG. 2 is a diagram of architecture for implementing the method according to the invention;

FIG. 3 illustrates an embodiment of a cryptographic algorithm in accordance with the method of the invention.

DETAILED DESCRIPTION

Architecture

In reference to FIG. 2, a method for “white box” encryption or decryption is proposed, implemented within equipment 10a such as a mobile terminal (smartphone, touch tablet, etc.), i.e. equipment having no particular secure hardware and which can be the object of attacks on hardware implementation, and for which the white box approach takes all interest.

The equipment 10a comprises data-processing means 11a (a processor) and data-storage means 12a (a memory, for example flash).

The equipment 10a is for example connected to a server 10b for example via the internet network 20. It can be led to receive tables (to be described later) from this server 10b (for example that of a provider of security solutions), containing secrets which will be stored in the memory 12a and used to implement the present method.

The equipment 10a can in turn be connected to other third-party servers 10c with whom it could exchange data encrypted by means of the present method.

Cryptographic Method

The present method is a cryptographic “encryption or decryption” method, meaning that according to the case it encrypts data or decrypts them. It is of symmetrical or “secret key” type.

It is understood that the present method is a novel implementation of known algorithms such as DES or AES which are the current standards. More precisely, it is not a novel encryption strategy but only a new way of handling data within the algorithm which is resistant to all “white box” hardware attacks.

According to a classic pattern, it processes data block by block, and within a block, it manipulates elements of smaller size, for example 16 elements of one byte for 128 bits block (such as AES for example). These elements are manipulated n by n, with n≥2, and advantageously n=2.

So, the present method encrypts or decrypts a n-tuple of data with a n-tuple of predetermined secret keys . In the rest of the description, it will be assumed that n=2 (i.e. there is a pair of elements a₀, a₁ and a pair of keys k₀, k₁), but the skilled person can transpose the method to other higher values of n.

Each element a_i of said n-tuple of data has a value in a space {0; 1}^k to be noted ₂^k and advantageously has a size of one byte (a “byte” of 8 bits, i.e. k=8), but a size of one half-byte (a “nibble” of 4 bits, i.e. k=4) or even 6 bits could be taken for example. The preferred example of one byte will be taken in the rest of the description.

To process a complete block from smaller elements, it is necessary to multiply the operations within the block, and for this the present method classically combines the use of a non-linear permutation function ƒ (step (a) as will be seen), and the use of a linear multiplexing function L (step (b) as will be seen), each datum as a function of the cryptographic algorithm to be implemented.

The permutation function ƒ is a bijective function parameterized with a secret key k_i which takes as input an input element of ₂^k and generates at output an output element of the same size (i.e. of ₂^k). These functions are well known and that of any cryptographic algorithm could be used in particular using permutations, in particular an algorithm selected from DES and AES (the function ƒ is then for example a box S).

“Multiplexing” function means a function taking as input several elements of ₂^k (in particular n) and generating at output a single element of ₂^k. Thus, the multiplexing function combines several elements of ₂^k. These functions are well known and the commonly used eXclusive OR function could be used in particular (in particular in AES), noted XOR and more simply +.

It is understood that ƒ is non-linear and that L is linear.

The algorithm typically comprises alternating a stage of use of ƒ to permutate elements, then a stage of use of L for merging data, until the whole block has been processed (merged data are again permutated, then merged with other data, etc.). It is understood that the present method advantageously comprises the repetition of steps (a) and (b) so as to encrypt or decrypt a set of data comprising those of said n-tuple .

In the rest of the present description, the illustrative example of the general pattern a₀, a₁→z=L(ƒ(a₀+k₀), ƒ(a₁+k₁)) as found in FIGS. 1a to 1c will be taken, but the skilled person will be able to transpose it to other algorithmic structures.

It should be noted that for computations more complex than those described in the present examples, it can be interesting to use decomposition in the form of sequences of linear operations and multiplications. In this case, ideas continue to apply in combination with the works of Rivain-Prouff (“Provably Secure Higher-Order Masking of AES” CHES 2010) and Ishai-Sahai-Wagner (“Private Circuits: Securing Hardware against Probing Attacks” at CRYPTO 2003).

Permutation Step

The present method is implemented by the data-processing means 11a of the equipment 10a.

To counter attacks of the prior art, the present method proposes as shown in FIG. 3 to split all the internal states of the computation in at least m>n parts (in particular n+1 parts), that is, at least 3 parts if n=2 (the preferred example of 3 parts in the present description will be taken), and operating computations on these parts independently so as to find splitting of the final result ultimately expected of the computations, with non-linear splitting functions. Therefore, and as will be seen later, even though the prior art can dissuade use of splitting functions, the Applicant has discovered that the fact of using them sufficiently and selecting them non-linear astutely resolves all flaws.

As explained, the first step (a) is called permutation, and will use the function ƒ but not the function L.

In this step (a), for each element a_i of said n-tuple of data (i.e. ∀i∈0, n−1), “first internal states” are determined (belonging as elements a_i to ₂^k, and to the number of m) by application to said element a_i of m “first operations”. The first internal states are visible in the hypothesis of white box and must therefore be unusable for obtaining information on the secret keys.

Each first operation for this is:

• • represented by a table T_ij stored on data-storage means 12a of the equipment 10a (so as to protect implantation of the pattern and hide the keys), and
  • defined as the combination of a single bijective internal encoding G_ij, of a non-linear splitting function D_i, E_i, F_i . . . , and of the non-linear permutation function ƒ parameterized with the corresponding secret key k_i, said non-linear splitting functions D_i, E_i, F_i . . . forming m collections such that the n functions of a collection split any input datum in n fragments whereof the sum is equal to the input datum.

Therefore, typically there is:

• • y_i0=T_i0[a_i]=G_i0∘D_i ∘ƒ(a_i+k_i)=G_i0∘D_i(y_i),
  • y_i1=T_i1[a_i]=G_i1 ∘E_i ∘ƒ(a_i+k_i)=G_i1∘E_i(y₁),
  • y_i2=T_i2 [a_i]=G_i2 ∘F_i ∘ƒ(a_i+k_i)=G_i2 ∘F_i(y_i),
  • etc.

More precisely, the idea of non-linear splitting is to build functions D_i, E_i, F_i . . . such as ∀i∈0, n−1, ∀x, x=D_i(x)+E_i(x)+F_i(x)+ . . . . It is assumed that m=3, that is, three families D_i, E_i, F_i suffice, and therefore 6 functions if n=2. The G_ij serve as internal encoding while the D_i, E_i and F_i serve to split a secret.

Therefore, each “non-masked” internal value y_i=ƒ(a_i+k_i), which is a sensitive datum, can be rebuilt only from D_i(y_i), E_i(y_i) and F_i(y_i).

E_i and F_i can be selected randomly from all functions (not just bijective) operating on elements of preferred size, in particular bytes, but not D_i, which is linked to the others.

The method preferably comprises a previous step (a0) of random generation by the data-processing means 11b of a server 10b connected to the equipment 10a of m−1 non-linear splitting functions E_i, F_i . . . for each collection (D_i, E_i, F_i . . . ), from which the m-th non-linear splitting function D_i is built (by posing for example D_i(y)=y_i+E_i(y)+F_i(y)+ . . . for any element y).

As explained, all G_ij are bijective masking encodings (of ₂^k in ₂^k), selected randomly once for all, in particular by the server 10b.

In this way and as preferred, step (a0) further comprises random generation of internal encodings G_ij (and as will be seen G_Lj), construction of tables T_ij, and as will be seen T_Lj), and their transmission to the equipment 10a for storage on the storage means 12a. In the preferred embodiment there are m×n first internal encodings G_ij and their inverses, and m second internal encodings G_Lj and their inverses. In total, (m−1)+(m×n)+m=(n+2)m−1 functions of ₂^k in ₂^k must be generated randomly.

On completion of step (a) (when it has been implemented n times for all a_i), there is a set (in this case m×n) of said first internal states y_ij. So m n-tuples can be formed from first internal states

${\left\{{\left\{y_{\mathrm{ij}}\right\}}_{i\in 〚0,n-1〛}\right\}}_{j\in 〚0,m-1〛}.$

Multiplexing Step

The second step (b) is called multiplexing, and uses the function L to combine the first internal states y_ij.

In this step (b), for each n-tuple of first internal states (i.e. ∀j∈0, m−1) a (single) “second internal state” z is determined (still in ₂^k) by application to said internal states y_ij of the n-tuple of first internal states of a “second operation”.

As before, the second internal states are visible in the hypothesis of white box and therefore must be unusable for obtaining information on the first internal states and the secret keys.

Each second operation for this is:

• • represented by a table T_Lj stored on the data-storage means 12a of the equipment 10a (again so as to protect implantation of the pattern), and
  • defined as the combination of a second single bijective internal encoding G_Lj, of the linear multiplexing function L, and of the inverses of said first bijective internal encodings G_ij.
  • Therefore, this typically gives: z_j=T_Lj[y_0j, y_1j . . . ]=G_Lj∘L(G_0j⁻¹[y_0j], G_1j⁻¹[y_1j] . . . ).

n by n will be cross-combined as evident in FIG. 3, the first internal states such that the non-masked value of z=T_L[y₀, y₁, . . . ] which is another sensitive datum can again be rebuilt from all the D_i(y_i), E_i(y_i) and F_i(y_i). The G_Lj again serve as internal encoding while the D_i, E_i and F_i serve to split a secret.

Explanation

The encrypted/decrypted z of said n-tuple of data can easily be retrieved from m second internal states

If needed, it is sufficient to apply to them in a step (c) a “third operation” which is:

• • represented by a table T_z stored on the data-storage means 12a of the equipment 10a, and
  • defined as the sum of the inverses of said second bijective internal encodings G_Lj.

Therefore, this typically gives: z=T_z[]=Σ_j=0^m-1G_Lj⁻¹[z_j].

Yet, because n<m, each z_j contains insufficient information for rebuilding to obtain a relation linking the y_i, an attack by collision therefore becomes impossible.

To illustrate this in the case n=2 and m=3, for any pair of octets (a, b), there is ∀j∈{0; 1; 2}, T_Lj(a, b)=G_Lj (L(G_0j⁻¹(a), G_1j⁻¹(b))), that is, T_L0(a, b)=G_L0(L(G₀₀⁻¹(a), G₁₀⁻¹(b))), T_L1(a, b)=G_L1(L(G₀₁⁻¹(a), G₁₁⁻¹(b))) and T_L2(a, b)=G_L2(L(G₀₂⁻¹(a), G₁₂⁻¹(b))).

It can be verified that by linearity of L and by construction, there is

$T_{L0}\left(T_{00}\left[a_0\right],T_{10}\left[a_1\right]\right)=G_{L0}\left(L\left(G_{00}^{-1}\left(G_{00}{\mathrm{oD}}_0\left[y_0\right]\right),G_{10}^{-1}\left(G_{10}{\mathrm{oD}}_1\left[y_1\right]\right)\right)\right)=G_{L0}\left(L\left(D_0\left[y_0\right],D_1\left[y_1\right]\right)\right);$ $T_{L1}\left(T_{01}\left[a_0\right],T_{11}\left[a_1\right]\right)=G_{L1}\left(L\left(G_{01}^{-1}\left(G_{01}{\mathrm{oE}}_0\left[y_0\right]\right),G_{11}^{-1}\left(G_{11}{\mathrm{oE}}_1\left[y_1\right]\right)\right)\right)=G_{L1}\left(L\left(E_0\left[y_0\right],E_1\left[y_1\right]\right)\right);$ $T_{L2}\left(T_{02}\left[a_0\right],T_{12}\left[a_1\right]\right)=G_{L2}\left(L\left(G_{02}^{-1}\left(G_{02}{\mathrm{oF}}_0\left[y_0\right]\right),G_{12}^{-1}\left(G_{12}{\mathrm{oF}}_1\left[y_1\right]\right)\right)\right)=G_{L2}\left(L\left(F_0\left[y_0\right],F_1\left[y_1\right]\right)\right);$

That is ∀j∈{0; 1; 2}, T_Lj(T_0j[a₀], T_1j[a₁])=G_Lj(L(G_0j⁻¹[y_0j], G_1j⁻¹[y_1j])). This suggests that the G_Lj for j=0, 1, 2 form encoding of a splitting of the datum T_L[y₀, y₁] described in FIG. 1c.

And z=G_L0⁻¹[z₀]+G_L1⁻¹[z₁]+G_L2⁻¹[z₂]=G_L0⁻¹∘G_L0(L(D₀[y₀], D₁[y₁]))+G_L1⁻¹∘G_L1(L(E₀[y₀], E₁[y₁]))+G_L2⁻¹∘G_L2(L(F₀[y₀], F₁[y₁]))=L(D₀[a₀], D₁[a₁])+L(E₀[y₀], E₁[y₁])+L(F₀[y₀], F₁[y₁])=L(D₀[y₀]+E₀[y₀]+F₀[y₀], D₁[y₁]+E₁[y₁]+F₁[y₁])=L(y₀, y₁)=L(ƒ(x₀+k₀), ƒ(y₀+k₁)).

The present breakdown therefore easily achieves its objective, specifically enabling encryption or decryption of elements and obtaining only internal states which cannot be exploited to recover the secret keys.

Computer Program Product

According to a second and a third aspects, the invention relates to a computer program product comprising code instructions for executing (in particular on the data-processing means 11a of the equipment 10a) a method according to the first aspect of the invention for encrypting or decrypting a n-tuple of data with a n-tuple of predetermined secret keys , as well as storage means legible by computer equipment (a memory 12a of the equipment 10a) hosting this computer program product.

Claims

1. A method for encrypting or decrypting a n-tuple of data with a n-tuple of predetermined secret keys , n≥2, for a given non-linear permutation function (ƒ) and a given linear multiplexing function (L), the method being characterized in that it comprises data-processing means (11a) of equipment (10a) implementing steps of: (c) For each element (ai) of said n-tuple of data , determination of m>n first internal states by application to said element (ai) of m first operations, each being: represented by a table (Tij) stored on data-storage means (12a) of the equipment (10a), anddefined as the combination of a single bijective internal encoding (Gij), of a non-linear splitting function (Di, Ei, Fi . . . ), and of the non-linear permutation function (ƒ) parameterized with the corresponding secret key (ki), said non-linear splitting functions (Di, Ei, Fi . . . ) forming m collections such that the n functions of a collection split any input datum in n fragments whereof the sum is equal to the input datum; all of said first internal states yij determined for all said elements (ai) forming m n-tuples of internal states

2. The method according to claim 1, wherein ∀i∈0, n−1, yi0=Ti0[ai]=Gi0∘Di∘ƒ(ai+ki), yi1=Ti1[ai]=Gi1∘Ei∘ƒ(ai+ki), yi2=Ti2[ai]=Gi2 ∘Fi ∘ƒ(ai+ki), etc.

3. The method according to claim 2, wherein zj=TLj[y0j, y1j . . . ]=GLj∘L(G0j−1[y0j], G1j−1[y1j] . . . ).

4. The method according to one of claims 1 to 3, wherein ∀i∈0, n−1, ∀x, x=Di(x)+Ei(x)+Fi(x)+ . . . .

5. The method according to claim 4, comprising a previous step (a0) for random generation by data-processing means (11b) of a server (10b) connected to the equipment (1a) of m−1 non-linear splitting functions (Ei, Fi . . . ) for each collection (Di, Ei, Fi . . . ), from which the m-th non-linear splitting function (Di) is built.

6. The method according to claim 5, wherein step (a0) further comprises random generation of internal encodings (Gij, GLj), construction of tables (Tij, TLj), and their transmission to the equipment (10a) for storage on the storage means (12a).

7. The method according to one of claims 1 to 6, comprising the repetition of steps (a) and (b) so as to encrypt or decrypt a set of data comprising those of said n-tuple .

8. The method according to one of claims 1 to 7, further comprising a determination step (c) of the encrypted/decrypted (z) of said n-tuple of data by application to said second internal states of a third operation being: represented by a table (Tz) stored on the data-storage means (12a) of the equipment (10a), anddefined as the sum of the inverses of said second bijective internal encodings (GLj).

9. The method according to claim 8, wherein z=Tz[]=Σj=0m-1GLj−1[zj].

10. The method according to one of claims 1 to 9, wherein n=2.

11. The method according to claim 10, wherein said linear multiplexing function (L) is the eXclusive OR function.

12. The method according to one of claims 1 to 11, wherein m=3.

13. The method according to one of claims 1 to 12, wherein each element (ai) of said n-tuple of data has a size of one byte or of one half-byte.

14. The method according to one of claims 1 to 13, wherein said non-linear permutation function (ƒ) is that of a cryptographic algorithm selected from DES and AES.

15. A computer program product comprising code instructions for executing a method according to one of claims 1 to 14 for encryption or decryption of a n-tuple of data with a n-tuple of predetermined secret keys .

16. Storage means legible by computer equipment on which a computer program product comprises code instructions for executing a method according to one of claims 1 to 14 for encryption or decryption of a n-tuple of data with a n-tuple of predetermined secret keys .