424 IEEE TRANSACTIONS ON DEPENDABLE AND SECURE COMPUTING, VOL. 16, NO.

3, MAY/JUNE 2019

Building PUF Based Authentication and Key

Exchange Protocol for IoT Without Explicit
CRPs in Verifier Database
Urbi Chatterjee , Vidya Govindan, Rajat Sadhukhan, Debdeep Mukhopadhyay,
Rajat Subhra Chakraborty , Senior Member, IEEE, Debashis Mahata , and Mukesh M. Prabhu

Abstract—Physically Unclonable Functions (PUFs) promise to be a critical hardware primitive to provide unique identities to billions of
connected devices in Internet of Things (IoTs). In traditional authentication protocols a user presents a set of credentials with an
accompanying proof such as password or digital certificate. However, IoTs need more evolved methods as these classical techniques
suffer from the pressing problems of password dependency and inability to bind access requests to the “things” from which they
originate. Additionally, the protocols need to be lightweight and heterogeneous. Although PUFs seem promising to develop such
mechanism, it puts forward an open problem of how to develop such mechanism without needing to store the secret
challenge-response pair (CRP) explicitly at the verifier end. In this paper, we develop an authentication and key exchange protocol by
combining the ideas of Identity based Encryption (IBE), PUFs and Key-ed Hash Function to show that this combination can help to do
away with this requirement. The security of the protocol is proved formally under the Session Key Security and the Universal
Composability Framework. A prototype of the protocol has been implemented to realize a secured video surveillance camera using a
combination of an Intel Edison board, with a Digilent Nexys-4 FPGA board consisting of an Artix-7 FPGA, together serving as the IoT
node. We show, though the stand-alone video camera can be subjected to man-in-the-middle attack via IP-spoofing using standard
network penetration tools, the camera augmented with the proposed protocol resists such attacks and it suits aptly in an IoT
infrastructure making the protocol deployable for the industry.

Index Terms—Physically unclonable functions, elliptic curve cryptography, identity based encryption, internet of things,
device authentication, key management

1 INTRODUCTION

I OTS have opened up an ubiquitous sensing-communicat-

ing-actuating network with information sharing across
platforms, blended seamlessly in various areas of modern
hardware security primitive [2] proposed in various security
applications such as IC anti-counterfeiting, device identifi-
cation and authentication, binding hardware to software
day-to-day living. But as with most emerging technologies, platforms, secure storage of cryptographic secrets, keyless
innovation comes first, and security is only an afterthought in secure communication etc. A Silicon PUF [3] is a mapping
reaction to discovered vulnerabilities. The devices deployed g : f0; 1gn ! f0; 1gm , where the output m-bit “response” are
in an IoT framework usually generate large quantities of unambiguously identified by both the n “challenge” bits and
security-sensitive data. One of the major security challenges the unclonable, instance-specific system behaviour. So, it can act
in IoT framework is the authentication and key management as a hardware fingerprint generator for the IC in which it is
of potentially billions of devices deployed in the network. included. We can adopt this property to uniquely identify each
We try to address this problem and provide a lightweight and devices in the IoT framework. A specific challenge and its cor-
secure solution using PUFs and IBE [1]. A PUF circuit reali- responding response together form a Challenge-Response Pair
zation can be thought to be an unconventional, lightweight (CRP) for a given PUF instance. PUF based authentication
protocols rely on this “challenge-response authentication”
 U. Chatterjee, V. Govindan, R. Sadhukhan, D. Mukhopadhyay, and
mechanism, rather than on a single secret cryptographic key.
R.S. Chakraborty are with the Secure Embedded Architecture Laboratory The response generated on-the-fly by the challenge applied to
(SEAL), Department of Computer Science and Engineering, Indian Institute a PUF instance can be used to generate session key for secure
of Technology Kharagpur, Kharagpur 721302, India. message encryption; thus offloads the complexity of managing
E-mail: {urbi.chatterjee, debdeep, rschakraborty}@cse.iitkgp.ernet.in, {vidya.
govindan, rajat.sadhukhan}@iitkgp.ac.in. and storing the keys for IoT device. We make following contri-
 D. Mahata and M.M. Prabhu are with the Wipro Technogies, Bengaluru, bution in this paper:
Karnataka 560 035, India.
E-mail: {debashis.mahata, mukesh.prabhu}@wipro.com.  We propose an authentication and key exchange pro-
Manuscript received 31 July 2017; revised 7 Apr. 2018; accepted 17 Apr. 2018. tocol combining the concepts of PUF, IBE and Key-ed
Date of publication 1 May 2018; date of current version 10 May 2019. Hash Function. The protocol solves an open problem
(Corresponding author: Urbi Chatterjee.) in the domain of PUF based protocols, alleviating the
For information on obtaining reprints of this article, please send e-mail to:
[email protected], and reference the Digital Object Identifier below. overhead from the verifier to store the CRP database of the
Digital Object Identifier no. 10.1109/TDSC.2018.2832201 PUF and the dependency of imposing security mechanism
1545-5971 ß 2018 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission.
See ht_tp://www.ieee.org/publications_standards/publications/rights/index.html for more information.
CHATTERJEE ET AL.: BUILDING PUF BASED AUTHENTICATION AND KEY EXCHANGE PROTOCOL FOR IOT WITHOUT EXPLICIT CRPS IN... 425

to keep it secret. In traditional PUF based protocols, if a resource overhead results have been provided in Section 6.
verifier needs to authenticate k IoT nodes, let us We conclude the paper with future research directions
assume that it stores l number of m-bit challenges and in Section 7.
its corresponding n bit responses. Then the space
complexity is: Oððm þ nÞ  l  kÞ. Now, if we con- 2 SYSTEM ASSUMPTIONS AND GOALS
sider the IoT framework, the “smart” devices (prover System Model. The setting assumed is that each IoT node
and verifier) are very resource constrained and more tries to authenticate to a verifier and communicate with the
susceptible to be a target for active and passive verifier or with another node. Each node is enabled with a
attacks. In many cases prover device is just a sensor PUF and has the capability to perform two elliptic curve
node and verifier device are mobile, bridge or router. operations, namely scalar multiplication and a pairing oper-
Accessing CRP database by the smart devices itself is ation along with a standard cryptographic hash function.
a security risk because smart devices are easy target On the other hand the verifier is assumed to have the capa-
for attacker. In order to offload storage requirement bility to compute keyed hash function, where the key is
from verifier and to eliminate risk of getting CRP stored in a non-volatile memory.
database compromised, we stores just a single key in Threat Assumptions. We assume the adversary can have
the NVM of verifier for authentication of all prover access to the communication channel and can not only be a
nodes under it using a key-ed hash function (space passive observer, but can tamper the channel with mali-
complexity: constant). This way it would be easier to cious data as an active adversary. The goal of the adversary
protect a single key instead of securing a whole CRP is to authenticate to the verifier on behalf of the legitimate
database. Additionally instead of using CRP database nodes, without possession of the node. For a PUF instance
directly we generate a new security association infor- embedded in an IoT node, its challenge-response character-
mation between prover and verifier that hides the istics is an implicit property, and is thus not accessible to
correlation between the challenge and response of the the adversary. Further, the attacker can corrupt the verifier
PUF and can be stored as public information. (as by a malware) and can obtain access to the databases
 We prove formally the security of the protocol in the which the verifier possesses. However, we assume that the
Session Key Security model and the Universal Com- attacker cannot gain knowledge of the secret key stored on
posability framework [4]. the verifier.
 We implement a prototype of the protocol to Attack Models. To formally proof the security of the proto-
