Abstract:
A network authentication system with dynamic key generation that facilitates the establishment of both endpoint identity, as well as a secure communication channel using a dynamically-generated key between two end devices (potentially on separate local area networks). An interactive or noninteractive authentication protocol is used to establish the identity of the target end device, and dynamic key generation is used to establish a shared symmetric session key for creating an encrypted communication channel between the end devices.

Description:
CROSS REFERENCE TO BELATED APPLICATIONS 
       [0001]    This application claims the benefit of the priority of and incorporates by reference provisional U.S. Patent Application Ser. No. 62/001,979 filed May 22, 2014. 
     
    
     FIELD OF THE INVENTION 
       [0002]    This disclosure relates generally to network authentication, and in particular but not exclusively, to authentication to protect against tampering and subversion by substitution. 
       BACKGROUND OF THE INVENTION 
       [0003]    An essential aspect of online communication is the ability of two endpoints to establish an authenticated channel based on their respective identities. One solution to this employs public key infrastructure (PKI), wherein public keys allow end devices to be reasonably convinced that they are communicating only with each other. In this scheme, however, an endpoint and its identity are generally independent, i.e., an arbitrary identity is generated and assigned to an endpoint. 
         [0004]    In various device authentication schemes, physical unclonable functions (PUFs) have been used such that each device has a unique identity intrinsically linked to the device. Rührmair et al. (“Modeling Attacks on Physical Unclonable Function.”  Proceedings of the  17 th ACM conference on Computer and communications security , CCS &#39;10, pages 237-249, ACM. 2010) define three distinct classes of PUF devices:
       A Weak PUF is typically used only to derive a secret key. The challenge space may be limited, and the response space is assumed to never be revealed. Typical constructions include the SRAM (Holcomb et al., “Initial SRAM State as a Fingerprint and Source of True Random Numbers for RFID Tags,”  In Proceedings of the Conference on RFID Security,  2007), Butterfly (Kumar et al., “Extended abstract: Butterfly PUF Protecting IP on Every FPGA,”  IEEE International Workshop on Hardware - Oriented Security and Trust , pages 67-70, 2008), Arbiter (Lee et al., “A technique to build a secret key in integrated circuits for identification and authentication applications,”  IEEE Symposium on VLSI Circuits: Digest of Technical Papers , pages 176-179, 2004), Ring Oscillator (Suh et al., “Physical Unclonable Functions for Device Authentication and Secret Key Generation,”  Proceedings of the  44 th, annual Design Automation Conference , DAC &#39;07, pages 9-14, ACM, 2007), and Coating (Tuyls et al., “Read-Proof Hardware from Protective Coatings,”  Proceedings of the  8 th international conference on Cryptographic Hardware and Embedded Systems , CHES&#39;06, pages 369-383, Springer, 2006) PUFs.   A Strong PUF is assumed to be (i) physically impossible to clone, (ii) impossible to collect a complete set of challenge response pairs in a reasonable time (typically taken to be on the order of weeks), and (iii) difficult to predict the response to a random challenge. For example, the super-high information content (SHIC) PUF described by Rührmair (“Applications of High-Capacity Crossbar Memories in Cryptography,” IEEE Trans. Nanotechnol. , volume 10, no. 3:489-498, 2011) may be considered a Strong PUF.   A Controlled PUF satisfies all of the criteria for strong PUFs, and additionally implements an auxiliary control unit capable of computing more advanced functionalities to cryptographically augment protocols.       
 
         [0008]    PUF output is noisy in that it varies slightly despite evaluating the same input. This is generally addressed with fuzzy extraction, a method developed to eliminate noise in biometric measurements. (See Juels et al., “A Fuzzy Commitment Scheme,”  Proceedings of the  6 th ACM conference on Computer and Communications Security , CCS &#39;99, pages 28-36, ACM, 1999). Fuzzy extraction may in part be employed within a device having a PUF such as within an auxiliary control unit, such that the output is constant for a fixed input. Fuzzy extraction (or reverse fuzzy extraction) may for example employ a “secure sketch,” as described by Juels et al. to store a sensitive value V to be reconstructed and a helper string P for recovering V. A secure sketch SS for input string O, where ECC is a binary (n, k, 2t+1) error correcting code of length n capable of correcting t errors and V←{0, 1} k  is a k-bit value, may for example be defined as SS(O;V)=O⊕ECC(V). The original value V then may be reproduced given the helper string P and an input O′ within a maximum Hamming distance t of O using a decoding scheme D for the error-correcting code ECC and O′, as D(P⊕O′)=D(O⊕ECC(V)⊕O′)=V. 
         [0009]    A physical unclonable function P d :{0,1} κ     1   →{0,1} κ     2    bound to a device d preferably exhibits the following properties:
       1. Unclonability: Pr[dist(y,x)≦t|x←U κ     1   ,y←P(x), z←P′]≦ε 1 , the probability of duplicating PUF P with a clone PUF P′ such that their output distributions are t-statistically close is less than some sufficiently small ε 1 .   2. Unpredictability: It is desirable that an adversary cannot predict a device&#39;s PUF response r for a challenge c with more than negligible probability (at least without physical access to the device), and that helper data does not reveal anything to an adversary about PUF responses. Assuming that all entities are bound to probabilistic polynomial-time (PPT), i.e., can only efficiently perform computation requiring polynomially many operations with respect to a global security parameter λ (which refers to the number of bits in the relevant parameter). Adv A   PUF-PRED (κ 2 )=Pr[r=r′], denoting the probability of the adversary A guessing the correct response r of the PUF P to the challenge c, is preferably negligible in κ 2 . This can be assessed, for example, through a game between an adversary A and a PUF device P:{0,1} κ     1             {0,1} κ     2    mapping input strings from the challenge space C P  of length κ 1  to the response space R P  of length κ 2  where λ is the security parameter for the protocol, given in unary as 1 λ .       
 
         [0000]    
       
         
               
             
               
               
               
               
             
               
               
               
               
               
             
           
               
                   
               
               
                 PUF-PRED: PUF Prediction Game 
               
             
          
           
               
                   
                 Adversary A 
                   
                 PUF Device P 
               
               
                   
                   
               
             
          
           
               
                 (1) 
                 c i  ∈  C   P  ⊂ C P , 
                 → 
                   
                   
               
               
                   
                 0 ≦ i ≦ poly(λ) 
               
               
                   
                   
                 ← 
                 r i  = P(c i ) ∈  R   P   
                 (2) 
               
               
                   
                   
                   
                   R   P  ⊂ R P , 
               
               
                   
                   
                   
                 0 ≦ i ≦ poly(λ) 
               
               
                 (3) 
                 Challenge c ∉  C   P   
                 → 
               
               
                 (4) 
                 c i ′ ∈  C   P ′ ⊂ C P , 
                 → 
               
               
                   
                 c ∉  C   P ′, 
               
               
                   
                 0 ≦ i ≦ poly(λ) 
               
               
                   
                   
                 ← 
                 r i ′= P(c i ′) ∈  R   P ′ 
                 (5) 
               
               
                   
                   
                   
                   R   P ′ ⊂ R P , 
               
               
                   
                   
                   
                 0 ≦ i ≦ poly(λ) 
               
               
                 (6) 
                 Guess r′            P(c) 
                 → 
               
               
                   
               
             
          
         
       
     
         [0012]    The game proceeds as follows: 
         [0013]    1. The adversary A issues polynomially many (w.r.t. the security parameter λ) challenges c i ∈  C   P  to the PUF device P, where the challenge set  C   P  is a proper subset of the entire challenge space C P .
       2. The PUF device P returns the responses {r i |r i ←P(c i )} to A.   3. The adversary A eventually outputs a challenge c that was not in the original set of challenge queries  C   P . The adversary is not allowed to query the PUF device P on the committed challenge c.   4. The adversary A may once again issue a new set of polynomially many challenges c i   1 ∈  C   P   1  to the PUF device P. The adversary is not allowed to query the PUF device P on the committed challenge c.   5. The PUF device P returns the responses {r i   1 |r i   1 ←P(c i   1 )} to A.   6. The adversary A eventually outputs a guess r′ for P&#39;s response to the committed challenge c.       
 
         [0019]    The adversary only wins the game when guess r′ is equal to P&#39;s actual response r←P(c) to A&#39;s committed challenge c. (As noted, the PUF&#39;s output is noisy and will vary slightly on any fixed input, so the equality is typically taken with respect to the output of a fuzzy extractor (e.g., Dodis et al.,“Fuzzy Extractors: How to Generate Strong Keys from Biometrics and Other Noisy Data,”  SIAM J. Comput ., volume 38, no. 1:97-139, 2008)).
       3. Robustness: Pr[dist(y,z)&gt;t|x←U κ     1   ,y←P(X), z←P(x)]≦ε 2 , i.e., the probability of a fixed PUF P yielding responses t-distant on the same input x is less than some sufficiently small ε 2 .   4. Indistinguishability: The output of the PUF device (typically fuzzy extractor output) preferably is computationally indistinguishable from a random string of the same length l, such that a PPT adversary A&#39;s advantage Adv A   PUF-IND (l) is at most negligibly more than ½. The indistinguishability of a PUF can be assessed, for example, through a game in which an adversary A is asked to differentiate between the output r of the fuzzy extractor for a PUF P and a randomly chosen string s∈{0,1} l  of the same length l.       
 
         [0000]    
       
         
               
             
               
               
               
               
               
             
               
               
               
               
               
             
           
               
                   
               
               
                 PUF-IND: PUF Inistinguishability Game 
               
             
          
           
               
                   
                 Adversary A 
                   
                 PUF Device P 
                   
               
               
                   
                   
               
             
          
           
               
                 (1) 
                 c i  ∈ CH ⊂ C P , 
                 → 
                 (R i , H i ) ← 
                   
               
               
                   
                 0 ≦ i ≦ poly(λ) 
                   
                 Gen(r i  = P(c)) 
               
               
                   
                   
                 ← 
                 H i  ∈  R   P  ⊂ R P , 
                 (2) 
               
               
                   
                   
                   
                 0 ≦ i ≦ poly(λ) 
               
               
                 (3) 
                 c i  ∈  CH  ⊂ C P , 
                 → 
               
               
                   
                 0 ≦ i ≦ poly(λ) 
               
               
                   
                   
                 ← 
                 R i  ∈  R   P  ⊂ R P , 
                 (4) 
               
               
                   
                   
                   
                 0 ≦ i ≦ poly(λ) 
               
               
                 (5) 
                 Challenge c ∉  CH   
                 → 
                 b ∈ {0, 1} 
               
               
                   
                   
                 ← 
                 b(s ∈ {0, 1} l )+ 
                 (6) 
               
               
                   
                   
                   
                 (1 − b)(R i ), 
               
               
                   
                   
                   
                 R i  = Rep(P(c), H i ) 
               
               
                 (7) 
                 c i ′ ∈ CH ⊂ C P , 
                 → 
               
               
                   
                 c ≠ c i ′, 
               
               
                   
                 0 ≦ i ≦ poly(λ) 
               
               
                   
                   
                 ← 
                 R i ′ ∈  R   P  ⊂ R P , 
                 (8) 
               
               
                   
                   
                   
                 0 ≦ i ≦ poly(λ) 
               
               
                 (9) 
                 Guess b′            b 
                 → 
               
               
                   
               
             
          
         
       
     
         [0022]    This game proceeds as follows:
       1. Adversary A executes the enrollment phase on any challenge c i ∈C P .   2. The PUF device returns the corresponding helper string H i  from the output of Gen. Denote this set of challenge-helper pairs (c i ,H i ) as CH.   3. Adversary A now requests the PUF response r i =P(c i ) for any c i ∈CH. Denote the set of requested challenges in this step  CH .   4. For all requests c i ∈  CH , the PUF device returns the set {r i |r i ←P(c i )}.   5. Adversary A selects a challenge c∉  CH , such that A has H i  but not R i  for c. The PUF device chooses a bit b∈{0,1} uniformly at random.   6. If b=0, A is given R i =Rep(P(c)=r i , H i ). Otherwise, if b=1. then A is given a random string s∈{0,1} l .   7. Adversary A is allowed to query the PUF device for c i   1 ∈CH so long as no c i   1 =c.   8. For all requests c i   1 ≠c, the PUF device returns the set {r i   1 |r i   1 ←P(c i   1 )}.   9. The adversary outputs a guess bit b′, and succeeds when b′=b.
 
Related assessments of PUFs are provided by Hori et al., “Quantitative and Statistical Performance Evaluation of Arbiter Physical Unclonable Functions on FPGAs,” 2010  International Conference on Reconfigurable Computing and FPGAS  ( ReConFig ), pages 298-303, 2010; Maiti,  A Systematic Approach to Design an Efficient Physical Unclonable Function , dissertation, Virginia Tech, 2012, and others.
       
 
         [0032]    Various authentication schemes utilize zero knowledge proofs of knowledge, which is a method for proving that a given statement is true, while revealing nothing beyond this fact. The zero knowledge proof is an interaction between two parties: a prover P that wishes to establish the validity of a statement, and a verifier V that must be convinced the statement is true. The verifier should be convinced with overwhelming probability that a true statement is indeed true. With a zero knowledge proof of knowledge, the verifier could not use the messages from a previous proof to convince a new party of the statement&#39;s validity, and the messages reveal only a single bit of information: whether or not the prover P possesses the secret. There are two general classes of zero knowledge proofs: interactive zero knowledge proofs, where a series of messages are exchanged between the prover P and verifier V, and non-interactive zero knowledge proofs, where the prover P conveys a single message M without interaction with V, yet V is convinced that P possesses the secret. Many (interactive) zero knowledge proof systems require multiple iterations to establish the validity of a statement. That is, each interaction may succeed with some probability, even if the prover does not possess the secret (or the statement is false). Thus, if the probability of success when the statement is false is p, the protocol is run n times until 1−(p) n  is sufficiently close to 1. 
       SUMMARY OF THE INVENTION 
       [0033]    An authentication system according to an embodiment of the invention facilitates the establishment of both endpoint identity, as well as a secure communication channel using a dynamically-generated key between two end devices (potentially on separate local area networks). An interactive or non-interactive authentication protocol is used to establish the identity of the target end device, and dynamic key generation is used to establish a shared symmetric session key for creating an encrypted communication channel between the end devices. In one embodiment, the shared symmetric session key may then be updated as desired, and encrypted under a new dynamically-generated key. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWING 
         [0034]      FIG. 1  is a diagram illustrating dynamic key generation between devices in an embodiment of the present invention. 
       
    
    
     DETAILED DESCRIPTION OF EMBODIMENTS 
       [0035]    The present detailed description is based on the example of an embodiment utilizing elliptic curve cryptography (including the associated terminology and conventions), but the inventive concept and teachings herein apply equally to various other cryptographic schemes such as ones employing different problems like discrete logarithm or factoring. Likewise, the invention is not limited by the various additional features described herein that may be employed with or by virtue of the invention. 
         [0036]    In order to construct an intrinsic identity of a device, a public representation of the device&#39;s identity (referred to here as an enrollment token or public key) is generated. An elliptic curve mathematical framework may be used, but those skilled in the art will realize that other frameworks (e.g., discrete logarithm frameworks, in which regard U.S. Pat. No. 8,918,647 is incorporated here by reference) will provide the same functionality. A cryptographic enrollment token (or series of tokens) {(c d , P d , A d  mod p)} is collected from each PUF device d in response to a challenge query (or queries) by the server. Each device chooses a private key P d   priv  uniformly at random from the space {0, 1} λ , where λ is the security parameter (e.g., the number of bits in the modulus p) and calculates A d =P d   priv ·G mod p as the device&#39;s public key, were G is a base point of order q on an elliptic curve over          . Preferably, no sensitive information is transmitted over the communication channel or stored in non-volatile memory (for example, the device may discard P d   priv  after generating A d ). When P d   priv  is needed to authenticate the device, the enrollment token (c d , P d , A d  mod p) allows the device d to regenerate P d   priv  and complete the proof. Algorithm 1 describes an exemplary enrollment protocol in pseudocode. 
         [0000]    
       
         
               
             
               
               
             
           
               
                   
               
               
                 Algorithm 1 Enrollment Algorithm 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 for Server s do 
               
               
                   
                  Select finite field             p  of order p 
               
               
                   
                  Select E, an elliptic curve over             p   
               
               
                   
                  Find G ∈ E/             p , a base point of order q 
               
               
                   
                 end for 
               
               
                   
                 for Server s do 
               
               
                   
                  c d  ← random ∈             p , a random group element 
               
               
                   
                  Device d ← {c d , E, G, p, q} 
               
               
                   
                 end for 
               
               
                   
                 for PUF Device d do 
               
               
                   
                  x = H(c d ,E,G, p, q) 
               
               
                   
                  O = PUF(x) 
               
               
                   
                  helper d  = P d  = O ⊕ ECC(P priv ) 
               
               
                   
                  token d  = A d  = P d   priv  · G mod p 
               
               
                   
                  Server s ← {token d , helper d } 
               
               
                   
                 end for 
               
               
                   
                 for Server s do 
               
               
                   
                  Store new enrollment entry {c d , (P d   priv  · G mod p), P d } 
               
               
                   
                 end for 
               
               
                   
                   
               
             
          
         
       
     
         [0037]    (The enrollment process preferably should be required only once, and preferably should ensure that in the event of a security breach the device can remain active through a minor change on the server side without re-enrollment. As described in U.S. Pat. No. 8,918,647 which is incorporated herein by reference, a challenge-response tree can be constructed wherein only the root node is directly derived from a PUF response, with derived tokens being generated from those collected during enrollment. 
         [0038]    A PUF-enabled device may locally store and retrieve a sensitive value preferably without storing any sensitive information in non-volatile memory. Algorithm 2 illustrates the storing of a sensitive value (e.g., P d   priv ) using a PUF, and Algorithm 3 illustrates the regeneration of the sensitive value. The challenge c d  and helper data helper for device d can be public, as neither reveals anything about the sensitive value. While the present example uses encryption of the sensitive value by exclusive-or, ⊕, alternately the value could for example be used to form a key to other encryption algorithms (e.g., AES) to enable storage and retrieval of arbitrary-sized values. 
         [0000]    
       
         
               
             
               
               
             
               
               
             
               
               
             
           
               
                   
               
               
                 Algorithm 2 PUF-Store 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 Goal: Store value P d   priv   
               
               
                   
                 for PUF Device d do 
               
             
          
           
               
                   
                 Select finite field              p  of order p 
               
               
                   
                 Select E, an elliptic curve over            
               
               
                   
                 Find G ∈ E/             p , a base point of order q 
               
               
                   
                 Select challenge c d  ∈             p   
               
               
                   
                 x = H(c d , E, G, p, q) 
               
               
                   
                 O = PUF(x) 
               
               
                   
                 helper d  = P d  = O ⊕ ECC(P d   priv ) 
               
               
                   
                 Write {c d , helper d } to non-volatile memory 
               
             
          
           
               
                   
                 end for 
               
               
                   
                   
               
             
          
         
       
     
         [0000]                                      Algorithm 3 PUF-Retrieve                                    Goal: Retrieve value P d   priv             for PUF Device d do            Read {c d , helper d } from non-volatile memory            x ← H(c d , E, G, p, q)            O′ = PUF(x)            P d   priv  ← D(helper d  ⊕ O′)           end for                        
Whenever O and O′ are t-close, the error correcting code ECC can be passed to a decoding algorithm D to recover the sensitive value.
 
         [0039]    The authentication phase allows a server to verify that a client device is authorized to issue a request. In an elliptic curve embodiment, upon receiving a request from a device, the server can conduct an elliptic curve variant of Chaum et al.&#39;s (“An Improved Protocol for Demonstrating Possession of Discrete Logarithms and some Generalizations,”  Proceedings of the  6 th annual international conference on Theory and application of cryptographic techniques ; EUROCRYPT&#39;87, pages 127-141, Springer, 1988) zero knowledge proof protocol with the device d to establish permission to perform the request, as shown in Algorithm 4. 
         [0000]                                  Algorithm 4 Authentication Algorithm                                for PUF Device d do        Server s ← request       end for       for Server s do        Device d ← {c d , G, P d , N, p, q} where N is a nonce and P is the helper string       end for       for PUF Device d do        x ← H( c d , E, G, p, q)        P d   priv ← PUF-Retrieve        r ← random ε            p,  a random group element        B ← r · G mod p        h ←Hash(G, B, A, N)        m ← r + h · P d   priv  mod p        Server s ← {B, m}        end for       for Server s do        h′ ← Hash(G, B, A d , N)        B′ ← m · G − h′ · A mod p                         Device                 d     ←     {             accept        :                     B   ′       =       B   ⋀   τ                   is                 current                   deny        :                     B   ′       ≠       B   ⋁   τ                   is                 not                 current                                   end for                    
The requirement for communication front the verifying end device in the interactive zero knowledge proof is to obtain a nonce value specific to the current proof. This prevents an eavesdropping adversary from using previous proofs from a valid device to successfully complete an authentication protocol and masquerade as the end device.
 
         [0040]    A non-interactive zero knowledge proof removes this communication requirement, and allows a proof to be completed without interacting with the verifying endpoint. A non-interactive construction of Algorithm 4 requires the device to generate the nonce on behalf of the verifier in a manner that prevents the proving end device from manipulating the proof. As one example, the proving end device may construct the nonce N as N←H(P d   priv ·G mod p|τ) where H is a hash function, τ is a timestamp and x|y denotes concatenation of x and y. The timestamp ensures that previous proofs constructed by the proving end device cannot be replayed by an adversary in the future, while the hash function ensures that the proving end device cannot manipulate the challenge in an adversarial manner. The timestamp preferably need not match the current timestamp on arrival at the prover, with the verifying endpoint instead checking that the timestamp is reasonably current (e.g. second granularity) and monotonically increasing to prevent replay attacks. Algorithm 5 provides a non-interactive authentication protocol. 
         [0000]    
       
         
               
             
               
             
           
               
                   
               
               
                 Algorithm 5 Non-Interactive Authentication Algorithm 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 for PUF Device d do 
               
               
                  x ← H{c d , E, G, p, q} 
               
               
                  P d   priv ← PUF-Retrieve 
               
               
                  A d  = P d   priv  · G mod p 
               
               
                  r ← random ε            p,  a random group element 
               
               
                  B ← r · G mod p 
               
               
                  N ← Hash(A d |τ) where τ is the current timestamp 
               
               
                  h ← Hash(G, B, A d , N) 
               
               
                  m ← r + h · P d   priv  mod p 
               
               
                  Server s ← {B, m, τ}  
               
               
                 end for 
               
               
                 for Server s do 
               
               
                  A d  = P d   priv  · G mod p (stored from device enrollment) 
               
               
                  N ← Hash(A d |τ) 
               
               
                  h′ ← Hash(G, B, A d , N) 
               
               
                  B′ ← m · G − h′ · A d   mod p 
               
               
                   
               
               
                 
                   
                     
                       
                         
                           Device 
                            
                           
                               
                           
                            
                           d 
                         
                         ← 
                         
                           { 
                           
                             
                               
                                 
                                   
                                     accept 
                                      
                                     
                                       : 
                                     
                                      
                                     
                                         
                                     
                                      
                                     
                                       B 
                                       ′ 
                                     
                                   
                                   = 
                                   
                                     
                                       B 
                                       ⋀ 
                                       τ 
                                     
                                      
                                     
                                         
                                     
                                      
                                     is 
                                      
                                     
                                         
                                     
                                      
                                     current 
                                   
                                 
                               
                             
                             
                               
                                 
                                   
                                     deny 
                                      
                                     
                                       : 
                                     
                                      
                                     
                                         
                                     
                                      
                                     
                                       B 
                                       ′ 
                                     
                                   
                                   ≠ 
                                   
                                     
                                       B 
                                       ⋁ 
                                       τ 
                                     
                                      
                                     
                                         
                                     
                                      
                                     is 
                                      
                                     
                                         
                                     
                                      
                                     not 
                                      
                                     
                                         
                                     
                                      
                                     current 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                   
               
               
                 end for 
               
               
                   
               
             
          
         
       
     
         [0041]    Non-interactive authentication may be employed so as to provide first packet authentication in zero knowledge. For example, the first packet sent by the proving end device may contain the following authentication token, which is sufficient for the verifying end device to establish the identity of the proving end device: auth={B=r·G mod p,m=r+h·P d   priv  mod p,τ}. The authentication is first packet in that no communication with the receiving (verifying) end device is necessary before constructing the authentication token. Further, verification of the sending (proving) end device completes without communication with the sending (proving) end device. An eavesdropping adversary observing packet auth will be unable to replay the packet, as the timestamp τ will no longer be current. Algorithm 6 illustrates device-to-device first packet mutual authentication. 
         [0000]                                  Algorithm 6 Non-Interactive Mutual Authentication Algorithm                                for PUF Device d ε {0,1} do        x ← H( c d , E, G, p, q)        P d   priv ← PUF-Retrieve        A d  = P d   priv  · G mod p        r ← random ε            p,  a random group element        B d  ← r · G mod p        N d  ← Hash(A d |τ d ) where τ d  is the current timestamp        h ← Hash(G, B, A d , N d )        m d  ← r + h · P d   priv  mod p        Device (1 − d) ← {B d , m d , τ d }        A (1 −   d)  ← QueryServer(DeviceID =(1 − d))        N (1 −   d)  ← Hash(A (1 −   d) |τ (1 −   d) )        h (1 −   d) ′ ← Hash(G, B (1 −   d) , A (1 −   d) , N (1 −   d) )        B (1 −   d) ′ ← m (1 −   d)  · G − h (1 −   d) ′ · (A (1 −   d)  mod p                         Device                   (     1   -   d     )       ←     {             accept        :                     B     (     1   -   d     )     ′       =         B     (     1   -   d     )       ⋀     τ     (     1   -   d     )                       is                 current                   deny        :                     B     (     1   -   d     )     ′       ≠         B     (     1   -   d     )       ⋁     τ     (     1   -   d     )                       is                 not                 current                                   end for                    
Two communicating devices can as desired (i.e., dynamically), (re)authenticate using Algorithm 6 and simultaneously establish a new session key by sending an auth-update message including the authentication token and a new session key. Referring to  FIG. 1  for example, if device D 1  wishes to prove identity on the first packet to device D 5 , and simultaneously establish a new session key with device D 5 , the auth-update packet is then {B D1 =r·G mod p,m D1 =r+h·P D1   priv  mod p,τ D1 , E A     D5    (session-key (D1,D5) , SIG D1 (H(session-key (D1,D5) )))}.
 
         [0042]    One embodiment of such a device may comprise a Xilinx Artix 7 field programmable gate array (FPGA) platform, equipped, e.g., with 215,000 logic cells, 13 Megabytes of block random access memory, and 700 digital signal processing (DSP) slices. In an embodiment employing elliptic curve cryptography, for example, the hardware mathematics engine may be instantiated in the on-board DSP slices, with the PUF construction positioned within the logic cells, and a logical processing core including an input and output to the PUF and constructed to control those and the device&#39;s external input and output and to perform algorithms (sending elliptic curve and other mathematical calculations to the math engine) such as those described above. Devices (e.g., D 1 -D 8  in  FIG. 1 ) thus constructed can then be connected (such as via a network) and perform non-interactive mutual authentication and dynamic key generation. Numerous other physical embodiments are readily apparent, such as using a coating PUF over a larger integrated circuit, etc. 
         [0043]    In another embodiment, a new ‘public key’ of the target end device can be generated without requiring communication with the target end device to encrypt a new random session key, which will supersede the current session key. The new public key may be generated, as desired, using derived tokens as described in U.S. Pat. No. 8,918,647, which is incorporated by reference in that regard. 
         [0044]    One skilled in the art will realize that other combinations and adaptations of the exemplary features and algorithms may be used in different applications, and the use of the device&#39;s hardware identity may be applied to a variety of cryptographic authentication techniques not limited by the zero knowledge aspect of the example provided. For example, a device wishing to communicate with a system may initially perform authentication such as according to Algorithm 5 to authenticate in the first packet to the system and the system may then perform the dynamic session key establishment protocol (through an auth-update message) with the device to initiate a secure communication channel. Further, the authentication protocol need not be limited to zero knowledge, and could be based on other cryptographic constructions for establishing identity. For example, a server may send a device a challenge message, which the device digitally signs using its hardware identity e.g., using the private key regenerated by the device&#39;s PUF and a standard signature algorithm) and includes this signature in the packet header (e.g., TCP Options Header) returned to the server. Upon receipt, the server verifies the digital signature over its challenge is valid using the device&#39;s public key. 
         [0045]    As one embodiment of the invention relies on an elliptic curve mathematical framework, one skilled in the art will realize that it may be extended to support cryptographically-enforced role based access control (RBAC). That is, data access policies and device credentials may be specified mathematically, and the RBAC algorithm computes a function f(P,C)         {0,1} mapping policies P and credentials C to an access decision in {0,1}. This is typically accomplished by constructing a bilinear pairing (e.g. Well or Tate pairing).