Energy-Aware Digital Signatures for Embedded Medical Devices

TL;DR

This paper introduces ESEM, an energy-efficient digital signature scheme tailored for embedded medical IoT devices, significantly reducing energy consumption and signature size while maintaining security.

Contribution

ESEM is a novel energy-aware signature scheme that eliminates costly operations and reduces signature size, suitable for resource-constrained medical IoT devices.

Findings

ESEM achieves 8.4x higher energy efficiency compared to existing schemes.

ESEM has the smallest signature size among elliptic curve-based signatures with similar security.

ESEM is securely implemented on low-end microcontrollers used in medical devices.

Abstract

Authentication is vital for the Internet of Things (IoT) applications involving sensitive data (e.g., medical and financial systems). Digital signatures offer scalable authentication with non-repudiation and public verifiability, which are necessary for auditing and dispute resolution in such IoT applications. However, digital signatures have been shown to be highly costly for low-end IoT devices, especially when embedded devices (e.g., medical implants) must operate without a battery replacement for a long time. We propose an Energy-aware Signature for Embedded Medical devices (ESEM) that achieves near-optimal signer efficiency. ESEM signature generation does not require any costly operations (e.g., elliptic curve (EC) scalar multiplication/addition), but only a small constant-number of pseudo-random function calls, additions, and a single modular multiplication. ESEM has the smallest signature size among its EC-based counterparts with an identical private key size. We achieve this by eliminating the use of the ephemeral public key (i.e, commitment) in Schnorr-type signatures from the signing via a distributed construction at the verifier without interaction with the signer while permitting a constant-size public key. We proved that ESEM is secure (in random oracle model), and fully implemented it on an 8-bit AVR microcontroller that is commonly used in medical devices. Our experiments showed that ESEM achieves 8.4x higher energy efficiency over its closest counterpart while offering a smaller signature and code size. Hence, ESEM can be suitable for deployment on resource limited embedded devices in IoT. We open-sourced our software for public testing and wide-adoption.

Figures

Tables

Table 1. TABLE I : Signature generation performance of ESEM  and its counterparts on AVR ATmega 2560 microcontroller

Scheme	CPU cycles	Signing Speed (ms)	Code Size (Byte)	Signature Size (Byte)	Private Key (Byte)	CPU energy (mJ)
ECDSA	79 185 664	4949	11 990	64	32	494.91
BPV-ECDSA	23 519 232	1470	27 912	64	10 272	146.99
Ed25519	34 342 230	2146	17 373	64	32	214.64
SchnorrQ	5 174 800	323	29 894	64	32	32.34
ESEM	616 896	38	18 465	48	32	3.85

Table 2. TABLE II : Experimental performance comparison of ESEM  schemes and their counterparts on commodity hardware

Scheme	Signing Time ($\mu$s)	Private Key$\P$ (Byte)	Signature Size (Byte)	Verifier Comp. ($\mu$s)	Verifier Storage (Byte)	Server Comp. ($\mu$s)	Server Storage (KB)	End-to-End Delay$†$ ($\mu$s)
ECDSA	725	32	64	927	32	$-$	$-$	1652
BPV-ECDSA	149	10272	64	927	32	$-$	$-$	1076
Ed25519	132	32	64	336	32	$-$	$-$	468
SchnorrQ	12	32	64	22	32	$-$	$-$	34
ESEM	11	32	48	24	32	5	32784	$11+24+5+\Delta$
ESEM2	4	12416	48	24	32	10	4112	$4+24+10+\Delta$

Equations

$${Adv}_{\text{ESEM}}^{EU\text{mathchar}45CMA}(t,q_h,q_s)$$

$$R^{\ast }$$

$$r^{\ast }$$

$${ϵ}_{\mathcal{F}}$$

Full text

We propose an Energy-aware Signature for Embedded Medical devices (ESEM) that achieves near-optimal signer efficiency. ESEM signature generation does not require any costly operations (e.g., elliptic curve (EC) scalar multiplication/addition), but only a small constant-number of pseudo-random function calls, additions, and a single modular multiplication. ESEM has the smallest signature size among its EC-based counterparts with an identical private key size. We achieve this by eliminating the use of the ephemeral public key (i.e, commitment) in Schnorr-type signatures from the signing via a distributed construction at the verifier without interaction with the signer while permitting a constant-size public key. We proved that ESEM is secure (in random oracle model), and fully implemented it on an 8-bit AVR microcontroller that is commonly used in medical devices. Our experiments showed that ESEM achieves 8.4$\times$ higher energy efficiency over its closest counterpart while offering a smaller signature and code size. Hence, ESEM can be suitable for deployment on resource limited embedded devices in IoT. We open-sourced our software for public testing and wide-adoption. ††$\copyright$ 2019 IEEE. Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, including reprinting/republishing this material for advertising or promotional purposes, creating new collective works, for resale or redistribution to servers or lists, or reuse of any copyrighted component of this work in other works.

I Introduction