securely authenticate a video surveillance camera, col, we introduce two models which we will briefly discuss
commercially purchased and devoid of any inbuilt here.
security feature. The prototype was implemented
following a hardware/software co-design, by con-  Session Key Security Model: Here all parties involved
necting the camera to an Intel Edison board, provid- in the protocol are assumed to be trusted. The
ing the IP and hosting the protocol operation, while attacker either (i) eavesdrops the communication
the hardware circuit of the PUF is implemented and link without any change or addition to the messages
unique ID is generated from a Artix-7 FPGA. But, (e.g., packet sniffing attack ) or, (ii) has full control
PUF responses are corrupted by noise and other over the links and can modify the messages (e.g.,
environmental factors when deployed in an embed- packet injection or re-routing attack). In Section 5.1.3,
ded system. Hence helper data algorithm or fuzzy it has been shown that the protocol is secure against
extractor [5] is used to generate cryptographic keys both of these attack variants.
with appropriate entropy from noisy and non-  Universally Composite Framework: This model ensures
uniform random PUF responses. To perform this that the proposed key exchange protocol provides
task, we design a BCH encoder circuit to generate the same security when used by any other protocol
the helper data from the responses of the PUF. This to set up session keys between two parties, even
helper data along with a BCH decoder can then be when it runs in parallel with an arbitrary set of other
used to re-generate the correct response from the protocols in a distributed communication network.
actual response of a PUF for a specific challenge. It is We have shown three different scenarios where: a)
to be noted that the BCH encoder and decoder circuit The verifier and the two communicating parties are
are implemented in Artix-7 FPGA. honest (ideal case), b) The verifier is corrupt, c)
 We first show a man-in-the-middle attack on the com- Either of the two communicating parties or both are
mercial video camera, and then show when the pro- corrupt. In real life implementation, we can picture
posed protocol is enabled, the attack is subverted. We case (b) and (c) as the attacker can control the internal
show that the protocol is lightweight, consumes low functioning of the party and tries to send some mali-
power, and has a low latency, suiting the require- cious information to disrupt the system.
ments of IoT. In this work, we do not address the subsequent encryp-
The rest of the paper is organized as follows. In Sections 2 tion of the messages between the nodes, but sketch that the
and 3, we provide the security assumptions and the back- public-private key pair established can be used to commu-
ground of the work. In Section 4, we present our proposed nicate using established protocols [1].
authentication and key exchange protocol. The correctness Design Goals. Next, we briefly discuss the design goals of
and security analyses of the proposed scheme are described the proposed PUF based Authentication and Key Exchange
in Section 5. The experimental setup, attack scenario and Protocol:
426 IEEE TRANSACTIONS ON DEPENDABLE AND SECURE COMPUTING, VOL. 16, NO. 3, MAY/JUNE 2019

 No explicit key storage in ‘Things’: Instead of having In this paper, we have tried to overcome the above-
explicit key storage, a PUF instance will be embed- mentioned problems. In our scheme, the prover (resource-
ded in each IoT data node to provide unique identity constrained) node is PUF-enabled, but the verifier (less
to the device. resource-constrained) node does not need to hold the subset
 Lightweight and minimal overhead on execution time : of the CRP database or the model of the PUF instance.
The hardware overhead, power-consumption of the Rather, it contains a keyed hash function which is used to
PUF enabled node and the latency to authenticate a authenticate the PUF instance without knowing the actual
legitimate node should be very less. response of a given challenge. We have assumed that the
 No explicit storage of raw CRP with verifier and model key is stored in a secure non-volatile memory. However,
building resistance: The verifier will not have access to the prover does not need to explicitly store any key, rather
the raw CRP database of the PUF of the prover node. the secret is generated from the response of a PUF which is
This is to ensure that if the verifier gets compro- embedded in the device.
mised, no one should be able to mathematically
clone the PUF instances using the CRP databases. 3.2 Public Key Based Protocols
 Unlimited authentications: The protocol will have mod- Authentication and key exchange have been traditionally
erate input-output space and can have unlimited handled by the use of public key encryption. The two con-
authentication rounds repeating same challenges. ventional ways of handling encryption is by the use of Public
 Security association mapping for CRPs: A mapping is Key Infrastructure (PKI) or by the use of Identity Based
done between the challenge and response for each Encryptions (IBE). In [19], new protocols have been pro-
entries in the CRP database so that it can be stored posed for the IP protection problem on FPGAs using PUFs
publicly in a resourceful device ensuring its integ- and PKI based public key cryptography. But PKI has been
rity. The verifier can access it at the time of authenti- plagued with several shortcomings of non-uniform stand-
cation without any advantages to the attacker. ards, and most importantly the difficulty of handling certifi-
 Efficient management of public/ private keys without cen- cates generated by a trusted third party, virtually making it
tral authority: There is no need to involve central cer- infeasible for IoT applications where billions of devices are
tificate authority to sign the public keys. A verifier expected to communicate. As an alternative, identity based
can easily verify the public key of the prover as it encryptions are attractive as they provide a mechanism for
holds information derived from the PUF instance of generating public keys from publicly known information.
the prover. The public-private key should be suitably However, in classic IBE the secret keys of a node are not tied
tied to the PUF instance of the node, and that serves to its physical identity, and the proof of identity is usually in
as the root of trust. the form of a password or a digital certificate that include a
user’s public key. Moreover, some of these secrets need to be
3 ALTERNATIVE APPROACHES AND RELATED explicitly stored in the nodes. Further, classic IBE requires a
WORK Public Key Generator (PKG) which is used to generate pri-
vate keys for the nodes and transfer through secured chan-
In this section we discuss conventional protocols and their nels. This makes the key exchange unwieldy and difficult for
shortcomings for authentication and key exchange among real life deployment for the scalability of IoT applications. In
the nodes of an IoT system. [20], Wallrabenstein has proposed to use PUF based Elliptic
Curve Cryptosystem for IOT framework, but storing helper
3.1 PUF Based Protocols data for each challenge in the node can lead to unacceptable
Several lightweight PUF-based authentication protocols [6], memory overhead in resource-constrained devices.
[7], [8], [9], [10], [11], [12], [13], [14], [15], [16] have been In the proposed protocol, we have blended IBE with
proposed in the past. But in[17], the authors demonstrated identity generated by the PUF embedded in a node. It leads
several vulnerabilities such as Denial-of-Service (DoS) to a certificate-less protocol, where no explicit keys need to
attack, synchronization problem, replay attack, token/ be stored in the nodes, while IBE provides security based
server impersonation, modelling attack, lack of integrity on strong well-founded hard problems. The key exchange
checking of the helper data, compromise of code and data at in the proposed protocol is made seamless by allowing the
runtime, limited local authentication, single point of failure nodes with the PUFs generating its keys, while the verifier
that have made these protocols unacceptable in their origi- simply checks its authenticity and passes a verified public
nal form. The mutual authentication protocol proposed in key to another node for further communications.
[18] has considerable hardware overhead; hence, it is not Security of Commercial IoT Appliances. Surprisingly, even
suitable for resource-constrained devices. Moreover, in with the growing importance of security, several IoT appli-
most of the PUF based authentication schemes, a verifier ances have very little to no support for it. As a use-case, in
node granting authenticity to a prover node, has prior this paper we study video surveillance cameras, which are
access to a subset of CRP database or a model of the PUF considered as a very popular IoT application. Till now,
instance embedded at the prover node. Now, if we map this several passive and active attacks [21], [22] such as visual
setup in a hierarchical network of IoT framework, it may layer attacks, abusing covert channel and data ex-filtration
expand the attack surface substantially, as the integrity of attacks, jamming, Denial-of-service, and side channel
CRP details at lower level nodes may get compromised due attacks have been proposed for video surveillance system.
to easy accessibility. Hence, we cannot adopt any of these As a countermeasure, many public key infrastructure based
protocols in its current form. user authentication protocols[23], [24] were proposed in
CHATTERJEE ET AL.: BUILDING PUF BASED AUTHENTICATION AND KEY EXCHANGE PROTOCOL FOR IOT WITHOUT EXPLICIT CRPS IN... 427

Fig. 1. Hierarchical IoT architecture and proposed secure communication mechanism.

