New Family of Stream Ciphers as Physically Clone-Resistant VLSI-Structures

A new large class of $2^{100}$ possible stream ciphers as keystream generators KSGs, is presented. The sample cipher-structure-concept is based on randomly selecting a set of 16 maximum-period Nonlinear Feedback Shift Registers (NLFSRs). A non-linear combining function is merging the 16 selected sequences. All resulting stream ciphers with a total state-size of 223 bits are designed to result with the same security level and have a linear complexity exceeding $2^{81}$ and a period exceeding $2^{161}$. A Secret Unknown Cipher (SUC) is created randomly by selecting one cipher from that class of $2^{100}$ ciphers. SUC concept was presented recently as a physical security anchor to overcome the drawbacks of the traditional analog Physically Unclonable Functions (PUFs). Such unknown ciphers may be permanently self-created within System-on-Chip SoC non-volatile FPGA devices to serve as a digital clone-resistant structure. Moreover, a lightweight identification protocol is presented in open networks for physically identifying such SUC structures in FPGA-devices. The proposed new family may serve for lightweight realization of clone-resistant identities in future self-reconfiguring SoC non-volatile FPGAs. Such self-reconfiguring FPGAs are expected to be emerging in the near future smart VLSI systems. The security analysis and hardware complexities of the resulting clone-resistant structures are evaluated and shown to exhibit scalable security levels even for post-quantum cryptography.


Introduction
Clone-Resistant Units have been well investigated during the last two decades. The aim is to provide electronic systems with unique and secure identities making them resistant to cloning attacks. Physical Unclonable Functions (PUFs) [Pap01] [AM17] [MV10] were introduced to fabricate electronic unclonable units for secure identification/authentication [TB06] [SVW10], memoryless key storage [Lim04] [ŠTO05] and intellectual property protection [Int]. Due to the analog nature of all proposed PUF technologies, all techniques proposed so far had limited use in real world applications due to economic cost factors and failing long term stability. To overcome the PUFs issues, digital clone-resistant functions were introduced in [Adi08]. In [AMM17], digital clone-resistant functions were coined as Secret Unknown Ciphers. By definition, a Secret Unknown Cipher is a randomly, internally generated cipher inside the chip where the user has no access or influence on its creation process, even the producer is not able to backtrace the personalization process and deduce the made random cipher [MA19] [MA18a].
Creating SUC requires designing families of secure ciphers with random components [MA19]. In [AM] [ MA19], an SUC based on random block cipher was proposed, it is deploying random optimal S-Boxes as source of randomness of the SUC design. It was shown that deploying a fixed SUC design with small random components increases tremendously the cardinality of the resulting SUC class. Also, this ensures that each element of the SUC class has the same security level [MA19]. In [MAMH17], Random Stream Cipher (RSC) based on single cycle T-Functions (Triangular Functions) has been proposed to construct a class of SUCs. The proposed RSC-SUC makes use of DSP blocks embedded in modern SoC FPGAs to implement single cycle T-Functions as part of the keystream generators. Both proposed designs in [AM] [MA19] and [MAMH17] share the property of requiring a small area that should be located inside the FPGA. Distributing the SUC design in both cases would results with more area overhead and latency. In this paper, the SUC design template is based on combining a set of NLFSRs. Distributing NLFSRs overall the FPGA area is practically attainable since each NLFSR can be implemented in a free area of the FPGA. This would ensure additionally a zero-cost implementation of the SUC and lower its vulnerability to some side channel attacks. In 2005, the European project ECRYPT launches a competition to design new stream ciphers that might be suitable for widespread adoption. This project is called eSTREAM (ECRYPT Stream Cipher Project) [ECR] and it received 35 submissions. When it came to its end in 2008 [CT08], four of the proposals in the final portfolio [BCC + 08] were suited to fast encryption in software: HC-128, Rabbit, Salsa20/12 and Sosemanuk, while other four stream ciphers offered particularly efficient hardware implementation: Grain v1, MICKEY 2.0, Trivium and F-FCSR-H which has been excluded later because of the cryptanalytic results presented in [M. 08]. The last eStream portfolio includes seven algorithms [Tec09]. A number of NLFSR-based stream ciphers have been proposed to the eStream project such as Achterbahn [GGK05] and Grain [HJM07]. Achterbahn was one of the challenging new designs based on combining several NLFSRs with a non-linear combining function, which performs nonlinear operations on sequences with distinct minimal polynomials [Rue86]. In [TWF06], authors highlight some problems in the design principle of Achterbahn summarized in the small length of the NLFSRs and the weakness of the combining function. The complexity of the attack presented in [TWF06] depends exponentially to the number of shift registers and their size, and to the number of shift registers outputs that would cancel the nonlinear part of the combining function if they are equal to zero. After selecting the positions in the output sequence that cancel the nonlinear terms in the combining function, the attack builds parity checks. We outline that a high number of shift registers in the linear part of the combining function makes the attack complexity very high.