It is essential to provide authentication and integrity services for the emerging Internet of Things (IoT) systems that include resource-constrained devices. Due to their computational efficiency, symmetric key primitives (e.g., message authentication codes) are usually preferred for such systems. On the other hand, these primitives might not be scalable for large and ubiquitous systems, and they also do not offer public verifiability and non-repudiation properties, which are essential for some IoT applications [1, 2, 3]. For instance, in financial IoT applications and implantable medical devices, digital forensics (e.g., legal cases) need non-repudiation and public verifiability [2, 3, 4]. Moreover, such systems may include many devices that require scalability.

Digital signatures rely on public key infrastructures and offer scalable authentication with non-repudiation and public verifiability. Therefore, they are ideal authentication tools for the security of IoT applications. On the other hand, most of the compact digital signatures (e.g., elliptic curve (EC) based signatures) require costly operations such as EC scalar multiplication and addition during signature generation. It has been shown [5, 6, 7], and further demonstrated by our experiments that, these operations can be energy costly, and therefore, can negatively impact the battery life of highly resource-limited embedded devices. For instance, as one of the many potential applications, we can refer to a resource-limited sensor (e.g., a medical device [1]) that frequently generates and signs sensitive data (medical readings), which are verified by a resourceful cloud service provider. There is a need for lightweight signatures that can meet the computation, memory and battery limitations of these IoT applications.

The goal of this paper is to devise an energy-aware and compact digital signature scheme that can meet some of the stringent battery and memory requirements of highly resource-limited IoTs (e.g., implantable medical devices) that must operate for long periods of time with minimal intervention.

Design Objectives: (i) The signature generation should not require any costly operation (e.g., exponentiation, EC operations), but only symmetric cryptographic functions (e.g., pseudorandom functions) and basic arithmetics (e.g., modular addition) (ii) The low-end devices are generally not only computation/battery but also memory limited. Hence, the objective (i) should be achieved without consorting precomputed storage (e.g., Boyko-Peinado-Venkatesan ($\mathit{BPV}$) tables [8], or online/offline signatures [9]). (iii) The signing should not draw new randomness [10] to avoid potential hurdles of weak pseudo-random number generators. (iv) The size of the signature should be small and constant-size as in Schnorr-like signatures. (v) The size of the public key should be constant.

Our Contributions: (i) We create an Energy-aware Signature for Embedded Medical devices (ESEM), which is ideal for the signature generation on highly resource-limited IoT devices. We observe that the realizations of Schnorr-like signatures on efficient elliptic curves (e.g., FourQ [11]) are currently the most efficient solutions, and a generation of the commitment value via a scalar multiplication is the main performance bottleneck in these schemes. Our main idea is to completely eliminate the generation, storage, and transmission of this commitment from the signing of Schnorr signature. To achieve this, we first develop a new algorithm that we call as Signer NOn-interactive Distributed BPV (SNOD$\mathchar 45\relax$BPV), which permits a distributed construction of the commitment for a given signature at verifier’s side, without requiring any interaction with the signer. We then transform the signature generation process such that the correctness and provable security are preserved once the commitment value is separated from message hashing and SNOD$\mathchar 45\relax$BPV is incorporated into ESEM. We present our proposed algorithms in Section III. In Section IV, we prove that ESEM is secure in the random oracle model [12] under a semi-honest distributed setting for SNOD$\mathchar 45\relax$BPV.

(ii) We implemented ESEM and its counterparts both on an AVR ATmega 2560 microcontroller and a commodity hardware, and provided a detailed comparison in Section V. We also conducted experiments to assess the battery consumption of ESEM and its counterparts when they are used with common IoT sensors (e.g., a pulse and pressure sensor). We make our implementation open-source for broad testing and adoption.

Desirable Properties of ESEM: We summarize the desirable properties of our scheme as follows (Table I gives a comparison of ESEM with its counterparts in terms of signing efficiency on 8-bit AVR processor):

$\bullet$ Signing and Energy Efficiency: The signature generation of ESEM does not require any EC operations (e.g., scalar multiplication, addition) or exponentiation, but only pseudo-random function (PRF) calls, modular additions and a single modular multiplication. Therefore, ESEM achieves the lowest energy consumption among their counterparts. For example, ESEM consumes 8$$\times and 55$$\times less battery than SchnorrQ [11], and Ed25519 [13], respectively. Our experiments indicate that ESEM can substantially extend the battery life of low-end devices integrated with IoT applications (see Section V). Similarly, ESEM is at least a magnitude of times faster than Ed25519 both in an 8-bit microcontroller and commodity hardware. This gap further increases when our high-speed variant ESEM2 (introduced in Section III) is considered.

$\bullet$ Small Private Key and Signature Sizes: ESEM has the smallest signature size among its counterparts ($48$ Bytes for $\kappa=128$) with an identical private key size. ESEM does not require any precomputation tables to be stored at the signer, and therefore it is significantly more storage and computation efficient than schemes relying on $\mathit{BPV}$ at the signer’s side. Moreover, ESEM has a small code size at the signer since it only requires symmetric primitives and basic arithmetics.