literature. However the fact remains that many network- databases (KEYDBs) (marked as ‘1’). To resist against
enabled camera vendors do not use data encryption, to modelling attack of the PUF instance, the CRPDBs and
increase the throughput and to decrease memory and KEYDBs are assumed to be stored in a secure “offline” data-
power footprint. Additionally, some of the current video base in a trusted environment, outside the reach of the
streaming protocols such as RTP, RTSP and video steaming typical IoT “node-to-node” communication. These database
engines such as WOWZA, Mjpg-Streamer etc. do not even entries are never directly used for authentication.Next, each veri-
support secure network protocols such as SSL. This inspires fier node is assigned to authenticate a set of IoT prover
us to develop PUF based authentication and key exchange nodes. In Security Association Generation Process a security
protocol which will ensure the device authentication irre- relationship mapping between IoT node and verifier node is
spective of the security level of the network protocol running on it. created (marked as ‘2’) using each CRP entry of the prover
node, the secret key associated with its corresponding veri-
fier node and some randomly selected entities by the SCG.
4 PROPOSED AUTHENTICATION AND KEY It hides the challenge-response correlation of the PUF
EXCHANGE PROTOCOL instance. These mapping entries are stored in Mapping
In this section, we describe the authentication and key Databases (MAPDBs) in the SAP maintained outside the
exchange protocol that can be suitably implemented in an trusted environment. MAPDBs are generated in such a way
IoT infrastructure. Fig. 1 represents the functional blocks of that access to this database would not help the adversary to
the proposed security architecture. The architecture consists model the PUF instance, and the integrity of the entries are
of four major components: the Security Credential Genera- maintained so that the trusted party can verify any illegitimate
tor (SCG), the Security Association Provider (SAP), the Veri- modification during the protocol execution.In the Authentication
fier Node and the IoT Node. The IoT nodes, which play the and key exchange phase, the verifier uses challenges randomly
role of prover, reside at the lowest level of the architecture. selected from MAPDBs and validates responses from the
In our proposal, we assume these IoT nodes to be PUF- prover node dynamically at the time of protocol execution.
enabled, and having low hardware and software footprint The protocol is designed in a way that both the prover and the
verifier mutually authenticate each other. Finally, the verifier
and limited computational abilities. They prove their
node coordinates among different prover nodes for genera-
authenticity using respective embedded PUF instances to
tion and sharing of public keys (marked as ‘3’).
the immediate upper layer nodes, which play the role of ver-
ifier and are relatively resourceful.
4.1 Public Mathematical Parameters
The proposed protocol has two main phases, enrolment
Our scheme requires that the communicating parties must
phase and authentication & key exchange phase. The Enrol-
agree on some mathematical parameters before initiating
ment phase consists of two sub processes and executes in a
communication. For some large prime value q, we define an
secure and trusted environment. Once the manufacturing of
elliptic curve and generate three groups G1 , G2 and G3 on
the verifier and IoT prover nodes are done, the SCG exe-
the points of an elliptic curve to define cryptographic pair-
cutes a Provisioning Process. In this process, the characteriza-
ing. Pairing is an admissible bilinear map e: G1  G2 ! G3
tion of the PUF instance is done for each of the IoT nodes
which satisfies the following three properties:
and stored in CRP databases (CRPDBs). Similarly, a ran-
domly selected secret key is assigned for each verifier and 1) Bilinearity: 8a; b 2 Fq ; 8P 2 G1 ; Q 2 G2 : eðaP; bQÞ ¼
stored in the NVM of the verifier as well as the key eðP; QÞab .
428 IEEE TRANSACTIONS ON DEPENDABLE AND SECURE COMPUTING, VOL. 16, NO. 3, MAY/JUNE 2019

Fig. 2. Enrolment phase of the proposed protocol.

2) Non-degeneracy: eðP; QÞ 6¼ 1. At the end of the enrolment phase for a given node A, the Veri-
3) Computability: There exist an efficient algorithm to fier S supervising it will have only the secret key. For authenti-
compute e. cation, the SAP will transfer an entry randomly from the
For further details, please refer to Section 2 of [25]. We mapping database of the node A to the Verifier S. The Verifier
also need to choose three secure cryptographic hash func- S will calculate the response of the PUF on-the-fly to authenti-
tions: H1: f0; 1gn ! G1 , H2: f0; 1gn  f0; 1gm ! G2 , H3: G2 ! cate node A. Here, we have assumed that the Verifier S will
f0; 1gn , where n and m are the bit lengths of the PUF securely store the secret key for the keyed hash function in a
response and secret key, respectively, in our context. So, the non-volatile memory. We can achieve this goal using the com-
public mathematical parameters are: < q, G1 , G2 , G3 , e, n, mercially available tamper-proof NVM chips, e.g., those used
H1 , H2 , H3 > . in Trusted Platform Module (TPM) [26].

4.2 Enrolment Phase 4.3 The Authentication and Key Exchange Phase
Before deploying the nodes in the communication network, The second phase of this protocol performing authentica-
the enrolment phase is executed for each node in a secure tion and key sharing is described below as shown in Fig. 3.
and trusted environment. The steps are shown in Fig. 2, and Consider a situation where IoT node A wishes to communi-
are summarized as follows: cate with IoT node B, with both A and B being at the lowest
levels of the hierarchy.
 In the provisioning process, the SCG first randomly
selects an m-bit key KS and assigns it to the NVM of  At first, IoT node A initiates a request < IDA ;
Verifier S. It also stores KS in the KEYDBs. IDB > (i.e., the public identifiers of the two com-
 Then it sends a random challenge CA to the IoT Node municating nodes) to Verifier S for authentication.
A. Node A applies the challenge CA to its PUF, and Verifier S forwards the request to the SAP.
generates the output RA ¼ PUF ðCA Þ, and returns it  The SAP randomly chooses an entry < CA ; CS ;
to the SCG. HLPA ; a; B; d1 > from MAPDBAS and sends it back
 The SCG generates the helper data HLPA ¼ BCH to the Verifier S.
EncoderðRA Þ and stores it along with the challenge  Now, the Verifier S performs the following computa-
and response by appending < CA ; RA ; HLPA > to its tions:
CRPDBs. PS ¼ H2KS ðCS Þ:
 Next, in Security Association Generation Process, the
SCG randomly generates an n-bit challenge CS , and  If d1 ¼¼ H3ðH1ðCA jjCS jjHLPA jjajjH3ðPS ÞÞ þ BÞ, then
then it calculates it calculates
PS ¼ H2KS ðCS Þ; PA ¼ H1ðRA Þ: PA ¼ a  PS þ B:
Then, the SCG randomly selects an element a from It can be noted that if the Verifier S gets compro-
Zq and calculates mised, it can impersonate as Node A. To avoid this
scenario, we suggest to use Strong PUFs and the
B ¼ PA  a  PS ; mapping entry used for an authentication round is
d1 ¼ H3ðH1ðCA jjCS jjHLPA jjajjH3ðPS ÞÞ þ BÞ: deleted from MAPDBAS .
def
 Next, the Verifier S randomly chooses a value x such
Please note that Zq ¼ fx 2 Zq : gcdðx; qÞ ¼ 1g i.e., that x 2R Zq and computes
elements of Zq with multiplicative inverses. In this
way, a new tuple < CA ; CS ; HLPA ; a; B; d1 > is gen- QA ¼ PA þ x  PS þ H1ðIDA jjIDB Þ;
erated and stored in the MAPDBs of the Security VA ¼ eðPA ; x  PS Þ;
Association Provider. This procedure is repeated
according to the memory capacity of the SAP and and sends this value to node A as the tuple
the SCG and for all IoT nodes under Verifier S. < IDB ; CA ; HLPA ; QA > . Please note that the nonce
CHATTERJEE ET AL.: BUILDING PUF BASED AUTHENTICATION AND KEY EXCHANGE PROTOCOL FOR IOT WITHOUT EXPLICIT CRPS IN... 429

Fig. 3. The authentication and key exchange phase.

x is used to resist the replay attack and also acts as a  Since node A wishes to communicate with node B, it
timestamp for that specific instance of the protocol needs the Verifier S to authenticate node B. Hence,
run. Generally it is very hard to mitigate DoS attacks the Verifier S follows a similar procedure for node
at protocol level [27]. But in proposed protocol, we B as described above to authenticate node B, and
took two approaches from the verifier and the node’s accepts its public key KBPUB upon successful
perspective. As the authentication request initiation authentication. Finally, it sends node A the tuple
is done by the node, it can keep track of exactly how < KBPUB ; QB ; YB ; H3ðH1ðPA ÞjjH1ðKBPUB ÞjjH1ðQB Þjj
many requests have been sent by it. In case, it is H1ðYB ÞÞ > . On receiving it, if node A finds that
flooded with challenge requests, then it can tempo- H3ðH1ðPA ÞjjH1ðKBPUB ÞjjH1ðQB ÞjjH1ðYB ÞÞ equals
rarily shut down the protocol execution and can opt H3ðH1ðPA0 ÞjjH1ðKBPUB ÞjjH1ðQB ÞjjH1ðYB ÞÞ, then the
for approaches such as exponential back-off algorithms Verifier S is authenticated, as only the Verifier S can
which is used for network congestion avoidance. On retrieve the value of PA using PS , and node A accepts
the verifier side, the timestamp x is used to keep the public key of node B.
track that currently which nodes are executing the
protocol. Hence if new requests come for the same
5 SECURITY ANALYSIS
pair, it can immediately rejects them. This way the
frequency of each request type can be limited. Next we will describe two different attack models in which
 On receiving the message, node A first applies CA to we will analyze the security of the proposed authentication