Contribution.
The contributions of this paper are summarized as follows: firstly, a new large-class of low-complexity stream ciphers with the same designed-security level is created. Each resulting cipher, even when randomly selected, exhibits the same security level. The cardinality of the cipher-class exceeds 2 100 without considering the NLFSRs initial states as a key of 223 bits. Secondly, the resulting ciphers are adapted to convert future VLSIdevices to clone-resistant physical entities in future VLSI technologies. Finally, a new generic-lightweight identification/authentication protocol is shown for VLSI-devices when using such SUC-based structure. The remainder of this paper is organized as follows, section 1 describes the state of the art of clone-resistan units, also it discusses Kerckhoffs' principles in relation to SUC. Section 2 presents a detailed description of the key stream generator. In section 3, security analysis of the proposed family of new stream ciphers is investigated. Section 4 describes a concept for deploying this family to create SUCs and provide unique and robust identity to SoC units. Section 5 presents the hardware complexity results and Section 6 concludes.

Secret Unknown Cipher
Digital physical clone-resistant units based on pseudo-random functions have been proposed in [AS07] [Adi08] to overcome some of the PUFs drawbacks especially their inconsistency. Those Physical Clone-Resistant Functions were nominated later on as Secret Unknown Ciphers (SUCs) [AM] [MAMH17]. Definition 1. Secret Unknown Cipher is a randomly internally generated cipher/hash inside the chip, where the user has no access or influence on its creation process, even the producer should not be able to back trace the creation process and deduce the made random cipher. Each generated SUC can be defined as an invertible Pseudo Random Function (PRF), as follows:  For an SUC based on block cipher design, i.e. n = m. The optimum case is to design an involutive SUC, such as SU C = SU C −1 and hence we define it as follows: Figure 1 describes the concept for embedding SUC in System on Chip (SoC) FPGA devices. The personalization process proceeds as follows, the Trusted Authority (TA) disposes of a software package called "GENIE" that contains an algorithm for creating internally random secure ciphers in addition to a package of cryptographically strong functions that will be used to design each SUC. The TA injects for a short time into each SoC FPGA unit the GENIE which runs only one time (step 1). After being loaded into the chip, the GENIE creates a permanent (non-volatile) and unpredictable random cipher by deploying random bits from the True Random Number Generator (TRNG) (step 2). When the GENIE completes the creation of the SUC, it will be fully deleted (step 3). After that, the SoC FPGA will contain its unique and unpredictable SUC. The TA challenges the SUC by a set of challenges X i and gets the corresponding responses Y i = SU C(X i ) and stores them on the corresponding area in its Units Individual Records (UIR) defined by the Serial Number of the device SN i . The X/Y pairs are to be used later by a TA to identify and authenticate devices. The concept is comparable to a PUF with the advantage that with an SUC based on random block cipher design, recovering Y from X is possible by using the inverse function of the SUC (SU C −1 ) or the same involution SUC. This property was deployed in [MA18a] to build a chain of trust used for a secured vehicular over the air software update, also for securing in-vehicle and vehicle-to-vehicle communication. SUC invertability is also used in the generic identification and authentications protocols in [AMM17] and other applications protocols such as in [MA18b]. In [AMM17], two generic identification/authentication protocols have been proposed, they show a very efficient identification protocol which eliminates storage of big number of challenge/response pairs, also the device should embed a small memory of about t-bit to detect t-consumed X/Y pairs, even without the need of deleting the used pairs during communication with the unit.
In [AM] [MA19], template based SUC was presented, where a block cipher with random components was designed as an SUC template. Optimal 4-bit S-Boxes were used as a source of randomness, such as the GENIE selects few S-Boxes from some sets of all optimal 4-bit S-Boxes. Each resulting SUC from this class has the same security level. Furthermore, in [MAMH17], Mars et al. proposed the first digital clone-resistant function prototype based on Random Stream Cipher (RSC) deploying a class of T-Functions (Triangular Functions) as key stream generator. We note that, identification and authentication protocols designed for SUC based on random block ciphers would not be applicable directly for an SUC based on random one-way function or on RSC.
As discussed before, many PUFs are susceptible to mathematical cloning hence they are recently nominated as Physically Unclonable Functions. SUC designs ensure that it is secure against known mathematical cryptanalysis as in [MA19] [MAMH17], and each SUC have the same security level. Since each device embeds a unique SUC, the adversary should break each unit alone with the same attack complexity. Moreover, SUC can be implemented with zero cost; the hardware overhead of an SUC should be low such as in [MA19]. Most industrial customer designs do not make full usage of the FPGA resources. Hence with low overhead, SUC can make use of the free FPGA resources and can be incrementally added to the customer design with zero cost.