$\bullet$ High Security: (i) Side-channel attacks exploiting the EC scalar multiplication implementations in ECDSA were proposed [14]. Since ESEM does not require any EC operations at the signer, it is not vulnerable to these types of attacks. (ii) The security of Schnorr-like signatures are sensitive to weak random number generators. The signing of ESEM does not consume new randomness (as in [10]), and therefore can avoid these problems. (iii) We prove that ESEM is $\mathit{EU}\mathchar 45\relax\mathit{CMA}$ secure in the random oracle model [12].

Potential Use-cases: In many IoT applications, extending the battery life of low-end processors (i.e., usually signers) is a priority, while verifiers generally use a commodity hardware (e.g., a server) with reasonable storage and communication capabilities. In particular, energy efficiency is a vital concern for embedded medical devices, as they are expected to operate reliably for long periods of time. Currently, symmetric cryptography is preferred to provide security for such devices [15]. At the same time, the ability to produce publicly verifiable authentication tags with non-repudiation is desirable for medical systems [2, 3, 4] (e.g., digital forensics and legal cases). Moreover, scalable integration of various medical apparatus to IoT realm will receive a significant benefit from the ability to deploy digital signatures on these devices [1]. ESEM takes a step towards meeting this need, as it is currently the most energy efficient alternative with small signature and private key sizes. Essentially, any IoT application involving energy/resource limited signers and more capable verifiers (e.g., wireless sensor networks and IoT sensors in smart cities) are expected to receive benefit from ESEM.

Limitations: The signature verification of ESEM is distributed, wherein a verifier reconstructs the commitment value of a signature with $l$ parties. Therefore, verification of ESEM is not real-time, and the verifier should wait for a response from all parties. However, as confirmed with our experiments, this only results in a few milliseconds of delay. Moreover, the signer does not need interaction with any parties to compute signatures. Parties aiding the verification are assumed to be semi-honest (do not deviate from the protocol, but try to learn information) and non-colluding (as in traditional semi-honest secure multi-party computation). In our case, even $(l-1)$ parties collude, ESEM remains EU-CMA secure. Since ESEM is designed for a near-optimal signer performance, we believe that ESEM is suitable for applications as outlined above, where a small delay and interaction can be tolerated at the verifier.

II Preliminaries and Models

We first give the notations and definitions used by our schemes, and then describe our system/security model.

II-A Notation and Definitions

Notation: $||$ and $|x|$ denote concatenation and the bit length of variable $x$, respectively. x\stackrel{{\scriptstyle\}}{{\leftarrow}}\mathcal{S}$means variable$x$is randomly selected from set$\mathcal{S}$.$|\mathcal{S}|$denotes the cardinality of set$\mathcal{S}$. We denote by${0,1}^{}$the set of binary strings of any finite length. The set of items$q_{i}$for$i=0,\ldots,n-1$is denoted by${q_{i}}{i=0}^{n-1}$.$\log{x}$denotes$\log{2}{x}$.$\mathcal{A}^{\mathcal{O}{0},\ldots,\mathcal{O}{i}}(.)$denotes algorithm$\mathcal{A}$is provided with oracles$\mathcal{O}{0},\ldots,\mathcal{O}{i}$. For example,$\mathcal{A}^{\mathit{SGN.Sig}{}{sk}}(.)$denotes algorithm$\mathcal{A}$is provided with a *signing oracle* of algorithm$\mathit{Sig}$of signature scheme$\mathit{SGN}{}$under a private key$sk$. We define a pseudo-random function (PRF) and three hash functions to be used in our schemes as follows:$PRF{0}:{{0,1}}^{}\rightarrow{{0,1}}^{\kappa}$,$H_{0}:{{0,1}}^{}\rightarrow{{0,1}}^{\kappa}$,$H_{1}:{{0,1}}^{}\rightarrow{{0,1}}^{v\cdot\log{n}}$and$H_{2}:{{0,1}}^{}\rightarrow\mathbb{Z}_{q}^{}$, where$1<v<n$are BPV parameters and$\kappa$ is the security parameter.

Definition 1**.**

A signature scheme $\mathit{SGN}$ is a tuple of three algorithms $(\mathit{Kg},\mathit{Sig},\mathit{Ver})$ defined as follows:

$\underline{(\mathit{sk}{},\mathit{PK}{})\leftarrow\mathit{SGN.Kg}{}(1^{\kappa})}$: Given the security parameter $1^{\kappa}$, the key generation algorithm returns a private/public key pair $(\mathit{sk}{},\mathit{PK}{})$. 2. -

$\underline{\sigma\leftarrow\mathit{SGN.Sig}{}(m{},\mathit{sk}{})}$: The signing algorithm takes a message $m{}$ and a $\mathit{sk}$, and returns a signature $\sigma$. 3. -

$\underline{b\leftarrow\mathit{SGN.Ver}{}(m{},\sigma,\mathit{PK}{})}$: The verification algorithm takes a message $m$, signature $\sigma$ and the public key $\mathit{PK}$ as input. It returns a bit $b$: $1$ means valid and [math] means invalid.

Our schemes are based on Schnorr signature [16].

Definition 2**.**

Schnorr* signature scheme is a tuple of three algorithms $(\mathit{Kg},\mathit{Sig},\mathit{Ver})$ defined as follows:*