its PUF instance PUFA and get the response Ractual . and key exchange protocol.
 Next using helper data HLPA and Ractual in
BCH Decoder, it retrieves the corrected response 5.1 Session-Key Security
Rcorrected . The definition of Session-Key Security (SK security) is based
 It calculates the following: on the approach called “security by indistinguishability”.
To elaborate, this approach evaluates the security of a cryp-
PA0 ¼ H1ðRcorrected Þ; tographic system as follows. Suppose, two games Game1
PS0 ¼ QA  PA0  H1ðIDA jjIDB Þ; and Game2 are constructed in which the adversary commu-
VA0 ¼ eðPA0 ; PS0 Þ: nicates with the protocol under consideration. If no feasible
adversary can distinguish between whether she is interact-
 Next, node A randomly chooses two values t and YA ing with Game1 or Game2 , then the protocol is said to be
such that t 2R Zq and YA 2R G1 . Then it computes indistinguishable and secure. Further, in order to ensure
the public and private key pair that the proposed cryptographic scheme is secure against
differing capabilities of the attacker, usually two adversarial
KAPUB ¼ t  QA ; KAPRV ¼ t  YA ; models are considered:

and it sends the Verifier S the tuple < VA0 ; KAPUB ;  The Unauthenticated-link Adversarial Model (UM):
YA ; H3ðPS0 þ KAPUB ÞjjH3ðYA Þ > . Here, a probabilistic polynomial-time (PPT) attacker
 If VA equals VA0 and H3ðPS0 þ KAPUB ÞjjH3ðYA Þ equals is considered who has full access/control over the
H3ðx  PS þ KAPUB ÞjjH3ðYA Þ, the Verifier S accepts communication links, along with the scheduling of
node A as an authenticated device, and accepts its all protocol events such as initiation of protocols and
public key. message delivery.
430 IEEE TRANSACTIONS ON DEPENDABLE AND SECURE COMPUTING, VOL. 16, NO. 3, MAY/JUNE 2019

 The Authenticated-link Adversarial Model (AM): In this the Decisional Uniqueness Problem Assumption is that the
case, the attacker is restricted to only deliver mes- ensemble of tuples of type ðC; PUFAdv ; zÞ is computationally
sages truly generated by the parties without any indistinguishable from the ensemble of tuples of type
change or addition to them. ðC; PUFAdv ; PUFN ðCÞÞ.
We prove that our protocol is secure against UM, which in The second important security assumption is the compu-
turn ensures that the protocol is secure against AM. tational infeasibility of the Elliptic Curve Discrete Logarithm
Consider the following experiment under UM: the Problem (ECDLP):
attacker L chooses to attack a session under test, and let k be
Definition 4 (Elliptic Curve Discrete Logarithm Prob-
the shared session key of the session. A random coin tossing
lem). Let EðKÞ be a discrete elliptic curve over a finite field K;
is performed, with its result encoded as a bit b. If b ¼ 0, the
let there exist points P; Q 2 EðKÞ such that Q 2 <P> , where
value k is given to the attacker L, otherwise a random value r
P is a primitive point (capable of generating any arbitrary
is chosen from the probability distribution of keys generated
point on EðKÞ), and < P > denotes the set of points generated
by the protocol. The attacker outputs a bit b0 at the end.
by adding P to itself k times, for some integer k. The ECDLP
Definition 1 (Session Key Secure (SK-Secure) Protocol). problem is to find the value of the scalar multiple k, given P
A key-exchange (KE) protocol p is called SK-secure if the fol- and Q. ECDLP is considered computationally intractable at the
lowing properties hold for any KE-adversary L in the UM: current state-of-the-art for proper choices of the curve EðKÞ.
(1) Protocol p satisfies the property that if two uncor-
5.1.2 Correctness Proof of the Proposed Scheme
rupted parties successfully complete a session then
they both output the same key, and, We consider a setting with two parties, IoT node A and the
(2) the probability that L guesses correctly the bit i.e., Verifier S monitoring the authentication procedure of node
b0 ¼ b is more than 12 by only a negligible quantity. A. We denote the protocol by p. Recall that node A and the
verifier contain PUF instance PUFA and a secure NVM stor-
ing KS . Moreover, let outputnodeA;p ðIDB ; CA ; HLPA ; QA Þ and
5.1.1 Security Assumptions
outputS;p ðCA ; CS ; a; BÞ denote the respective outputs of
As mentioned previously, there are two security assump- node A and the Verifier S. We assume that this output takes
tions at the foundation of the secure communication proto- the form of an element of G3 that is supposed to be consid-
col proposed. The first security assumption is the physical ered as the identity of node A, and should be shared by
and mathematical unclonability of PUFs by a polynomial-time node A and the verifier. Hence
algorithm, which implies that it is computationally infeasible
to construct the challenge-response mapping of an arbitrary outputnodeA;p ðIDB ; CA ; HLPA ; QA Þ
PUF instance. Although most PUF variants are physically ¼ eðH1ðBCH DecoderðPUFA ðCA Þ; HLPA ÞÞ;
unclonable at the current state-of-the-art (a notable QA  H1ðBCH DecoderðPUFA ðCA Þ; HLPA ÞÞ
exception being the successful effort of SRAM PUF H1ðIDA jjIDB ÞÞ;
cloning reported in [28]), successful mathematical modeling
(“model-building attacks”) have been widely reported [29]. and
However, by choosing relatively secure PUF variants such
as Lightweight Secure PUF or XOR PUF [29], we can avoid outputS;p ðCA ; CS ; a; BÞ
both physical and mathematical cloning in practice. This ¼ eða  H2KS ðCS Þ þ B; x  H2KS ðCS ÞÞ:
security assumption is formalized in the definitions below:
Next, we present the definition of the correctness require-
Definition 2 (Decisional Uniqueness Problem (DUP) ment. It states that, except with negligible probability, node
for PUF). Given an n-bit output of an arbitrary PUF instance A and the Verifier S will generate the same identity, and
PUFAdv , a challenge C and an n-bit string z 2 f0; 1gn , the only node A will be authenticated to the Verifier S.
DUP aims to decide whether z ¼ PUFN ðCÞ for a PUF instance
Definition 5 (Correctness of Protocol). A protocol p for
PUFN , or a random n-bit string.
authentication and key exchange is denoted as correct if there
Definition 3 (Decisional Uniqueness Problem Assump- exists a negligible function neglðÞ, such that for every possible
tion). The problem of fabricating a PUF instance PUFN using value of n
another instance PUFAdv is hard, and for all probabilistic, poly-
Pr½outputnodeA;p ðCA ; HLPA ; QA Þ
nomial time algorithm A, there exists a negligible function
neglðÞ such that 6¼ outputS;p ðCA ; CS ; a; BÞ4neglðnÞ:

It can be observed that

j Pr½AðC; PUFAdv ; zÞ ¼ 1
eða  H2KS ðCS Þ þ B; x  H2KS ðCS ÞÞ ¼ eðPA ; x  H2KS ðCS ÞÞ
Pr½AðC; PUFAdv ; PUFN ðCÞÞ ¼ 1 j 4neglðnÞ:
¼ eðH1ðBCH DecoderðPUFA ðCA Þ; HLPA ÞÞ; QA  H1
where n is the number of response bits of the PUF instance. ðBCH DecoderðPUFA ðCA Þ; HLPA ÞÞ  H1ðIDA jjIDB ÞÞ:

This implies that given an arbitrary challenge C and an This means that node A and the verifier will output the
arbitrary PUF instance PUFAdv , the adversary A behaves same value, thereby proving the correctness of the scheme.
almost identically, for a random element z 2 f0; 1gn , and the It may be noted that the rationale for the choices of the
actual n-bit response PUFN ðCÞ. Another way of interpreting public and private keys are based on [1]. The exact
CHATTERJEE ET AL.: BUILDING PUF BASED AUTHENTICATION AND KEY EXCHANGE PROTOCOL FOR IOT WITHOUT EXPLICIT CRPS IN... 431

description of the encryption process is beyond the scope of

the present work, but for the sake of completeness,
we would like to sketch that for encryption. For a
random string w, the node A can compute, a string
 ¼ eðKBPUB ; YB Þw ¼ eðt  QB ; YB Þw =eðQB ; YB Þtw , which can