Kerckhoffs' principles and SUC
In [Ker83a], Kerckhoffs stated the principles that should apply to a cryptosystem. The most concerning one, in relation to SUC, is the one stating that the method used to encipher data is known to the opponent, and that security must lie in the choice of key. However, "This does not necessarily implies that the method should be public, but only considered as public during its creation" [Ker83b] [Pet83]. Thus, SUC validates this Kerckhoffs's principle if and only if the SUC design is secure when considering that all the components are publicly known. In this paper, a family of stream cipher is proposed such that the NLFSRs feedback functions are selected randomly together with the initial NLFSRs states to generate SUCs. The security analysis of the proposed family of stream ciphers is investigated by considering that the cipher design is publicly known. i.e. the NLFSRs's feedback functions are known.
Cryptanalyzing SUCs in the field would require two steps: • Reversing the secret components: an adversary is forced to reverse the random selected functions that are used by the SUC.
• Breaking the resulting stream cipher: After reversing the secret parameters of an SUC, this SUC could be considered as a publicly known cipher and an adversary would apply known cryptanalytical attack to break this SUC.
Since each SUC is assumed to be generated randomly, attacking each SUC requires to repeat the same attack with the same complexity. This constitutes an advantage over using any secure stream cipher with publicly known specifications and with a randomly generated secret key. For this latest solution, the attack complexity is only based on breaking the publicly known stream cipher. Another advantage by design, is that for the proposed SUC, the secrets are distributed and not located in the same area such that when deploying a random secret key, this makes it hard to physically break the SUC.

Description of the Keystream Generator
The basic components of the KSG are 16 Non-Linear Feedback Shift Registers (NLFSRs) of lengths 6 to 17 and 19, 21, 22 and 23, combined by a balanced Boolean function F with algebraic degree 4, correlation immunity 8 and algebraic immunity 4. The NLFSRs are such that they can produce binary sequences of maximum period 2 N − 1, where N is the length of the shift register. Each shift register has a corresponding set of non-linear feedback function updating the internal state of the shift register. The outputs of the 16 NLFSRs deliver the 16 inputs of the combining function F which outputs the running key Z t . The 5 4-bits Look Up Tables (4-LUTs) implement the Boolean combining function F . The total number of all the NLFSRs bits is 223 bits. This design is hardware oriented to FPGA environment where the basic logic computing unit in FPGA is 4-LUT.
The key-loading algorithm that determines the initial internal states of the NLFSRs from a key (K ≥ 80 bits) and an initial vector (IV) will not be investigated in this paper since it is not required for SUC usage, i.e. the key (K) can be the initial NLFSRs states. Generally, two requirements are important for the key loading algorithm: for all possible keys (K), the key loading algorithm should generate non-zero initial states for the NLSRs, also it should be resistant to side channel attacks. Figure 2 describes the proposed stream cipher design.