$\underline{(y,Y)\leftarrow\texttt{Schnorr.Kg}{}(1^{\kappa})}$: Given $1^{\kappa}$ as the input,

The system-wide $\mathit{params}{}\leftarrow{}(q,p,\alpha)$, where $q$ and $p$ are large primes such that $p>q$ and $q|(p-1)$, and a generator $\alpha$ of the subgroup $G$ of order $q$ in $\mathbb{Z}_{p}^{*}$. 2. 2)

Generate private/public key pair (y\stackrel{{\scriptstyle\}}{{\leftarrow}}\mathbb{Z}_{q}^{},Y\leftarrow\alpha^{y}\bmod p)$*. We suppress *$\mathit{params}$ afterwards for the brevity.* 2. -

$\underline{(\sigma\leftarrow\texttt{Schnorr.Sig}{}(m,y)}$: Given $m\in\{0,1\}^{*}$ and $y$ as the input, it returns a signature $\sigma=(s,e)$, where $H:\{0,1\}^{*}\rightarrow\mathbb{Z}_{q}^{*}$ is a full domain hash function.

r\stackrel{{\scriptstyle\}}{{\leftarrow}}\mathbb{Z}_{q}^{}{},{}{}R\leftarrow{}\alpha^{r}\bmod p$.* 2. 2)

$e\leftarrow{}H(m||R),~{}s\leftarrow{}(r-e\cdot y)\bmod q$. 3. -

$\underline{b\leftarrow\texttt{Schnorr.Ver}{}(m,\langle s,e\rangle,Y)}$: The signature verification algorithm takes $m$, $\langle s,e\rangle$ and $Y$ as the input. It computes $R^{\prime}\leftarrow{}Y^{e}\alpha^{s}\bmod p$ and returns a bit $b$, with $b=1$ indicating valid, if $e=H(m||R^{\prime})$ and $b=0$ otherwise.

We use Boyko-Peinado-Venkatesan ($\mathit{BPV}$) generator [8].

Definition 3**.**

The $\mathit{BPV}$ generator is a tuple of two algorithms $(\mathit{Offline},\mathit{Online})$ defined as follows:

$\underline{(\Gamma,v,n,q,p)\leftarrow{}\mathit{BPV.Offline}{}(1^{\kappa})}$: The offline $\mathit{BPV}$ algorithm takes $1^{\kappa}$ as the input and generate system-wide parameters $(q,p,\alpha)$ as in $\texttt{Schnorr.Kg}{}(1^{\kappa})$.

$\mathit{BPV}$* parameters $n$ and $v$ are the number of pairs to be precomputed and the number of elements to be randomly selected out $n$ pairs, respectively, for $2<v<n$.* 2. 2)

r_{i}\stackrel{{\scriptstyle\}}{{\leftarrow}}\mathbb{Z}{q}^{*}{},$*   *$R{i}\leftarrow{}\alpha^{r_{i}}\bmod p$*, *$i=0,\ldots,n-1$. 3. 3)

Set precomputation table $\Gamma=\{r_{i},R_{i}\}_{i=0}^{n-1}$. 2. -

$\underline{(r,R)\leftarrow{}\mathit{BPV.Online}{}(\Gamma,v,n,q)}$: The online $\mathit{BPV}$ algorithm takes the table $\Gamma$ and $(v,n,q)$ as input.

Generate a random set $S\subset[0,n-1]$, where $|S|=v$. 2. 2)

$r\leftarrow{}\sum_{i\in S}r_{i}\bmod q$, $R\leftarrow{}\prod_{i\in S}R_{i}$.

Lemma 1**.**

The distribution of $\mathit{BPV}$output $r$ is statistically close to the uniform random distribution with an appropriate choice of parameters $(v,n)$ [8].

II-B System and Security Model

As depicted in Figure 1, our system model includes a highly resource-limited signer that computes signatures to be verified by any receiver. Our system model also includes $l$ distinct parties ($P_{1},\ldots,P_{l}$) that are involved in signature verification. In the line of [17], after the initialization phase, we consider a synchronous network which consists of a client (verifier in ESEM) and semi-honest servers $P=(P_{1},\ldots,P_{l})$. We assume that the communication channels are secure.

The security notion for a digital signature is Existential Unforgeability against Chosen Message Attack ($\mathit{EU}\mathchar 45\relax\mathit{CMA}$) [18].

Definition 4**.**

EU-CMA experiment $\mathit{Expt}^{\textit{EU-CMA}}_{\mathtt{SGN}}$ for a signature scheme $\texttt{SGN}=(\texttt{Kg,Sig,Ver})$ is defined as follows.

• •

$(\mathit{sk}{},pk)\leftarrow\texttt{SGN.Kg}(1^{\kappa})$

• •

$(M^{*},\sigma^{*})\leftarrow\mathcal{A}^{\texttt{SGN.Sig}(\cdot)}(pk)$