be used to confide a message to be sent to node B. The
encryptor sends a hint for w to node B, which is w  QB . The
decryptor node B using the hint and its private key can
compute this string by calculating eðw  QB ; KBPRV Þ=
Fig. 4. The view of Authadv;p when it is run as a sub-routine of B ( [30]).
eðw  QB ; t  YB Þ=eðQB ; YB Þtw =. This explains briefly the
choices for the public and private keys in the proposed key
Let us assume that the adversary Adv has some non-
exchange protocol.
negligible advantage " in breaking the protocol p. Then we
can construct an algorithm B which will have the same
5.1.3 Security Proof of the Proposed Scheme advantage " in breaking the Uniqueness problem. Now,
From the security perspective, an authentication and key the algorithm B takes as input a random Uniqueness Prob-
exchange protocol is secure if the output VA generated by lem tuple ðCA ; PUFAdv ; zA Þ (where zA ¼ PUFA ðCA Þ or one
node A and the verifier are identical, and no adversary can random string belongs to f0; 1g ) and proceeds as follows:
correctly guess VA for the challenge < CA ; CS ; HLPA ;
a; B; d1 > and x chosen randomly. This has been formu- (1) SetUp: Provide Adv with PUFAdv .
lated by giving an adversary the values < CA ; CS ; HLPA ; (2) Input tuple:
a; B; d1 > from a protocol execution, and observing (a) First it randomly chooses PS and x.
whether she can distinguish between VA generated by node (b) It calculates PA ¼ H1ðzA Þ.
A, and the verifier, or a completely random element of G3 . (c) Then it calculates
We would show that breaking the proposed protocol is at
QA ¼ PA þ x  PS þ H1ðIDA jjIDB Þ:
least as difficult as solving the Decisional Uniqueness Prob-
lem for PUFs, i.e., a successful attack on the proposed proto- (d) Then sets z ¼ < CA ; CS ; HLPA ; a; B; QA ; IDA ;
col implies a feasible solution to the Decisional Uniqueness IDB > , which is perfectly random to the
Problem for PUFs. In order to demonstrate this, an experi- adversary Adv.
ment has been presented next. (e) Next, it randomly chooses b 2 f0; 1g.
Let Adv be a probabilistic, polynomial time adversary, and (f) It then calculates VAb ¼ eðPA ; x  PS Þ and
the number of PUF response bits be n. Then, consider the fol- VA1b ¼ h 2R G3
lowing experiment: (g) The algorithm B finally provides Adv the input
The Eavesdropping Authentication and Key Exchange Experi- tuple < z; VA0 ; VA1 > . If zA ¼ PUFA ðCA Þ ,
ment Authadv;p ðn; z; PUFAdv ; VA0 ; VA1 Þ : then VAb will be equal to eðPA ; x  PS Þ and it
1) The adversary Adv is provided: will be a valid input tuple. Otherwise, VA0 ; VA1
a) A PUF instance PUFAdv and z= < CA ; CS ; HLPA ; both will be some random element of G3 .
a; B; QA ; IDA ; IDB > where QA ¼ ðða  H2KS ðCS Þþ
(3) Guess: The adversary Adv returns b0 , a guess of b. If
BÞ þ ðx  H2KS ðCS ÞÞÞ þ H1ðIDA jjIDB Þ. b ¼ b0 , then the algorithm B returns 1, implying
b) Two identities VA0 and VA1 , calculated based on a that zA are the correct responses of CA . Otherwise,
chosen random bit b 2 f0; 1g it returns 0.
Hence, it is proved that the adversary Adv has the same
VAb ¼ eða  H2KS ðCS Þ þ B; x  H2KS ðCS ÞÞ advantage " as the adversary B. But, due to the hardness
of Uniqueness Problem, " should be negligible (please refer
VA1b ¼ h 2R G3 : to Fig. 4). Hence
2) The adversary Adv will output a value b0 . If b ¼ b0 , the 1
Pr½Authadv;p ¼ 14 þ neglðnÞ:
adversary Adv succeeds in the experiment. 2
u
t
Next we prove the following theorem.
Once the authentication is done successfully, node A
Theorem 1. The authentication and key exchange protocol p is selects a random value t 2R Zq . Then, it locally calculates
secure in the presence of eavesdropping adversaries if the Deci- {public,private} key pair K1PUB ¼ t  QA and K1PRV ¼ t  YA .
sional Uniqueness Problem Assumption holds. It keeps K1PRV secret and sends K1PUB to the verifier over
Proof. To prove this, we show that the protocol p is secure if the authenticated link. Now assuming the complexity of the
the adversary succeeds in the experiment Authadv;p with Computational Discrete Log Problem, the probability that the
probability that is at most negligibly greater than 12, i.e., adversary Adv can retrieve the value of t from K1PUB , know-
for every probabilistic polynomial time adversary Adv, ing the value of QA is negligible. Hence the adversary Adv
there exists a negligible function neglðÞ such that fails to calculate the correct value of private key K1PRV .If we
consider the AM adversarial model, the adversary Advis
1 restricted to only deliver messages truly generated by the par-
Pr½Authadv;p ¼ 14 þ neglðnÞ: ties without any change or addition to them; hence she fails to
2
calculate the private key of node A. On the other hand, in the
432 IEEE TRANSACTIONS ON DEPENDABLE AND SECURE COMPUTING, VOL. 16, NO. 3, MAY/JUNE 2019

UM adversarial model, any change in the message sent over exchange information after each message or output
the channel will end up with difference in the hashed value generated by a party running the protocol. The envi-
of the message at the data node and sever node. From the ronment E also has the permission to apply inputs to
result obtained in the previous theorem, we conclude that: the communication parties, and collect outputs from
based on the complexity assumption of the Computational Discrete them. But the environment E is constrained to collect
Log Problem, Decisional Uniqueness Problem and that the hash outputs of the main program running in each party,
function is collision resistant, the authentication and key-exchange and not the output from the subroutines called from
protocol p is SK-secure in AM as well as in UM model. that main program.
Hence, DUP ^ ECDLP ! p is SK-secure. 6) A protocol p securely realizes the task f if p emulates
the ideal process F , i.e., if there exists an adversary
) p is not SK-secure ! : DUP _ : ECDLP:
L which attacks protocol p, there also exists a
Additionally, the protocol is designed in such a way that “simulator” S that achieves similar adversarial effect
both prover and the verifier mutually authenticate each by interacting with the ideal process F . In addition,
other. If an legitimate node A tries to impersonate as no environment E can tell with non-negligible proba-
another legitimate node B under the same verifier using the bility of success whether it is interacting with L and
same challenge set < CA ; CS > , it will fail to do so. As the p, or with S and F for f.
PUF’s response does not depend on the value of KS and it
is only used regenerate the response, use of the same for 5.2.1 UC Security of the Proposed Key Exchange
two different nodes will not lead to masquerading attack. The Phase
proof is similar to that given above. Furthermore, SAP is a The main concept of asymmetric key exchange ideal func-
database holding the mapping entries. These entries (in tionality F AKE is that: if both the communicating parties are
MAPDB) are already encoded by Security Credential Gener- honest, the functionality provides them with two random
ation process (refer to Section 4.2) and kept publicly. Only identities, which is written directly to the party’s input tape.
legitimate nodes can interpret information stored in a The adversary cannot have access to the tape, hence the val-
MAPDB entry. Hence SAP does not need to authenticate ues are invisible to her. If one of the communicating parties
the verifier. Next, we prove the compatibility of the scheme is corrupt, then the adversary can easily determine the iden-
with the universal composability framework. tity of the corrupt party. F AKE is parameterized by an inte-
ger N (the total number of permissible sessions), where a
5.2 Universal Composability Framework verifier runs with exactly t data nodes and the simulator S.
The basic objective of Universal Composability (UC) framework The working principle of F AKE has been shown the Fig. 5.
is to guarantee that any key exchange protocol provides the Next we prove the security of F AKE .
same security for any other protocol which wants to set up
Theorem 2. Protocol p securely realizes functionality F AKE .
session keys between two parties, even when it runs in
parallel with an arbitrary set of other protocols in a dis- Proof. Here we assume that (a) the adversary possesses a
tributed communication network. We prove that the PUF instance; (b) queries to the PUF are genuinely handed
method of key exchange as proposed in this work is also on to the simulator S’s PUF, and (c) the PUF’s answers are
compatible with similar composability properties. It fol- forwarded unmodified to the querying party throughout
lows the approach referred as “security by emulation of all the simulations. We consider different usage and secu-
an ideal process”. The primary concept of this principle is rity scenarios in turn.
as given below [4]: Case-1: Verifier and Node A are Honest.
1) The model of protocol execution consists of the com-  Setup: Whenever the functionality F AKE receives
municating parties running the protocol and the message (establish-sessionAKE ; sid; Node A; Verifier)
adversary. They are further considered as interacting for the first time, the simulator S queries the
computing elements and modeled as Interactive PUF instance PUFA for k random challenges
Turing Machines (ITMs). C1 , C2 ; . . . ; Ck , and obtains responses RA1 ,
2) We formulate an “ideal process” F that picks up the RA2 ; . . . ; RAk . Then, it creates a list LA of k chal-
task f of the desired functionality. lenge-response pairs.
3) In the ideal process F all communicating parties pro-  It then hands over PUFA to node A.
vides inputs to an “idealized trusted party” which  On receiving a message (establish-sessionAKE ; g
locally performs the task, and sends each party its sid; Node A; Verifier), F AKE increments p by
desired output. In this regard, it is the formal specifica- one and the simulator S sends (deliverAKE ; sid;
tion of the security requirements of the task. Verifier) to F AKE .
4) Additionally, a new algorithmic object, called the  F AKE then sends (deliverAKE ; sid; VA ; Verifier)
“environment machine” E, is added in this computa- to the verifier.
tional model, which is considered to consist of every-  Now the simulator S is activated again and it sim-
thing external to the current protocol execution, such ulates that the verifier sends (IDB ; CA ; HLPA ; QA )
as other protocol executions and their adversaries, to node A.
human users, etc.  When the adversary L instructs to send the latter
5) The adversary L can directly interact with E message to node A, the simulator S sends
throughout the execution of the protocol. They can (deliverAKE ; sid; VA ; Node A) to F AKE .
CHATTERJEE ET AL.: BUILDING PUF BASED AUTHENTICATION AND KEY EXCHANGE PROTOCOL FOR IOT WITHOUT EXPLICIT CRPS IN... 433