Non-Linear Feedback Shift Registers
The principal components of KSG are the 16 NLFSRs with lengths from 6 to 17 and 19, 21, 23 and 24. Each N -bit NLFSR has a set of feedback functions ensuring all a maximum period of 2 N −1. This section will describe in details the NLFSRs design methodology.
Definition 2. A feedback Shift Register consists of pure cycles if and only if its feedback function has the form: where g is a Boolean function that does not depend on x 0 .
Definition 3. A (binary) de Bruijn sequence is a sequence of period 2 N in which each N -bit pattern occurs exactly once in one period of the sequence. The linear complexities of order N de Bruijn sequences are bounded by 2 N −1 + N and Definition 4. A modified de Bruijn sequence is a sequence of period 2 N − 1 in which each N -bit pattern occurs exactly once in one period of the sequence.
In [Dub], a list of maximum period (2 N − 1) NLFSRs of N -bits with 4 ≤ N ≤ 24 has been presented. The search covers three types of feedback functions with algebraic degree two: Where a, b, c, d, e, h ∈ 1, 2, ..., N − 1. The presented NLFSRs in [Dub] do not include the all-0 state in their longest cycle of states of period 2 N − 1.
The set of N -bit Fibonacci NLFSRs with the period 2 N − 1 can be partitioned into 4 subsets [Jan89]: basic, reverse of basic, complement of basic, and reverse complement of basic. In [Dub], only NLFSRs with basic form were listed. The forms of the reverse, complement and reverse complement of the basic form (equation 4) are described as follows: Thus, for each listed feedback function in [Dub], three feedback functions generating the reverse, complement or reverse complement sequence can be deduced.
In [Dub], for each NLFSR A i with N i -bit where 4 ≤ N i ≤ 24, a set of feedback functions ensuring maximum period of 2 Ni − 1 was presented. All feedback functions have the form in equation 4. For NLFSRs with N i -bit, S Ni denotes the set of boolean functions g listed in [Dub] (by removing the xor with x 0 ) together with their reverse, complement and reverse complement form. We coin those functions as Random Feedback Functions (RF F Ni ). The  Table 1. Figure 3 describes the general structure of the used NLFSRs. For each NLFSR A i of length N i , the feedback function contains Random Feedback Function (RF F Ni ). Its general form is defined as follows: Where: • For each NLFSR A i of length N i , a set of random feedback functions S Ni is selected such that each of its RF F j Ni makes the NLFSR A i achieves a maximum period of 2 Ni − 1. where: During the personalization process, one of the feedback functions is to be selected randomly from this set and will be used to construct NLFSR A i .
Each selected NLFSR A i in Figure 2 has a form of the general structure in Figure 3, and generates a nonlinear sequence of period 2 Ni − 1 which is a nonlinear modified de Bruijn sequence. The linear complexity L i of an NLFSR A i is bounded by: The number of NLFSRs and their lengths are selected to satisfy the primarily security requirements described in the following: • B-M Algorithm attack: in order to ensure that the attack complexity of B-M Algorithm is over 2 80 ; in terms of time complexity, the linear complexity L of the total key stream sequence should exceed 2 40 , since the complexity of B-M algorithm attack is the square of the linear complexity. For the data complexity, it is 2L and hence L should be greater than or equal to 2 80 .
• Correlation immunity: If an adversary succeeds to recover the randomly selected feedback functions, she/he can try to mount a correlation attack. In this case, to protect the system against correlation attack, the total number of bits of certain number of the least NLFSRs, where the number is determined by the correlation immunity, should exceed the computing power namely 2 80 . The correlation immunity of the combining function F is equal to 8, thus the total number of bits of the shortest 9 NLFSRs should exceed 80.