$\mathcal{A}$wins the above experiment if $1\leftarrow{\texttt{SGN.Ver}(M^{*},\sigma^{*},pk)}$ and $m^{*}$ was not queried to $\texttt{SGN.Sig}(\cdot)$ oracle. The EMU-CMA advantage $\mathit{Adv}^{\textit{EU-CMA}}_{\texttt{SGN}}$ of $\mathcal{A}$is defined as $\Pr[\mathit{Expt}^{\textit{EU-CMA}}_{\texttt{SGN}}=1]$

Definition 5**.**

A protocol is $t$-private [17] if any set of parties $\mathcal{S}$ with $|\mathcal{S}|\leq t$ are not able to compute or achieve any output or knowledge any different than what they could have done individually from their set of private input and outputs.

Assumption 1**.**

We assume that the servers are semi-honest - always follow the protocol, but try to learn as much as possible from the shared or observed information.

For $t=l-1$, where $l$ is the total number of the servers, our proposed scheme is $t$-private. The signature generation in our scheme does not require the participation of the servers. In other words, the signer does not need to interact with any of the $l$ servers during the signature generation. The participation of all $l$ servers is however required on the verifier’s side.

III Proposed Schemes

We first discuss the design challenges to achieve our objectives outlined in Section I. We elaborate our Signer NOn-interactive Distributed BPV (SNOD$\mathchar 45\relax$BPV) algorithm that addresses some of them. We then present ESEM that uses SNOD$\mathchar 45\relax$BPV and other strategies to achieve our objectives.

III-A High-Level Design

Schnorr-like signatures with implementations on recent ECs (e.g., FourQ [11]) are currently among the most efficient and compact digital signatures. Hence, we take them as our starting point. In these schemes, the signer generates a random value $r$ and its commitment $R=\alpha^{r}\bmod p$, which is incorporated into both signing and verification (as an input to hash along with a message). This exponentiation (EC scalar multiplication) constitutes the main cost of the signature generation, and therefore we aim to completely eliminate it from the signing. However, this is a highly challenging task.

III-A1 Commitment Generation without Signer Interaction

The elimination of commitment $R$ from the signing permits removal of EC operations such as scalar multiplication/additions. It also eliminates the transmission of $R$ and a storage of $\mathit{BPV}$ table at the signer. However, the commitment is necessary for the signature verification. Hence, the verifier should obtain a correct commitment for each signature with the following requirements: (i) The verifier cannot interact with the signer to obtain the commitment (i.e., the signer does not have it). (ii) The signer non-interactive construction of the commitment should not reveal the ephemeral randomness $r$. (iii) Unlike some multiple-time signatures [6], the verifier should not have a fixed limit on the number of signature verifications and/or a linear-size public key.

We propose a new algorithm that we refer to as SNOD$\mathchar 45\relax$BPV, to achieve these requirements. Our idea is to create a distributed BPV technique that permits a set of parties to construct a commitment on behalf of the signer. This distributed scheme permits the verifiers to obtain the corresponding commitment of a signature from these parties on demand without revealing $r$ or an interaction with the signer. We elaborate on SNOD$\mathchar 45\relax$BPV in Section III-B.

III-A2 Separation of the Commitment from Signature Generation with SNOD$\mathchar 45\relax$BPV

The commitment value is generally used as a part of message hashing (e.g., $H(M||R)$ in Schnorr) in Schnorr-like signatures. To eliminate $R$ from the signature, the commitment must be separated from the message. However, the use of commitment in the message hashing plays a role in the security analysis of Schnorr-like signatures. Moreover, the removal of commitment $R$ from the signing while using $r$ with SNOD$\mathchar 45\relax$BPV algorithm requires a design adjustment.

We propose our main scheme ESEM that achieves these goals. In the line of [6], we use a one-time random value $x$ in the message hashing, but also devise an index encoding and aggregate BPV approach to integrate SNOD$\mathchar 45\relax$BPV into signature generation. This permits a constant-size public key at the verifier without any interaction with the signer. We give the details of ESEM in Algorithm 2.

III-B Signer NOn-interactive Distributed BPV (SNOD$\mathchar 45\relax$BPV)

We conceive SNOD$\mathchar 45\relax$BPV as a distributed realization of $\mathit{BPV}$ [8] where $l$ parties hold $n$ public values $\{R_{i,j}\}_{i=1,j=1}^{n,l}$ of $l$ $\mathit{BPV}$ tables, and then can collaboratively derive $R$ without learning its corresponding private key $r$ unless all of them collude. We stress that one cannot simply shift the storage of public values in a $\mathit{BPV}$ table to a single verifier. This is because the indexes needed to compute the commitment $R$ should remain hidden in order to protect the one-time randomness $r$ [19]. We overcome this challenge by creating a distributed $\mathit{BPV}$ approach that can be integrated into a Schnorr-like signature. At SNOD$\mathchar 45\relax$BPV.Offline, in Step 2, the secret key $y$ is used as a seed to derive $l$ secret values $\{z_{j}\}_{j=1}^{l}$. Each $z_{j}$ is used to deterministically generate secret $\mathit{BPV}$ values $\{r_{i,j}\}_{i=1,j=1}^{n,l}$, whose corresponding public values $\{R_{i,j}\}_{i-1,j=1}^{n,l}$ are computed in Step 4-5 and given to parties $(P_{1},\ldots,P_{l})$.