Fig. 5. The asymmetric key exchange ideal functionality.

 The probability that the value of eðH1ðBCH  Hence in this case the ID provided by F and the
DecoderðPUFA ðCA Þ; HLPA ÞÞ; x  H2KS ðCS ÞÞ is equal identity calculated from the challenges given by
to VA is negligible (as proved in Section 5.1.3). the server is same.
 But node A later chooses a random value t 2 Zq
Case-2: Verifier is Corrupt. after getting the VA , and calculates the public and
private keys using them. Hence, the simulator S as
 The simulator S let Verifier to instantiate PUFA ,
well as the adversary L cannot guess the asymmet-
and hands it over to node A.
ric key pairs for node A. This is due to fact that the
 When the adversary L instructs to deliver message
security of elliptic curve cryptography rests on the
(IDB ; CA ; HLPA ; QA ), then the simulator S can eas-
assumption that the elliptic curve discrete loga-
ily evaluate VA ¼ eða  H2KS ðCS Þ þ B; x  H2KS ðCS ÞÞ, rithm problem (ECDLP) is hard. Now as node A
as the server is corrupt. But it is to be noted that S randomly selects the value of t and QA ; YA are the
does not have access to KS . It can only get the final points on the elliptic curve, it is assumed to be
value of VA (refer to 5th point of Section 5.2). hard to predict the value of t by the simulator S
 It next sends (choose  valueAKE ; sid; Node A; and the adversary L. So, we can say that even if the
Verifier; VA ) to F AKE as it has already calculated server gets corrupted for a limited time, the keys
the value of VA and F increments the value of p of the legitimate users are not compromised which
by one. in turn ensures that the data communicated
 Finally, S sends the messages (deliverAKE ; sid; between two nodes cannot be retrieved by the
VA ; Node A) to F AKE . corrupted server.
434 IEEE TRANSACTIONS ON DEPENDABLE AND SECURE COMPUTING, VOL. 16, NO. 3, MAY/JUNE 2019

Fig. 6. Attack on video surveillance system and protection against it: (a) and (b) show the successful attack in the absence of PUF based authentica-
tion mechanism, while (c) and (d) show the prevention of the attack in the presence of the proposed PUF based authentication system.

Case-3: Node A is Corrupt. intercepts the network traffic to launch “man-in-the-middle

This case covers the situation if a party willingly attack” and “replay attack”, to potentially modify the infor-
hands over its PUF to the adversary L. So, in this case, mation received at the receiver. To prevent this, the camera
we show that the adversary L can easily retrieve the in conjunction with an embedded board and a PUF mapped
value of private key for that particular party. on a FPGA emulates as an IoT node. The scenario is illus-
 The set up phase is same as given in Case-1. trated in Fig. 6. The off-the-shelf hardware components
 On receiving a message (establish  sessionAKE ; used in the setup are: an Intel Edison embedded develop-
sid; Node A; Verifier), the simulator S incre- ment platform, a Digilent Nexys-4 FPGA board containing
ments p by one and sends (choose  valueAKE ; Xilinx Artix-7 FPGA, and a Logitech HD UVC camera as
sid; Node A; Verifier; VA ) to F AKE . shown in Fig. 7.
 It is activated again and sends (deliverAKE ; sid; In general scenario, the Logitech camera is connected to
Verifier) to F AKE . Intel Edison Board through a USB interface to form an IoT
 Verifier writes the VA on its local tape and S is node. An mjpg-streamer software is run on the Edison
activated again. board to capture video using the camera, and send to a PC
 It simulates the verifier sending (IDB ; CA ; HLPA ; (the receiver) through WiFi. The PC then displays the
QA ) node A. received video in a web browser using the IP address of the
 When the adversary L instructs to deliver the lat- Edison board. Next, we use the hacking software tools
ter message to node A, S sends (deliverAKE ; sid; enabled by Kali Linuxand perform the following steps:
VA ; Node A) to F AKE .
 If Node is corrupted, then L can easily find out  First, the attacker finds out the IP address of the Edi-
the random value chosen from Zq for calculating son board from the network ARP table using the arp
the private and public keys, and hence the value command.
of the private keys are compromised.  The video packets are then sniffed using IP forward-
Hence, the scheme securely realizes the ideal function- ing and ettercap tool and saved in the attacker’s
ality F AKE . u
t machine using the driftnet tool.
 The attacker starts scanning the network in monitor
6 EXPERIMENTAL SETUP AND RESULTS mode to get the router’s BSSID and associated clients
using the airmon-ng and airodump-ng tools.
In this section, we describe an experimental evaluation of
 Next, it de-authenticates the Edison board from the
the effectiveness of the protocol on an IoT testbed, including
network using the deauth option in the aireplay-ng
the incurred hardware and performance overheads.
tool. Once this is done, the video stream stops at
6.1 Attack Scenario and Experimental Setup PC’s end for a short interval of time.
We consider a scenario whereby a video camera transmits  Then, the attacker spoofs the IP address of the Edi-
unencrypted captured video over a network. An adversary son board and starts streaming the pre-captured
video using the same mjpg-streamer tool.
 Now, the receiver PC actually gets data from the
attacker’s computer, which can either be a replayed or
modified version of the video stream captured earlier.
To prevent this, we have adapted the idea of Double Arbiter
PUF [32], designed a 5-4 DAPUF as shown in Fig. 8 and imple-
mented it on Xilinx Artix- 7 FPGAs. The 5-4 DAPUF comprises
of five 64 bit Arbiter PUF instances. Each APUF instance
consists of two identical delay paths, and let us denote the out-
puts of top and bottom paths as Pi;T and Pi;B , respectively,
Fig. 7. Experimental setup for smart IoT node. where i ¼ 1; . . . ; 5. For i 2 f1; . . . ; 5g and j 2 fi þ 1; . . . ; 5g, an
CHATTERJEE ET AL.: BUILDING PUF BASED AUTHENTICATION AND KEY EXCHANGE PROTOCOL FOR IOT WITHOUT EXPLICIT CRPS IN... 435

Fig. 8. Architectural overview of 5-4 DAPUF. It generates 4-bit output (r0, r1, r2, r3) to a given challenge, and ri depends on the outputs of five conse-
cutive arbiters.