Cardinality of the KSG
The proposed KSGs can be used to create a family of SUC. In general, this design randomness is based on deploying all possible feedback functions ensuring that the N -bit NLFSR generates a sequence with period 2 N − 1. There are 2 2 N −1 −N +1 different N -bit Fibonacci NLFSRs with the period 2 N − 1 [Fre82]. Hence, the following theorem can be deduced.
In this paper, the NLFSRs selected for the proposed design can be made random, since for each N -bit NLFSR there exist a number of possible feedback functions ensuring a maximum period of 2 N . Hence randomly selecting one of the feedback functions for each NLFSR A i will ensure the same security level of the resulting random KSG as will be investigated through this paper. Table 2 presents the number of NLFSRs |A i | for each used NLFSR A i with length N i : This results with cardinality: ς ≈ 2 100 Furthermore, the 223 initial state is defined randomly by means of the TRNG adding an entropy of about 223 bits.

Boolean combining Function
The Algebraic Normal Form (ANF) of the proposed Boolean combining function is as follows: F (x 1 , ..., x 16 ) = x 1 + x 2 + x 3 + x 4 + x 5 + x 6 + x 7 + x 8 +x 9 x 11 + x 10 x 11 + x 10 x 12 + x 13 x 15 + x 14 x 15 + x 14 x 16 +x 9 x 10 x 11 + x 10 x 11 x 12 + x 13 x 14 x 15 x 16 (11) This Boolean combining function consists of two parts: • The linear part, which contains the monomials of degree one x 1 to x 8 , can be realized with two 4-LUTs, • The non-linear part containing monomials of degree two and three, related to the terms x 9 to x 16 can also be realized with another two 4-LUTs. The outputs of all four 4-LUTs are combined with one 4-LUT to generate the keystream Z t .

Properties of the BF.
Definition 5. The Boolean combining function F can be described as follows: The structure of a Boolean combining function is widely deployed in stream cipher designs. Although LFSR (linear feedback shift register)/ NLFSR (non-linear feedback shift register) can be excellent pseudo-random generators for being efficient, fast and with good statistical properties. They may be prone to be attacked due to linearity. A secure combining Boolean function should have the following properties: balanced, high algebraic degree, high correlation immunity and high nonlinearity. In the following, we present the analysis results of the Boolean combining function F .

Balanced
A Boolean combining function is balanced if and only if the numbers of '1's and '0's in its truth table are equal. Since the LFSRs/NLFSRs are supposed to be randomly i.d.d. (independent identically distributed), the combining function must be balanced to satisfy the pseudo-randomness. Otherwise, by inputting a large number of randomly selected values, the output value will not be balanced. Furthermore, the whole system would be vulnerable to cryptanalytic attacks. The Boolean combining function F is balanced.

Algebraic degree
The algebraic degree is the degree of ANF of the Boolean combining function. Since the ANF of the Boolean combining function has degree 4, the algebraic degree of F is 4.

Correlation immunity
Before we introduce the correlation immunity, an introduction to Walsh Transformation is needed.
Definition 6. Let x = (x 1 , x 2 , ..., x n ) and ω = (ω 1 , ω 2 , ..., ω n ) be n-tuples over {0, 1} , and dot product of x and ω is defined as: Then the Walsh Transformation on a n-variable Boolean function f (x) is defined as : The Correlation immunity can be calculated based on the Walsh Transformation as follows: If for all 1 ≤ wt(ω) ≤ t, with wt(ω) is the weight of ω, the Walsh Transformation F (ω) = 0 , then the number t is called correlation immunity.
The correlation immunity of the Boolean combining function F is 8.

Nonlinearity
The nonlinearity is the distance from the combining function F to the set of affine functions of n-variables (A n ): The non-linearity of the combining function F is: N L(F ) = 26624

Algebraic immunity
, 1}/F.g = 0}, any function g ∈ AN (F ) is called the annihilator of F . The algebraic immunity of F is the minimum degree of all the nonzero annihilators of F and of all those of F + 1. In [CM03], it was proved that the algebraic immunity is less than or equal to n/2 for any n-variable Boolean function F . The algebraic immunity of the Boolean combining function F is 4.
As a summary, the Boolean combining function F is balanced with algebraic degree 4, correlation immunity 8, nonlinearity 26624 and algebraic immunity 4.