At the online phase, the sender (i.e., signer) generates the aggregated $r$ on its own and the receiver (i.e., verifier) generates the aggregated $R$ cooperatively with the parties $(P_{1},\ldots,P_{l})$. The sender first derives a random value $x$ from a keyed hash function (at SNOD$\mathchar 45\relax$BPV.Sender Step 1), and then deterministically derives $z_{j}$ values (Step 3) as in SNOD$\mathchar 45\relax$BPV.Offline. Sender uses the $z_{j}$, that is only shared with the corresponding party, and the one-time random value $x$ to generate the set (indexes) to be used to aggregate the values. This step is of high importance since this way, the sender commits to the one-time random value $x$. Sender repeats this process for all $l$ parties and aggregates (adds) all the corresponding $r_{i,j}$s to derive the resulting $r$ (Step 5).

The verifier proceeds as follows to generate the corresponding $R=\alpha^{r}\bmod p$. At Step 1 in SNOD$\mathchar 45\relax$BPV.Receiver, the verifier communicates with $l$ parties to derive each $R_{j}$ from them. Upon request, parties first derive the same set (indexes) as the sender (Step 1 in $\texttt{SNOD.P}_{j}\mathchar 45\relax\texttt{Construct}$). Then, each party aggregates the corresponding $R_{i,j}$ that were assigned to them in SNOD$\mathchar 45\relax$BPV.Offline, and returns the results to the verifier. The verifier aggregates all these values at Step 2, to derive the corresponding $R$. Please note that only the parties can create the set (indexes) since only they have their corresponding $z_{j}$ values. Moreover, since all servers provide $R_{j}$ that can be generated only by them, unless all of the servers collude, they cannot learn any information about the other indexes or the one-time randomness $r$. This makes our scheme $t$-private, as shown in Lemma 2.

III-C Energy-aware Signature for Embedded Medical devices

We summarize our main scheme ESEM (see Algorithm  2), which permits a near-optimal signing by integrating SNOD$\mathchar 45\relax$BPV into Schnorr signature with alternations.

During key generation, secret/public key pair ($y,Y$) and $\mathit{BPV}$ parameters are generated (Step 1-2), followed by SNOD$\mathchar 45\relax$BPV.Offline$(\cdot)$ algorithm to obtain the distributed $\mathit{BPV}$ public values to be stored by parties $(P_{1},\ldots,P_{l})$. In ESEM.Sig$(\cdot)$, the signer generates the ephemeral random value $r$ and one-time randomness $x$ to be used as the commitment. Instead of the commitment in Schnorr ($R$), the signer uses $x$ as the commitment in Step 2. This separation of the commitment $R$ from the message hashing is inspired from [6]. Note that, unlike the multiple-time signature in [6] that can only compute a constant pre-determined number of signatures with a very large linear-size public key, ESEM can compute polynomially unbounded number of signatures with a constant public key size. Finally, the verifier first calls the SNOD$\mathchar 45\relax$BPV.Receiver$(\cdot)$ algorithm to generate the public value $R$, by collaborating with the parties. The signature verification, which is similar to Schnorr with the exception of the commitment $x$, is performed at Step 2.

III-C1 ESEM2

We point out a trade-off between the private key size and signing speed, which can increase the signature generation performance with the cost of some storage. The signer can store private keys $\{r_{i,j}\}_{i=1,j=1}^{n,l}$ in the memory, and therefore avoid $v\cdot l$ PRF invocations. We refer to this simple variant as ESEM2. As demonstrated in Section V, an extra storage of $12$ KB can boost the performance of ESEM commodity hardware.

IV Security Analysis

Lemma 2**.**

The scheme proposed in Algorithm 1 is $t$-private (in the sense of Definition 5) with regard to $r$ and therefore, it can resist against $l-1$ colluding servers.

Proof.

The random values $\{r_{i,j}\leftarrow\texttt{PRF}_{0}(z_{j}||i)\}_{j=1,i=1}^{l,n}$ are generated uniformly at random in the SNOD$\mathchar 45\relax$BPV.Offline$(\cdot)$ via private seed $z_{j}$, which is given to each server $P_{j}$. The security of SNOD$\mathchar 45\relax$BPV (i.e., ESEM) relies on the secrecy of $r\leftarrow\sum_{i=1}^{l}\sum_{j=1}^{n}r_{i,j}\bmod q$. Given each $r_{i,j}$ is generated uniformly at random via $z_{j}$’s, and due to Lemma 1, for the adversary $\mathcal{A}$to infer $r$, it must know all $l$ private seeds $z_{j}$ or corrupt all of the $l$ servers. ∎

Theorem 1**.**

In the random oracle model, based on Assumption 1 and Lemma 2, if a polynomial-time adversary $\mathcal{A}$can break the EU-CMA security of ESEM in time $t$ and after $q_{h}$ hash and $q_{s}$ signature queries, then one can build polynomial-time algorithm $\mathcal{F}$that breaks the EU-CMA security of Schnorr signature in time $t^{\prime}$ and $q_{s}^{\prime}$ signature queries.