arbiter ArbiterðPi;T ; Pj;T Þ is instantiated, where the inputs to the Then probability of false negative for one protocol run is =
arbiter are top paths of ith and jth APUFs. The process is ½1  0:98 = 0.02. If the verifier repeats the protocol run for 3
repeated for the bottom paths. Hence, in total 20 arbiters are times, then the probability of false negative= ð0:02Þ3 = 0.00008,
used in the design. Four 5-input XOR gates are used to generate which is almost zero. Next, the uniqueness of the deployed
4-bit output from the outputs of 20 arbiters, to a given challenge. 5-4 DAPUF is reported as 44.16 percent. The modelling accu-
The Edison board, Artix-7 FPGA and the camera together form racy of the entire 4-bit response of the PUF is approximately
a smart IoT node and can act as a prover. The receiver PC acts 39 percent using 2  105 raw CRPs. Finally Table 1 provides a
as the verifier that can generate and validate the response of the comparative study of hardware and performance overhead
PUF instance, and subsequently authenticate the IoT node. of previously discussed PUF-based authentication protocols
Now, with the modified set up, the system works as follows: with our scheme.For software implementation, we used the
before streaming the video in the web page, the PC first authenti- MIRACL Crypto SDK, which provides a C++ software library
cates the Edison board using our proposed protocol and vali- for elliptic curve cryptography. The specification of the Cocks-
dates the public keys. Later, if the attacker de-authenticates the Pinch curve which has been used for Type 2 Tate pairing is as
Edison board from the network, the video streaming will stop at follows:
PC’s end. Before reloading the web page, the PC again re-
authenticates the device of the video source. This is where the  The curve is non-supersingular.
adversary fails to authenticate herself as she does not possess the  512 bit prime number p=8D5006492B424C09D2FE-
correct PUF instance. BE717EE382A57EBE 3A352FC383E1AC79F21DDB43
706CFB192333A7E9CF644636332E83D90A1E56EFBA
6.2 Experimental Results E8715AA07883483F8267E80ED3
The PUF, BCH encoder and decoder design and implementa-  The equation of the curve is: y2 ¼ x3 þ Ax þ B
tion was performed using Xilinx ISE (v 14.2) design environ- where: A=-3 and B=609993837367998001C95B87A6-
ment. The power consumption of the circuit reported by BA872135E26906DB4C192D6E038486177A3EDF6C5
Xilinx XPower Analyser CAD software tool was 0.044 W. We
have tested the PUF circuit using CME Nano-Bench Top
Chamber (Sl. No. 120433) where 10,000 CRPs of 8 PUF instan-
ces are collected 15 times for the temperature variation from
20 to 80 C keeping the other reliability influencing factors
such as supply voltage unchanged. Fig. 9 shows the reliability
variation of 5-4 DAPUF across the temperatures after error
correction, approximately from 97 to 99 percent. One strategy
that can be taken to distinguish between a false negative and a
true negative is: i) If the authentication passes then it is correct
largely. ii) If the authentication fails, there is a chance that it is
a false negative. In that case, the verifier can repeat for n times.
Let us assume that on average the reliability is 98 percent. Fig. 9. Reliability of DAPUF across temperature variations.
436 IEEE TRANSACTIONS ON DEPENDABLE AND SECURE COMPUTING, VOL. 16, NO. 3, MAY/JUNE 2019

TABLE 1
Hardware, Storage and Execution Time Overhead Comparison with State-of-the-Art PUF Based Protocols

Protocols Hardware Overhead Error Correction Storage per end-to-end

Reported CRP entry execution time
[8] 4454 Slices on FPGA not reported 63 bits not reported
[9] 652 LUTs and 278 registers in FPGA not reported 63 bits not reported
[12] 9207 LUTs and 2921 registers in FPGA not reported 68 bits not reported
[14] 2061 GE in ASIC reported 192 bits not reported
[18] 6034 LUTs and 1724 FFs in FPGA not reported 2112 bits 2.75 secs
[15] 1037 LUTs and 627 registers in FPGA not reported 129 bits not reported
[19] 64kB in SRAM not reported 984 bits not reported
[31] 807 slices, 124 registers and 995 LUTs in FPGA not reported 112 bits not reported
Proposed PUF: 456 slices, 283 registers and 887 LUTs; BCH Encoder: reported 512 bits 480.11 ms
work 41 slices, 35 registers and 19 LUTs; BCH Decoder: 1236
slices, 1615 registers and 685 LUTs in FPGA

0B9BB20DF881F2BD05842F598F3E037B362DBF89F0 REFERENCES
A62E5871D41D951BF8E [1] D. Boneh and M. K. Franklin, “Identity-based encryption from the
 Order q=80000000000000000000000000000000000200 weil pairing,” SIAM J. Comput., vol. 32, no. 3, pp. 586–615, 2003.
01 [2] D. Mukhopadhyay, “PUFs as promising tools for security in inter-
 The pairing uses an embedding degree of k=2, so net of things,” IEEE Des. Test, vol. 33, no. 3, pp. 103–115, Jun. 2016.
[3] D. Lim, J. W. Lee, B. Gassend, G. Edward Suh, M. van Dijk, and
the pairing e(P,Q) evaluates naturally as an element S. Devadas, “Extracting secret keys from integrated circuits,”
in Fp2 . P is a point on the elliptic curve EðFp Þ and Q IEEE Trans. VLSI Syst., vol. 13, no. 10, pp. 1200–1205, 2005.
is a point on E 0 ðFpk=2 Þ, or in this case E 0 ðFp Þ where [4] R. Canetti, “Universally composable security: A new paradigm for
cryptographic protocols,” in Proc. 42nd Annu. Symp. Found. Com-
E 0 is the twisted curve. Using compression the pair- put. Sci., 2001, pp. 136–145.
ing evaluates as an element in Fpk=2 , or just Fp in [5] J. Delvaux, D. Gu, I. Verbauwhede, M. Hiller, and M. M. Yu,
this case. “Efficient fuzzy extraction of PUF-induced secrets: Theory and
We ported our implementations to the Edison platform. Over- applications,” in Proc. 18th Int. Conf. Cryptographic Hardware
Embedded Syst., 2016, pp. 412–431.
all, the executable took approximately 512 kB of memory on [6] B. Gassend, D. E. Clarke, M. van Dijk, and S. Devadas,
the Edison board. The latency overhead incurred running the “Controlled physical random functions,” in Proc. 18th Annu. Com-
end-to-end authentication scheme before the video streaming put. Secur. Appl. Conf., 2002, pp. 149–160.
[7] € urk, G. Hammouri, and B. Sunar, “Towards robust low cost
E. Ozt€
was 480.11 ms on average. These overhead results demon-
authentication for pervasive devices,” in Proc. 6th Annu. IEEE Int.
strates that the proposed protocol can be implemented while Conf. Pervasive Comput. Commun., 2008, pp. 170–178.
incurring acceptable resource and performance overheads. [8] S. Katzenbeisser, U. € Koçabas, V. van der Leest, A. Sadeghi, G. J.
Schrijen, and C. Wachsmann, “Recyclable PUFs: Logically reconfig-
urable PUFs,” J. Cryptographic Eng., vol. 1, no. 3, pp. 177–186, 2011.
7 CONCLUSIONS [9] M. Majzoobi, M. Rostami, F. Koushanfar, D. S. Wallach, and
We have developed a secure PUF based authentication S. Devadas, “Slender PUF protocol: A lightweight, robust, and
secure authentication by substring matching,” in Proc. IEEE Symp.
and certificate-less identity based key exchange protocol. Secur. Privacy Workshops, 2012, pp. 33–44.
Formal security proofs for the protocol have been formu- [10] € Koçabas, A. Peter, S. Katzenbeisser, and A. Sadeghi, “Converse
U.
lated under the SK security and UC framework. The asym- PUF-based authentication,” in Proc. 5th Int. Conf. Trust Trustworthy
Comput., 2012, pp. 142–158.
metric nature of the protocol overcomes the shortcomings [11] M. van Dijk and U. R€ uhrmair, “Physical unclonable functions in
of previously proposed CRP based PUF authentication cryptographic protocols: Security proofs and impossibility results,”
mechanism and suits appropriately in a distributed IoT IACR Cryptology ePrint Archive, vol. 2012, 2012, Art. no. 228.
framework. We have also demonstrated an attack on a pro- [12] J. Kong, F. Koushanfar, P. K. Pendyala, A. Sadeghi, and C. Wachs-
mann, “PUFatt: Embedded platform attestation based on novel
totype video surveillance system, and showed how the processor-based PUFs,” in Proc. 51st Annu. Des. Autom. Conf.,
proposed scheme can be useful in mitigating the security 2014, pp. 109:1–109:6.
vulnerability at low hardware and performance over- [13] S. Schulz, A. Schaller, F. Kohnh€auser, and S. Katzenbeisser, “Boot
attestation: Secure remote reporting with off-the-shelf IoT
heads. In future, our research work will be directed sensors,” in Proc. 22nd Eur. Symp. Res. Comput. Secur. Comput.
towards optimization of the resources for frame encryp- Secur., 2017, pp. 437–455.
tion and investigating side-channel attacks on the pro- [14] Y. Lao, B. Yuan, C. H. Kim, and K. K. Parhi, “Reliable PUF-based
posed protocol implementation. local authentication with self-correction,” IEEE Trans. Comput.-
Aided Des. Integr. Circuits Syst., vol. 36, no. 2, pp. 201–213, Feb. 2017.
[15] M. Barbareschi, P. Bagnasco, and A. Mazzeo, “Authenticating IoT
ACKNOWLEDGMENTS devices with physically unclonable functions models,” in Proc.
10th Int. Conf. P2P Parallel Grid Cloud Internet Comput., 2015,
This work was supported partially by Wipro Limited, Infor- pp. 563–567.
mation security education Awareness Program (ISEA), DIT, [16] M. Aman, K. C. Chua, and B. Sikdar, “Mutual authentication in
India. Debdeep Mukhopadhyay would like to thank DST IoT systems using physical unclonable functions,” IEEE Internet
Things J., vol. 4, no. 5, pp. 1327–1340, Oct. 2017.
Swarnajayanti Fellowship.
CHATTERJEE ET AL.: BUILDING PUF BASED AUTHENTICATION AND KEY EXCHANGE PROTOCOL FOR IOT WITHOUT EXPLICIT CRPS IN... 437