Security Analysis
In this section, we present a security analysis of the stream cipher against the following attacks: Brute force attack, Correlation Attack, Algebraic Attack and Parity Check Attack.

Exhaustive search of NLFSRs initial states
The first brute force attack is exhaustive search of all the internal states in NLFSRs. The Adversary will enumerate all possible states, then generate the corresponding sequence in each case and compare it with the known keystream. If the generated sequence and the keystream match, then the internal states of the NLFSR are found and the cipher is broken.
The complexity of this attack is: The total length of the NLFSRs is 223 bits and the cardinality of the KSG is ≈ 2 100 resulting with a complexity of ≈ 2 323 . We conclude that the complexity of brute force attack to guess all possible internal states is beyond possible computational power. So the cipher is secure against this attack.

Berlekamp-Massey algorithm
The other smarter and important brute force attack algorithm is the Berlekamp-Massey algorithm [Mas69]. In order to analyse the complexity of the B-M algorithm on the proposed cipher, it is necessary to compute lower bound of the total linear complexity of the output bit-stream. The time complexity of the B-M algorithm attack is the square of the total linear complexity, and the data complexity is the double. If the lengths N 1 , ..., N t of the t shift registers are pairwise relatively prime, then the linear complexity L(ζ) of the keystream ζ can be expressed as [Rue86]: If the lengths of the primitive NLFSRs are not pairwise relatively prime, then equation (5) does not hold. In this case, F (L 1 , ..., L t ) provides only an upper bound for L(ζ). However, in many cases, it is still possible to derive a reasonable lower bound for the linear complexity of ζ. Lemma 1. [GGK06b] Let σ 1 , ..., σ t be nonzero output sequences of primitive binary NLF-SRs of lengths N 1 , ..., N t , respectively, and with linear complexities L 1 , ..., L t , respectively. Let F (x 1 , ..., x t ) be a Boolean function of algebraic degree d ≥ 1 . A lower bound for the linear complexity of the sequence ζ = F (σ 1 , ..., σ t ) can be given if the following two conditions are fulfilled: F (x 1 , ..., x t ) contains a monomial x i1 , ..., x i

The algebraic normal form (ANF) of
If both conditions are true, then: The Boolean combining function F has algebraic degree 4, the ANF of it contains the following monomial with degree 4: • The other monomials in the ANF of the Boolean combining function are of degree less than the degree of the monomial described in (6). Then condition 2 holds.
We conclude that the linear complexity of the keystream ζ is: B-M algorithm requires 2 162 time complexity and 2 82 data complexity to break the proposed KSG.

Correlation attack
The correlation attack was firstly proposed by T. Siegenthaler in 1984 [Sie84], then improved by W. Meier and O. Staffelbach in 1989 as fast correlation attack [MS89]. The main idea of correlation attack is to focus on the Boolean combining function of the KSG and find the correlation between the combination of several LFSRs/NLFSRs and the output keystream. This requires to have previous knowledge about the used NLFSRs, i.e. an adversary should reverse the randomly selected feedback functions before applying this attack. Since, there is more than 2 100 possible combinations of feedback functions and about 2 223 initial states, trying to reverse the feedback functions is not possible. Now, let us consider that an adversary knows the used feedback functions. In this case, the adversary can apply correlation attack with an aim to recover the NLFSRs initial states. By considering the classical fast-correlation attack, when the Boolean combining function has correlation immunity n, the adversary needs at least n + 1 shift registers at the same time. The correlation immunity of the Boolean combining function F is 8; therefore the total length of the smallest 9 NLFSRs is: Thus, if an adversary is given the used feedback functions of an SUC, the complexity of the correlation attack is at least 2 90 . However, this attack can not be realized since for each SUC the random feedback functions are selected randomly and internally inside the chip.

Algebraic attack
The algebraic attack is another important attack against stream ciphers. It was introduced in [Cou03] and extended in [CM03]. The main idea of the Algebraic attack is to find a well-chosen multivariate polynomial G(s), such that G.F is of substantially lower degree, where F (s) is the combining Boolean function and s is the current state. To examine the degree of the linear polynomial equations system, an assertion for the degree of the algebraic equations from [GGK06a] will be used. It is described in the following fact:

Fact [GGK06a]
For 2N j ≤ 2 Nj − N j , the k th entry in the monomial spectrum of the shift registers A j , with 1 ≤ j ≤ 16, contains close to 2 Nj−1 different monomials and has in general degree N j−1 . For the Boolean combining function F , we find the term with highest degree and then calculate it as follows: The highest term is x 13 x 14 x 15 x 16 and its degree can be calculated as: (N 13 −1)(N 14 −1)+(N 15 −1)+(N 16 −1) = (19−1)+(21−1)+(22−1)(23−1) = 81 (21) Since we need 2 Nj − 2 different monomials, in order to express the bits of the sequence by the initial state of each register. So we need: Different monomials in order to express the bits of the sequence from the highest degree term. Set apart the remaining different monomials, the complexity for solving the system of equations is: Where ω ≈ 2.38 is the exponent of the fast matrix multiplication. The complexity of solving the system of equations ensures that the proposed algorithm is secure against algebraic attack.

Parity Check attack
The parity check attack was firstly proposed in [TWF06], it can successfully break the Achterbahn stream cipher. It starts with the weakness of the Boolean combining function that if two terms are equal to 0, then the whole nonlinear part would be 0, therefore the Boolean combining function is purely linear. After the linearization of the Boolean combining function, a parity check is applied in order to retrieve possible inner states of some certain registers.
Parity check attack is very sensitive to the number of terms in the combining function after linearization, because that bits/terms are required to complete the parity check and the number also determines the expected number of the inner states in certain registers, which satisfy the precondition of the linearisation (some bits are equal to 0). In the following, we present the security analysis of the proposed algorithm against parity check attack. The ANF of the Boolean combining function F is defined as: F (x 1 , ..., x 16 ) = x 1 + x 2 + x 3 + x 4 + x 5 + x 6 + x 7 + x 8 +x 9 x 11 + x 10 x 11 + x 10 x 12 + x 13 x 15 + x 14 x 15 + x 14 x 16 +x 9 x 10 x 11 + x 10 x 11 x 12 + x 13 x 14 x 15 x 16 It has a linear part and a nonlinear part. When we examine the common terms of the nonlinear part, if x 9 = x 10 = x 13 = x 14 = 0, then the Boolean combining function would degenerate into a pure linear Boolean combining function: The upper bound of the linear complexity is relatively not that high: So we can build an LFSR with length L, and we can also apply parity check on the sequence output of the sequence from the linear Boolean combining function.
So, the parity check can be computed as follows: Since the period of the first register is T 1 , this expression does not contain any term of x 1 . Similarly: Therefore llllllll(t) contains only terms of x 8 . Thus it satisfies: In terms of bits l(i) , we have the following equation: This is the basic parity check on l(t) that can be used to attack the KSG, it is the XOR between 256 bits from the sequence , within the time interval: It is the complexity required for the parity check attack, but the degeneration happens under the condition x 9 = x 10 = x 13 = x 14 = 0 and the complexity to satisfy this condition should be considered.
Consider the x 9 register first, which x 9 = 0 is the condition for further parity check attack. For every bit used in parity check, totally 256 bits, they should all satisfy the condition. The number of all the possible internal states in register x 9 is 2 14 . Since the output should be independent and identically distributed (i.d.d), the expected number of cases that satisfy this condition is: At this step, the attack cannot continue, since the possibility of finding a case satisfying the condition x 9 = 0 is too small to ignore.

Application of Secret Unknown Ciphers
Secret Unknown Cipher (SUC) is a digital clone-resistant unit that can be deployed as a security anchor in wide spectrum of applications such as automotive security [MA18a]. SUC is a random cipher created internally in SoC FPGAs resulting with unique and unpredictable random cipher even for the producer for each SoC unit. To create SUC, ciphers/hashes with flexible components that can be generated randomly should be designed. In this paper, SUC based on combining random NLFSRs with identical cryptographic properties is presented. Recently, all published generic protocols deploying SUC [AMM17] are designed to be used for SUC based on random block ciphers. Protocols targeted for random stream ciphers or random key stream generators based SUC will be investigated in the following.