[TABLE]

Proof: Please refer to the Appendix.

V Performance Analysis

V-A Parameter Selection

We select FourQ curve [11] that offers fast elliptic curve operations (that is desirable for our verification process, remark that signer has no EC operations) with $128$-bit security level. The selection of parameters $(v,n)$ relies on the number of $v$-out-of-$n$ different combinations possible. We select $n=1024$, $v=18$ for ESEM and $n=128$, and $v=40$ for ESEM2, where both offers over $2^{128}$ different combinations. Lastly, we select $l=3$ (i.e., 3 parties are involved in verification).

V-B Evaluation Metrics and Experimental Setup

Evaluation Metrics: We implemented ESEM and its counterparts both on the low-end device (8-bit microcontroller) and a commodity hardware. (i) At the signer’s side, the signature generation time and private key size were evaluated on both types of devices. The energy consumption and code size were evaluated on a low-end device. (ii) The signature size is evaluated as the communication overhead. (iii) At the verifier’s side, the signature verification time and the size of public key were evaluated on the commodity hardware.

Note that the time required to transmit the ESEM signature (only $48$ Bytes) is already smaller than all of its counterparts. Therefore, we do not include this in our experiments. The bandwidth overhead to construct $R$ between the verifier and $l$ parties is only $48$ Bytes, and highly depends on the geographic location of the server (i.e., round trip time). We conservatively benchmark this network delay and include in our signature verification time, with an Amazon EC2 server in North Virginia.

Hardware Configurations and Software Libraries: We selected AVR ATmega 2560 microcontroller as our low-end device due to its low power consumption and extensive use in practice, especially for medical devices [1, 2, 20]. It is an 8-bit microcontroller with $256$ KB flash memory, $8$ KB SRAM, $4$ KB EEPROM and maximum clock speed is $16$ MHz.

We implemented our schemes using Rhys Weatherley’s library111https://github.com/rweather/arduinolibs/tree/master/libraries/Crypto, which enables Barrett reduction to compute modulo $q$. We used BLAKE2s [21] as our hash function from the same library, since it is optimized for low-end devices in terms of speed and code size. We instantiated our PRF function as CHACHA20 stream cipher [22] which offers high efficiency. To assess our counterparts, we used ECDSA implementation in microECC222https://github.com/kmackay/micro-ecc, with which we also implemented BPV-ECDSA. We used the implementations on same microcontroller to assess Ed25519 [23] and SchnorrQ [24].

We powered the microcontroller with a $2200$ mAh power pack. ATmega 2560 operates at a voltage level of $5$ V and takes $20$ mA current333http://www.atmel.com/Images/Atmel-2549-8-bit-AVR-Microcontroller-ATmega640-1280-1281-2560-2561_datasheet.pdf. We verified the current readings taken from datasheets by connecting an ammeter between the battery and ATmega 2560, and we observed an insignificant difference. Therefore, we measured the energy consumption with the formula $E=V\cdot I\cdot t$ where $t$ is the computation time. To account the variations in time $t$, we run each scheme $10^{4}$ times and took the average.

We also investigated the effect of cryptography on the battery life in some real-life IoT applications. For this purpose, we measured the energy consumption of a pulse sensor444https://pulsesensor.com/ and a BMP183 pressure sensor555https://cdn-shop.adafruit.com/datasheets/1900_BMP183.pdf. We expect that the pulse and pressure sensors provide some ideas on the use of digital signatures with sensors in medical devices and daily IoT applications, respectively.

$\bullet$ Commodity Hardware: We used an Intel i7-6700HQ $2.6$ GHz processor with $12$ GB of RAM as the commodity hardware in our experiments. We implemented the arithmetic and curve operations of our scheme with FourQlib666https://github.com/Microsoft/FourQlib. We used BLAKE2b [21] as our hash function since it is optimized for commodity hardware. Lastly, we instantiated our PRF with AES in counter mode using Intel intrinsics. For our counterparts, we used their base implementations.

As the semi-honest party, we used an Amazon EC2 instance located in North Virginia. Our EC2 instance was equipped with an Intel Xeon E5 processor that operates at $2.4$ GHz.

Our implementations are open-sourced at:

www.github.com/ozgurozmen/ESEM

V-C Performance Evaluation and Comparisons

Low-end Device: Table I shows the results obtained from our implementations on 8-bit AVR ATmega 2560.

$\bullet$ Signature Generation Speed: ESEM has the fastest signing speed, which is 8.4$$\times and 55$$\times faster than that of SchnorrQ and Ed25519, respectively.

$\bullet$ Energy Consumption of Signature Generation: With a $2200$ mAh battery, ESEM can generate nearly $800000$* signatures, whereas SchnorrQ, Ed25519 and ECDSA can generate only $94482$, $14235$ and $6173$ signatures, respectively. This shows that, ESEM can generate significantly higher number of signatures with the same battery.*