[17] J. Delvaux, D. Gu, D. Schellekens, and I. Verbauwhede, “Secure Rajat Sadhukhan is working toward the PhD
lightweight entity authentication with strong PUFs: Mission degree in the Indian Institute of Technology-
impossible?” in Proc. 16th Int. Workshop Cryptographic Hardware Kharagpur, India, since 2016. Prior to joining
Embedded Syst., 2014, pp. 451–475. research programme he has worked with Intel
[18] W. Che, M. Martin, G. Pocklassery, V. K. Kajuluri, F. Saqib, and Technology India Pvt. Ltd., Bangalore for seven
J. Plusquellic, “A privacy-preserving, mutual PUF-based authentica- years. His research interests include symmetric
tion protocol,” Cryptography, vol. 1, no. 1, pp. 1–17, 2016, Art. no. 3. key cryptography, hardware security, and VLSI
[19] J. Guajardo, S. S. Kumar, G. J. Schrijen, and P. Tuyls, “Physical design.
unclonable functions, FPGAs and public-key Crypto for IP
protection,” in Proc. Int. Conf. Field Programmable Logic Appl., 2007,
pp. 189–195.
[20] J. R. Wallrabenstein, “Practical and secure IoT device authentica-
tion using physical unclonable functions,” in Proc. IEEE 4th Int. Debdeep Mukhopadhyay received the PhD
Conf. Future Internet Things Cloud, 2016, pp. 99–106. degree from the Department of Computer Sci-
[21] A. Costin, “Security of CCTV and video surveillance systems: ence and Engineering, Indian Institute of Tech-
Threats, vulnerabilities, attacks, and mitigations,” in Proc. 6th Int. nology Kharagpur, India, in 2007, where he is
Workshop Trustworthy Embedded Devices, 2016, pp. 45–54. currently an associate professor. His research
[22] H. Li, Y. He, L. Sun, X. Cheng, and J. Yu, “Side-channel informa- interests include cryptography, VLSI of crypto-
tion leakage of encrypted video stream in video surveillance sys- graphic algorithms, hardware security, and side
tems,” in Proc. 35th Annu. IEEE Int. Conf. Comput. Commun., 2016, channel analysis.
pp. 1–9.
[23] U. L. Puvvadi, K. Di Benedetto, A. Patil, K.-D. Kang, and Y. Park,
“Cost-effective security support in real-time video surveillance,”
IEEE Trans. Ind. Informat., vol. 11, no. 6, pp. 1457–1465, Dec. 2015.
[24] T.-S. Park and M.-S. Jun, “User authentication protocol for block- Rajat Subhra Chakraborty is an associate pro-
ing malicious user in network CCTV environment,” in Proc. 6th fessor with the Department of Computer Science
Int. Conf. Comput. Sci. Convergence Inf. Technol., 2011, pp. 18–24. and Engineering, Indian Institute of Technology
[25] U. Chatterjee, R. S. Chakraborty, H. Kapoor, and D. Mukhopad- Kharagpur, India. His area of research is hard-
hyay, “Theory and application of delay constraints in arbiter ware security, VLSI design (especially low-power
PUF,” ACM Trans. Embedded Comput. Syst., vol. 15, no. 1, pp. 10:1– and robust design) and digital content protection
10:20, 2016. through watermarking. He is a senior member of
[26] Infenion, “Trusted platform module fundamental,” 2008. [Online]. the IEEE and ACM.
Available: http://cs.unh.edu/ it666/reading_list/Hardware/
tpm_fundamentals.pdf
[27] N. Asokan, F. F. Brasser, A. Ibrahim, A. Sadeghi, M. Schunter,
G. Tsudik, and C. Wachsmann, “SEDA: Scalable embedded
device attestation,” in Proc. 22nd ACM SIGSAC Conf. Comput. Com- Debashis Mahata received the MSc degree in
mun. Secur., 2015, pp. 964–975. physics from Burdwan University, West Bengal
[28] C. Helfmeier, C. Boit, D. Nedospasov, and J.-P. Seifert, “Cloning and the MTech degree in computer science from
physically unclonable functions,” in Proc. IEEE Int. Symp. the Indian Statistical Institute, Kolkata. He is a
Hardware-Oriented Secur. Trust, 2013, pp. 1–6. distinguished member of Technical staff-senior
[29] U. R€ uhrmair, F. Sehnke, J. S€ olter, G. Dror, S. Devadas, and member, with Wipro Technologies. His current
J. Schmidhuber, “Modeling attacks on physical unclonable areas of interests include connected devices
functions,” in Proc. 17th ACM Conf. Comput. Commun. Secur., 2010, security, neural networks, and video collaboration.
pp. 237–249.
[30] J. Katz and Y. Lindell, Introduction to Modern Cryptography.
London, U.K./Boca Raton, FL, USA: Chapman and Hall/CRC
Press, 2007.
[31] U. Chatterjee, R. S. Chakraborty, and D. Mukhopadhyay, “A PUF-
Mukesh M. Prabhu received the MS degree
based secure communication protocol for IoT,” ACM Trans.
from IIT Madras. He is a distinguished member of
Embedded Comput. Syst., vol. 16, no. 3, pp. 67:1–67:25, 2017. Technical staff and head of the IP & Innovation of
[32] Y. K. Lee, K. Sakiyama, L. Batina, and I. Verbauwhede, “Elliptic- Product Engineering Services, Wipro Technolo-
curve-based security processor for RFID,” IEEE Trans. Comput., gies. His current areas of interests include con-
vol. 57, no. 11, pp. 1514–1527, Nov. 2008. nected devices security, augmented reality, video
collaboration, designing end-to end systems, and
Urbi Chatterjee is working toward the PhD degree applications addressing business challenges.
in the Indian Institute of Technology Kharagpur,
India, since 2015. Before that, she worked as assis-
tant systems engineer with TATA Consultancy
Services Limited, Kolkata. Her research interests
include design of PUF based lightweight authenti- " For more information on this or any other computing topic,
cation and secure communication protocols, crypt- please visit our Digital Library at www.computer.org/publications/dlib.
analysis, and security evaluation of PUFs.

Vidya Govindan is working toward the master’s

degree in the Computer Science and Engineering
Department, Indian Institute of Technology Khar-
agpur, India. Prior to that she had worked as hard-
ware design engineer with Tonbo Imaging Pvt Ltd,
Bangalore, India. Her current research focuses on
security of IOT and embedded systems.