Enrollment protocol
During the enrollment process, the Trusted Authority (TA) stimulates a unit A by a command (cmd) to generate a k-bit response Y . The k-bit response results from running the KSG k-cycle. This operation is to be done sequentially to generate all the responses Y 0 , . . . , Y t−1 . Figure 4 describes the enrollment protocol. Figure 5 describes the identification protocol, it proceeds as follows:

Identification protocol
• Unit A sends its serial number SN A to the TA that checks for its existence in the TA units identification records UIR. if SN A ∈ U IR, then TA accepts and continues otherwise it rejects and abort.
• The TA selects the exact Y i and generates a random number R T . The, it encrypts R T with a standard cipher by using Y i as key and sends it in concatenation with R T as E T (R T )||R T .
• Unit A generates the next response Y i and decrypts the received message as E −1 (E Yi (R T )) = R T . If R T = R T then the received message doesn't come from the TA and the unit rejects and abort the communication. Meanwhile, unit A keeps the state S i−1 . This protects the system from being desynchronized. When R T = R T , unit A generates a random number R A , encrypts it by the same Y i and sends it concatenated with R A to TA.   Figure 6 descibes the update protocol, it proceeds as follows:

Update protocol
• The TA and unit A authenticates each other by using the last response Y t−1 .
• Unit A generates t-responses and sends them encrypted with Y t−1 to the TA as E Yt−1 (Y 0 , Y 1 , ..., Y t−1 ).

Trusted Authority
Unit A

RSC based SUC
Y t-1 SUC runs for t-cycles Where in each cycle a new response Y i is generated

Hardware Complexity
Mass production requires lightweight identification mechanisms for economic reasons. SUCs as clone-resistant identities gain special interest because it is possible to be implemented with zero-cost. Most FPGA applications do not consume the total resources offered by the deployed FPGA. In such cases, our proposed SUC unit requires very few FPGA resources and can be added incrementally to the existing application for zero-costs. The KSG described in Figure 2 is modeled in VHDL and synthesized to check its hardware complexity and performance. Libero SoC with its integrated tools is used to implement the design; Mentor Graphics Modelsim ME design tool was used for simulation and Synplify pro ME for synthesis. Table 3 describes the resources consumed for different devices of SmartFusion R 2 SoC FPGAs family. The KSG requires 37 LUTs and 223 DFFs, this can be considered as zero cost in many real applications. Implementation mechanism of the SUC based on the proposed family of new stream ciphers is not presented in this paper, a concept for creating SUC in SmartFusion R 2 SoC FPGAs is presented in [MAMH17]. Figure 7 describes an FPGA implementation concept of SUC based on combining random NLFSRs. Each NLFSR is providing one bit per cycle to the combining function. This makes it possible to distribute NLFSRs over all the FPGA where only one connection is required to connect an NLFSR to the combining function. This constitutes an advantage over SUC based on block cipher designs.

Conclusion
In this paper, a new large class of Key Stream Generators KSGs as stream ciphers is presented. The class is created by random selection of a set of maximum-period NLFSRs with different lengths. It is shown that a random selection of one Secret Unknown Cipher (SUC) from this class, can serve to convert future VLSI-devices (in a post-fabrication process) into clone-resistant entities. The security level of the proposed cipher class against many attacks is evaluated and shown to be scalable to cope even with post-quantum security requirements. i.e. as the attack complexity exceeds 2 160 , the cipher structure can cope even with post-quantum cryptographic requirements at relatively moderate implementation complexity. A lightweight proposed generic Identification/authentication protocol for such physical SUC based structures is also presented. A sample prototype case showed that one SUC structure consumes relatively minor FPGA resources; (0.61% of the LUTs, 3.71% of DFFs) in the smallest Microsemi SmartFusion R 2 SoC FPGA M2S005 devices, and (0.025% LUTs, 0.15% DFFs) for the largest M2S150 device. Future work is in progress to fine-tune and optimize ciphers and SUC structures for emerging VLSI technologies.