$\bullet$ Energy Consumption of Signature Generation versus IoT Sensors: We considered a pulse and a pressure sensor to exemplify the potential medical and home automation IoT applications, respectively. We selected the sampling time (i.e., the frequency of data being read from the sensor) as every 10 seconds and every 10 minutes for the pulse and pressure sensor, respectively, to reflect their corresponding use-cases. We measured the energy consumption by considering three aspects: (i) Each sensor by default draws a certain energy as specified in its datasheet. The pulse sensor operates at $3$ V and draws $4.5$ mA of current, while pressure sensor operates at $2.5$ V and draws 5 $\mu$A of current. These values are multiplied by their corresponding sampling rates to calculate the energy consumption of the sensor. (ii) AVR ATmega 2560 consumes energy to make readings from the sensor as well as during its waiting time. We measured the time that takes the microcontroller to have a reading from the sensor as $1$ ms. Therefore, we calculated the energy consumption of the microcontroller on active time as $5V\cdot 20mA\cdot 1ms$. (iii) ATmega 2560 requires $10$ $\mu$A in power-save mode, which is used to calculate the energy consumption in the idle time.

We compared the energy consumption of signature generation and IoT sensors in Figure 2. ESEM* reduces the energy consumption of signature generation to $2.76$% and $9.29$% compared to that of pulse and pressure sensors, respectively*. Observe that, compared with the pressure sensor, SchnorrQ as the fastest counterpart of ESEM, requires $46.24$%, while Ed25519 demands $85.09$% of the energy consumption. When the pulse sensor is used, while ESEM requires an almost negligible energy consumption ($2.76$%), its closest counterpart requires $19.29$%. The energy efficiency of ESEM also translates into longer battery life in these applications. More specifically, when pressure sensor is deployed with ESEM, it takes $511$ days to drain a $2200$ mAh battery, while it is $303$ days for our closest counterpart (SchnorrQ).

Our experiments show that the existing ECC-based digital signatures consume more energy than IoT sensors, which make them the primary source of battery consumption. On the other hand, ESEM* was able to reduce the signature generation overhead to a potentially negligible level in some cases, at minimum offering improvements over its counterparts.*

Commodity Hardware: The benchmarks of ESEM and its counterparts on commodity hardware are shown in Table II.

$\bullet$ Signature Generation: ESEM and ESEM2 schemes offer the fastest signature generation on commodity hardware as well. Especially ESEM2 (the high-speed variant where private key components are stored instead of generating them from a seed), is 3$\times$ faster than its closest counterpart.

$\bullet$ Signature Verification: The signature verification in ESEM includes verifier computation, server computation and communication between the verifier and servers. Due to the computational efficiency of FourQ curve, verifier and server computation of ESEM verification is highly efficient. Specifically, verifier computation takes $24$ $\mu$s in ESEM and ESEM2; and server computation takes $5$ $\mu$s, and $10$ $\mu$s for ESEM and ESEM2, respectively. The communication between server and verifier is experimented with our commodity hardware and an Amazon EC2 instance at N. Virginia. This delay was measured as $37$ ms on average.

The fastest verification is observed at SchnorrQ scheme, that is $22$ $\mu$s. This scheme should be preferred if the verification speed is of high importance. However recall that for our envisioned applications, the signer efficiency (energy efficiency) is of top priority and a small delay at the verifier is tolerable.

VI Related Work

There are two main lines of work to offer authentication for embedded medical devices: symmetric key primitives (e.g., MACs) and public key primitives (e.g., digital signatures). In this section, we only mention lightweight digital signature schemes that are most relevant to our work.

One-time signatures (e.g., [6, 25, 26]) offer high computational efficiency, but usually have very large key and signature sizes that hinder their adoption in implantable medical devices. Moreover, they can only sign a pre-defined number of messages with a key pair, which introduce a key renewal overhead. The extensions of hash-based one-time signatures to multiple-time signatures (e.g., SPHINCS [27]) have high signing overhead, and therefore are not suitable for medical implantables. Some MAC based alternatives (e.g., TESLA [28, 29]) use time asymmetries to offer computational efficient and compactness, they cannot offer non-repudiation and require a continuous time synchronization. EC-based digital signatures (e.g., [11, 13, 24, 30, 31, 32]) are currently the most prevalent alternatives to be used on embedded devices due to their compact size and higher signing efficiency compared to RSA-based signatures (e.g., CEDA [33]). We provided a detailed performance comparison of ESEM with its most recent EC-based alternatives in Section V.

VII Conclusion

In this paper, we proposed ESEM, that achieves the least energy consumption, the fastest signature generation along with the smallest signature among its ECC-based counterparts. ESEM is also immune to side-channel attacks aiming EC operations/exponentiations as well as to weak pseudo random number generators at the signer’s side, since ESEM does not require any of these operations in its signature generation algorithm. We believe ESEM is highly preferable for applications wherein the signer efficiency is a paramount requirement, such as implantable medical devices. We implemented ESEM and its counterparts both on a resource-contrained device commonly used in medical devices and a commodity hardware. Our experiments validate the significant energy efficiency and speed advantages of ESEM at the signer’s side over its counterparts.

Acknowledgments. This work is supported by the NSF Award #1652389.