An Overflow Problem in Network Coding for Secure Cloud Storage

TL;DR

This paper identifies an overflow issue in network coding for secure cloud storage, analyzes its impacts, and proposes the NCSS scheme to improve storage efficiency and security in distributed cloud environments.

Contribution

It introduces the overflow problem in network coding storage systems and develops the NCSS scheme to address security and storage efficiency challenges.

Findings

Overflow causes storage waste and reduces coding efficiency.

NCSS improves storage cost and processing time.

Design guidelines for secure, efficient cloud storage.

Abstract

In this paper we define the overflow problem of a network coding storage system in which the encoding parameter and the storage parameter are mismatched. Through analyses and experiments, we first show the impacts of the overflow problem in a network coding scheme, which not only waste storage spaces, but also degrade coding efficiency. To avoid the overflow problem, we then develop the network coding based secure storage (NCSS) scheme. Thanks to considering both security and storage requirements in encoding procedures and distributed architectures, the NCSS can improve the performance of a cloud storage system from both the aspects of storage cost and coding processing time. We analyze the maximum allowable stored encoded data under the perfect secrecy criterion, and provide the design guidelines for the secure cloud storage system to enhance coding efficiency and achieve the minimal storage cost.

Tables

Table 1. TABLE I: Example of the overflow problem for binary digits

$𝐀$	$𝐛$	$𝐜$
	${(0,1,1)}^T$	${(2,3,5)}^T$=${(10,11,101)}^T$

Table 2. TABLE II: Example of the definitions for overflow problem

	$𝐀$	$𝐛$	$𝐜$	${\widetilde{𝐜}}_1=(c_1,c_3)$	${\widetilde{𝐜}}_2=\left(c_2\right)$	strictly non-overflow	$3$-bounded non-overflow
Case1		${(0,1,0)}^T$	${(1,1,1)}^T$	$(1,1)$	$\left(1\right)$	Yes	Yes
Case2		${(0,1,1)}^T$	${(10,11,101)}^T$	$(10,101)$	$\left(11\right)$	No	Yes

Table 3. TABLE III: Notations in this paper

Notations	Descriptions
$𝐛$	Original data array
$d$	Base of $b_i$
$l_d\left(a\right)$	Number of digits that represents $a$ in base $d$
$𝐀$	Encoding matrix
$k$	Use Galois Field size $2^k$ for $𝐀$
$n$	Matrix size of $𝐀$
$p$	Total number of cloud databases
$𝐜$	Encoded data vector
${\widetilde{𝐜}}_i$	Encoded data vector that stored in the $i$-th cloud database
$\left|{\widetilde{𝐜}}_i\right|$	Number of elements in ${\widetilde{𝐜}}_i$
$s_i$	Number of digits in $b_i$
${𝐛}^{\prime }$	Regrouped data array
$r$	Size of ${𝐛}^{\prime }$
$P_{e_i}$	Probability of the $i$-th cloud database can resist attacks
$P_g$	Probability that an eavesdropper can guess the original data
$P_u$	Security requirement: Maximum probability that an eavesdropper can guess the original data

Table 4. TABLE IV: Example of adopting NCSS scheme in storing encoded data to two cloud databases

$𝐛$	$d$	$k$	$s$	${𝐛}^{\prime }$	$r$	$n$	$𝐀$	$𝐜$	$\widetilde{𝐜}$
$(0,0,1,0,1,1,1,0,1)$	$2$	$3$	$3$	$(001,011,101)$	$3$	$3$		$(010,100,001)$	$(0101,00001)$

Equations

$$\sum _{j=1}^{|{\tilde{\mathbf{c}}}_i|}{l}_d(c_j)\le \left|{\tilde{\mathbf{c}}}_i\right|\alpha l_d(b_i),$$

$$\frac{k}{{\log }_{2}d}=k{\log }_{d}2={\log }_d{2}^k.$$

$$s_i=l_d(b_i)\le {\log }_d(2^k-1)=l_d(c_i{)}_{\max }.$$

$$\sum _{j=1}^{|{\tilde{\mathbf{c}}}_i|}{l}_d(c_j)\le$$

$$=$$

$$\le$$

$$=$$

$$\sum _{j=1}^{|{\tilde{\mathbf{c}}}_i|}{l}_d({\tilde{c}}_i(j))\le \sum _{t=1}^n{l}_d(c_t)+{\log }_d{P}_u-{\log }_d(1-P_{e_i}),$$

$$P_g$$

$$\le (1-P_{e_i})d^{{\log }_d{P}_u-{\log }_d(1-P_{e_i})}$$

$$=P_u.$$

$$(1-P_{e_i})d^{-(\sum _{t=1}^n{l}_d(c_t)-\sum _{j=1}^{|{\tilde{\mathbf{C}}}_i|}{l}_d({\tilde{c}}_i(j)))}\le P_u.$$

$$H(\mathrm{S}|E)=H(\mathrm{S}),$$

$$H({\mathbf{b}}^{(w)})$$

$$=$$

$$\le$$

$$H(\mathbf{c}|{\mathbf{b}}^{(w)})-H({\mathbf{c}}_{p+1:p+t}|{\mathbf{b}}^{(w)})=H({\mathbf{c}}_{p+t+1:n}|{\mathbf{b}}^{(w)},{\mathbf{c}}_{p+1:p+t}).$$

$$H({\mathbf{b}}^{\left(w\right)})$$

$$H(\mathbf{c})\le nH(b).$$

$$\displaystyle{{\rm{\mathbf{M}}}_{{\rm{p}}+1:{\rm{p}}+{\rm{t}}}}=\left[{\begin{array}[]{*{20}{c}}{m_{1}^{p}}\\ \vdots\\ {m_{1}^{p+t-1}}\end{array}\begin{array}[]{*{20}{c}}{...}\\ \vdots\\ {...}\end{array}\begin{array}[]{*{20}{c}}{\rm{|}}\\ {\rm{|}}\\ {\rm{|}}\end{array}\begin{array}[]{*{20}{c}}{}\hfil\\ {{{\bf{I}}_{t}}}\\ {}\hfil\end{array}\begin{array}[]{*{20}{c}}{\rm{|}}\\ {\rm{|}}\\ {\rm{|}}\end{array}\begin{array}[]{*{20}{c}}{...}\\ \vdots\\ {...}\end{array}\begin{array}[]{*{20}{c}}{m_{n}^{p}}\\ \vdots\\ {m_{n}^{p+t-1}}\end{array}}\right]\enspace,$$

$$H({\mathbf{c}}_{p+1:p+t})=tH(b).$$

$$tH(b)\le nH(b)-\mathrm{wH}(\mathrm{b}).$$

$$I\left({\mathbf{c}}^{(\tilde{w})};\mathbf{b}\right)=0.$$

$$H({\mathbf{b}}^{(w)}|{\mathbf{c}}_{p+1:p+t},{\mathbf{c}}^{(\tilde{w})})=H({\mathbf{b}}^{(w)}|{\mathbf{c}}_{p+1:p+t}).$$

$$I\left({\mathbf{c}}_{p+1:p+t},{\mathbf{c}}^{(\tilde{w})};{\mathbf{b}}^{\left(w\right)}\right)=I\left({\mathbf{c}}_{p+1:p+t};{\mathbf{b}}^{\left(w\right)}\right).$$

$$\text{minimize }f(n,l)=n^{2}s+\alpha l\text{hfill}$$

$$\text{subject to }(1-P_e{)}^p{d}^{-\alpha l}⩽P_u\text{hfill}$$

$$2⩽n⩽2^k\text{hfill}$$

$$l⩽n\text{hfill}$$

$$\alpha ns=m\text{hfill}$$

$$n,l\in {\mathbb{Z}}^{+},$$

$$\text{minimize }\tilde{f}(n,l)=\frac{k}{{\log }_{2}d}{n}^2+\frac{m{\log }_{2}d}{k}{n}^{-1}l\text{hfill}$$

$$\text{subject to }-\frac{k}{m{\log }_{2}d}{\log }_d\frac{P_u}{{(1-P_c)}^p}n⩽l⩽n\text{hfill}$$

$$2⩽n⩽2^k\text{hfill}$$

$$n,l\in {\mathbb{Z}}^{+}.$$

$$\displaystyle H(\tilde{f})=\left[{\begin{array}[]{*{20}{c}}{2a+2bl{n^{-3}}}&{-b{n^{-2}}}\\ {-b{n^{-2}}}&0\end{array}}\right]\enspace,$$

$$\det (H(\tilde{f})-\lambda I)={\lambda }^2-(2a+2bl{n}^{-3})\lambda -b^2{n}^{-4}=0.$$

Full text

I Introduction

Network coding is an attractive solution for secure cloud storage because of achieving the unconditional security. As long as protecting partial network coded data, a non-collusive eavesdropper cannot decode any symbol even with huge computing power for infinite time [1]. In principle, network coding simply mixes the data from different network nodes based on the well-designed linear combination rules. Hence, almost incurring no bandwidth expansion is another advantage of network coding.

A secure cloud storage using network coding is illustrated in Fig. 1. The original file is split into smaller chunks of symbols, each of which is encoded by Vandermonde matrix [2]. The different subsets of the encoded data are stored to two cloud databases. A legitimate user with access to two cloud databases can recover the entire original file. However, an eavesdropper with access to only one of the two cloud databases is unable to decode any of the original symbols [3]. In summary, the network coding storage system consists of three procedures: splitting, encoding, and distributing to storage nodes.

Nevertheless, a secure network coding storage system may encounter a practical design issue when encoding parameters (such as the size of encoding matrix) is not jointly designed with the storage parameters (such as the storage size per node). If the mismatch between encoding and storage parameters occurs, it can cause bandwidth expansion and redundant computation cost. We coin the term the overflow problem for secure network coding storage system in this paper because the mismatch of encoding and storage parameters results in extended length of coded data in the format of digits.

Table I shows an example of the overflow problem for binary digits, where ${\bf{A}}$ is the encoding matrix for network coding, ${b_{i}}$ and ${c_{i}}$ are the original data, and network coded data, respectively. Assume that ${c_{1}}$ and ${c_{3}}$ are stored in the first database, and $c_{2}$ is stored in the second database. We can see that the bit length of coded ${c_{i}}$ is larger than that of ${b_{i}}$ for $i=1\sim 3$. Also, the minimum bit length required for storing ${c_{1}}$ and ${c_{3}}$ is three in the first database, but in the second database the minimum bit length for storing $c_{2}$ is two.

To overcome the overflow problem, we propose a systematic design methodology to calculate the important system parameters of a network-coded cloud storage system. The major objective of the proposed scheme is to provide correct mapping between the encoding parameters and the storage parameters. The contributions of this work are explained as follows.

• •

Formulate the overflow problem of a network-coded cloud storage system, and perform experiments to show the impacts of the overflow problem, which not only waste storage spaces, but degrade computational efficiency.

• •

Propose a network coding based secure storage (NCSS) scheme to solve the overflow problem. To our best knowledge, the overflow problem for a network-coded storage system has not been investigated in the literature yet.

• •

Derive the upper bound of the amount of encoded data that can be stored in cloud databases to achieve the unconditional security level (i.e., perfect secrecy). Based on the derived upper bound, we present the analysis of storage cost minimization in the proposed NCSS scheme subject to different security levels.

• •

Finally, based on the experimental results, we suggest the design guidelines for determining important system parameters (e.g., the size of the encoding matrix) to accelerate the network coding process.

The rest of this paper is organized as follows. Section II describes related works. In Section III, we formulate the overflow problem in cloud storage using network coding. In Section IV, we present the NCSS scheme. In Section V we give the security and storage analyses of the proposed scheme. Section VI shows the experimental results. Finally, we give our concluding remarks in Section VII.

II Background and Related Work

Network coding can be viewed as a generalized store-and-forward network routing principle. Messages from different source nodes are combined and regenerated at the intermediate nodes according to algebraic encoding. Besides the well-known advantages of throughput enhancement [4, 5, 6] and data robustness [7], the recent studies on network coding focus on reliability and security enhancement.

II-A Network Coding for Data Recovery

Network coding can improve the efficiency of data recovery process when storage nodes fail in distributed storage systems. It was proved that the data recovery problem of distributed storage systems is equivalent to the multicasting problem of network routing [8]. The authors of [9] designed a cooperative network coding recovery mechanism for multiple node failures. A proxy-based multiple cloud storage system with the feature of fault tolerance was built based on the network coding storage scheme [10]. A network coding method called Regenerating Code was proposed to improve the repair process of distributed storage systems [11]. Different from erasure coding, the repaired data fragments are mixed in intermediate nodes, thereby reducing the repair bandwidth. The authors of [12] applied network coding to optimize the reliability performance of frequently accessed data in cloud storage systems.

II-B Network Coding for Data Security

Another research area of network coding is to prevent data being eavesdropped during transmission. The information-theoretical security problem for an untrusted channel was first discussed in [13]. A network coding system was built to prove that a wiretapper cannot obtain any information from the transmitted message [14]. A weaker type of security issue was investigated in[15], where a node can decode packets only after receiving sufficient linear independent encoded data. The construction of a secure linear network code for a wiretap network was presented in [16].

The secrecy capacity for a network-coded cloud storage system was investigated in [17, 18], where the secrecy capacity is defined as the maximum amount of data that can be securely stored under the perfect secrecy condition. The perfect secrecy condition ensure the eavesdropper cannot obtain any information of source data. The secrecy capacity for nodes with different storage capacities was derived in [19]. The coding scheme that can achieve the storage upper bound of secrecy capacity was proposed in [20]. The maximum data size being stored under the perfect secrecy condition for any number of eavesdropped nodes was determined in [21]. The authors of [22] considered how to achieve the information-theoretical secrecy when an eavesdropper can access some data in the storage nodes.

For secure storage over multiple clouds, similar to this work, the authors of [3] proposed a security protection scheme to ensure that no symbols can be decoded by an eavesdropper, which is weaker than perfect secrecy. In [23], a link eavesdropping problem in a network-coded cloud storage system was investigated. A publicly verifiable protocol for network coded cloud storage was proposed in [24].

II-C Objective of This Paper

Different from the previous works focusing on the security and reliability enhancement of network coding, in this paper we focus on the storage efficiency and perfect security when applying network coding in multiple untrusted clouds. We define the overflow problem when network coding is applied in a cloud storage system, which has not been discussed previously. The overflow problem will result in extra extended encrypted data in the format of digits during encoding process, thereby increasing storage and computation cost. To overcome the overflow problem, we develop a systematic design methodology for calculating the encoding and storage parameters of a network-coded cloud storage system. Based on the proposed method, we further solve the storage cost optimization problem under the perfect secrecy constraint. The ultimate goal of this paper is to demonstrate that the performance of a network-coded cloud storage system can be improved by jointly designing the encoding and storage and parameters.

III System Model and Problem Statement

Now we describe the coding scheme adopted in this paper and give the formal definition of the overflow problem.

III-A Coding Scheme

Consider the original data vector ${\bf{b}}={({b_{1}},\ldots,{b_{n}})^{T}}$ with base ${d}$, where elements ${b_{i}}$ are independent random integers uniformly distributed over ${\left\{{0,\ldots,d-1}\right\}}$. We use the terms original data and plaintext data interchangeably in this paper. The goal of a cloud user is to securely store ${\bf{b}}$ to multiple cloud databases. To achieve this goal, we adopt the same network coding scheme as [3], in which the input data are mapped to encoded symbols by linear transformation.

Denote ${\bf{A}}$ as an $n\times n$ Vandermonde matrix, where $\left[{{A_{i,j}}}\right]=(a_{j}^{i-1})$. ${\bf{A}}$ is used for the encoding matrix, where all the coefficients ${a_{i}}$ are distinct nonzero elements over a finite field ${F_{q}}$, $q={2^{k}}>n$. Note that ${\bf{A}}$ can be a $(n+m)\times n$ matrix, where the the amount of redundancy $m$ depends on the reliability requirement of the storage system.

A cloud user encodes data ${\bf{c}}={({c_{1}},\ldots,{c_{n}})^{T}}={\bf{Ab}}$ and splits the encoded data into ${p}$ parts. We assume the cloud user can arbitrarily store any piece of the encoded data to any cloud database. Let ${{{\bf{\tilde{c}}}_{i}}(i=1,\ldots,p)}$ be the encoded data vector stored in the ${i}$-th cloud database. A legitimate user can collect ${{{\bf{\tilde{c}}}_{i}}}$ from the cloud databases and obtain the original data by performing ${{{\bf{A}}^{{\bf{-1}}}{\bf{c}}}}$.

III-B Security Model

Assume that an eavesdropper has infinite computing power, but can access only one cloud database. Also, it is assumed that the eavesdropper can have the full information about the encoding and decoding schemes, including the knowledge of the encoding matrix. The objective of an eavesdropper is to guess the original data. Although we consider only one eavesdropper in this paper, our result can be extended to the case of multiple eavesdroppers.

In our considered cloud storage system, every cloud database can support different security levels [25]. Denote ${P_{{e_{i}}}}$ as the probability that the ${i}$-th cloud database can resist attacks. Also, the cloud user specifies a security requirement ${P_{u}}$, which represents the maximum probability that an eavesdropper can guess the original data. Next, we will show how to solve the overflow problem subject to the constraints of the security requirement when considering distributing encoded symbols to multiple cloud databases.

III-C Overflow Problem

Although it was proved that the aforementioned network coding scheme can help prevent eavesdroppers from obtaining the information of the original data [1], the overflow problem occurs from the encoding process and the storage process. Specifically, if the encoding parameter and the storage parameter are mismatched, the length of encoded data in digital format may become larger than the length of the original data in digital format. As a result, storage spaces are wasted due to redundant encoded data. Now we formally state this problem by introducing the following definition.

Definition 1** (Strictly Non-overflow).**

*Let ${{l_{d}}(a)}$ be the number of digits that represents ${a}$ in base ${d}$. A piece of encoded data ${\bf{c}}={({c_{1}},\ldots,{c_{n}})^{T}}$ is considered to be strictly non-overflow if and only if ${{l_{d}}({c_{i}})\leq{l_{d}}({b_{i}})}$ for every $i$. Thus, the length of the encoded data is equal to that of the plaintext data. *

Definition 2** (${\alpha}$-bounded Non-overflow).**

Let ${\left|{{{{\bf{\tilde{c}}}}_{i}}}\right|}$ denote the number of elements in ${{{\bf{\tilde{c}}}_{i}}}$. A piece of encoded data ${\bf{c}}={({c_{1}},\ldots,{c_{n}})^{T}}$ is considered to be ${\alpha}$-bounded Non-overflow if and only if

[TABLE]

*for ${1\leq i\leq p}$. *

Assume the encoded data are randomly stored in cloud databases. Hence, the increasing cost of storage or computation resources caused by data extension can be measured by the extension degree ${\alpha=\frac{{{l_{d}}({c_{i}})}}{{{l_{d}}({b_{i}})}}}$ of the encoded data in the cloud database. Table II show the coding results for the two different overflow cases where $d=2$ and $p=2$. In case 1 there are no redundant digits after the encoding process, but in case 2 the extension degree is bounded by $3$.

IV Network Coding based Secure Storage (NCSS) Scheme

In this section, we analyze the overflow problem of a network-coded cloud storage system. We first give the criteria to choose the proper length of the data element to be encoded. Next, we present the data distribution method for achieving the required security level. Finally, we describe the system design methods of the NCSS scheme. Table III summarizes the notations used in this paper.

IV-A Coding Analysis

The following theorem can help calculate the encoding parameters to avoid the overflow problem of the secure network coding storage system.

Theorem 1**.**

*Let ${s_{i}}$ be the number of digits in ${b_{i}}$. Then, the system is strictly non-overflow if ${s_{i}}=s=\frac{k}{{{{\log}_{2}}d}}\enspace.$ *

Proof.

First, we assume that ${s_{i}}<\frac{k}{{{{\log}_{2}}d}}$. Then, we have

[TABLE]

Because the coding process is manipulated with integers, we have ${s_{i}}\leq{\log_{d}}({2^{k}}-1)$. Since ${c_{i}}$ is distributed over $\left\{{0,\ldots,{2^{k}}-1}\right\}$, the maximum number of digits used to represent an encoded element is ${l_{d}}{({c_{i}})_{\max}}={\log_{d}}({2^{k}}-1)$. Furthermore, the number of digits in ${b_{i}}$ can be represented as ${l_{d}}({b_{i}})$. Thus, we have

[TABLE]

As a result, the overflow problem occurs because the length of encoded data may be larger than the length of the original data. Secondly, we assume that ${s_{i}}>\frac{k}{{{{\log}_{2}}d}}$. We take exponentiation with base $d$ on both sides and we have ${d^{{s_{i}}}}>{d^{{{\log}_{d}}{2^{k}}}}={2^{k}}$ from (1). Since ${b_{i}}={d^{{s_{i}}}}$, it contradicts the fact that the maximum value of ${b_{i}}$ is ${2^{k}}-1$. Hence, it follows that ${s_{i}}=s=\frac{k}{{{{\log}_{2}}d}}$.

Theorem 2**.**

*The system is ${\alpha}$-bounded non-overflow if ${s_{i}}\geq\frac{1}{\alpha}{\log_{d}}({2^{k}}-1)$ for every $i$. *

Proof.

Since ${s_{i}}={l_{d}}({b_{i}})$ and ${l_{d}}{({c_{i}})_{\max}}={\log_{d}}({2^{k}}-1)$, we have

[TABLE]

Theorem 1 and 2 give the criteria of selecting the length of the plaintext data element. Next, we relate the security requirement to the amount of encoded stored data.

Theorem 3**.**

The system satisfies the security requirement ${P_{u}}$ if

[TABLE]

*for $1\leq i\leq p$. *

Proof.

Recall that an eavesdropper can access only one cloud database. Hence, the probability ${P_{g}}$ that an eavesdropper can guess the original data is the product of the invasion probability of the cloud database and the probability of guessing the remaining encoded digits. It follows that

[TABLE]

IV-B System Design

The proposed NCSS scheme can be divided into three steps. First, a dynamic-length alphabet representation of network coded data is adopted based on Theorem 1 and Theorem 2. Second, the original data are preprocessed and regrouped before the encoding process. Third, the regrouped data are encoded and distributed to the corresponding cloud databases.

Figure 2 shows the system flow of the proposed NCSS scheme. Assume that a cloud user wants to store a single-digit data array ${\bf{b}}={({b_{1}},\ldots,{b_{m}})^{T}}$ with base $d$ to the $p$ cloud databases. We first choose a power $k$ for the field characteristics according to the following condition.

Condition 1**.**

${2^{k}}\geq d$* *

The field size must be larger than the maximal value of the data array element $d-1$. Otherwise, some data elements cannot be represented in the field. After that, a proper length of data elements ${s_{i}}$ can be decided according to Theorem 1 and Theorem 2. This step is called dynamic length alphabet representation. We then regroup ${\bf{b}}$ to ${{\bf{b}}^{\prime}}=({b_{1}}...{b_{{s_{1}}}},{b_{{s_{1}}+1}}...{b_{{s_{1}}+{s_{2}}}},\cdots,{b_{{{\hat{s}}_{r-1}}+1}}...{b_{{{\hat{s}}_{r}}}})$ based on the value of ${s_{i}}$, where ${{\hat{s}}_{r}}\buildrel\Delta\over{=}\sum\limits_{i=1}^{r}{{s_{i}}}$. Next, we generate an $n\times n$ encoding matrix ${\bf{A}}$ with the following condition.

Condition 2**.**

$n<{2^{k}}$* and $n\leq r$ *

Since matrix ${\bf{A}}$ is constructed from $n$ distinct elements over the Galois Field, we have $n<{2^{k}}$. In addition, the matrix multiplication cannot be operated if the size of encoding matrix is larger than the size of regrouped data array. We then encode ${\bf{b}}^{\prime}$ with ${\bf{A}}$ and obtain the encoded data array ${\bf{c}}={({c_{1}},\ldots,{c_{n}})^{T}}$. Finally, ${\bf{c}}$ can be regrouped to ${\bf{\tilde{c}}}$ by Theorem 3, which specifies the maximum amount of encoded data that can be stored in a cloud database according to user’s security requirement. Finally, the elements of ${\bf{\tilde{c}}}$ are distributed to the corresponding $p$ cloud databases.

Table IV shows an example of the proposed NCSS scheme in the strictly non-overflow case. We assume that the original data is ${\bf{b}}=\left({0,0,{\rm{1}},0,{\rm{1}},{\rm{1}},{\rm{1}},0,{\rm{1}}}\right)$ and the encoded data are stored to two cloud databases with ${P_{{e_{1}}}}=0.5$, ${P_{{e_{2}}}}=0.25$, and ${P_{u}}=\frac{1}{{64}}$. From Theorem 3, the maximal numbers of digits that can be stored in the first and the second cloud database are $4$ and $5$, respectively.

V Security Analysis

In this section, we analyze the proposed NCSS scheme in terms of security level and storage cost. First, we discuss the issue of enhancing security level from a system design aspect. Then we derive the upper bound of data size that can be stored in the cloud under the constraint of perfect secrecy.

To begin with, from (4) we know that the lower bound of the security requirement ${P_{u}}$ is

[TABLE]

Since ${l_{d}}({c_{t}})$ is proportional to the size of Galois Field, it is anticipated that a larger size of encoding matrix $n$ and a large value of power $k$ of the field characteristics can result in a higher security level for the network coding storage system. However, increasing these encoding parameters can result extra coding complexity. Next, we show that the security level can be enhanced to the perfect secrecy by storing a certain amount of encoded data in the local machine. The notion of perfect secrecy represents that an eavesdropper can get no information of the original message.

Definition 3** (Perfect Secrecy Criterion [26]).**

Let $S$ denote the random variable associated with the secret data fragments and $E$ denote the random variable associated encoded fragments observed by the eavesdropper. The perfect secrecy requires

[TABLE]

*where H(X) represents the entropy of a random variable $X$. *

In the worst case, an eavesdropper can access the encoded data of all the cloud databases. The following theorem can be applied to specify the maximal amount of encoded data fragments that can be stored in the cloud, while keeping the rest of data in a local machine to ensure perfect secrecy.

Theorem 4**.**

*Assume that $w$-digit secret information is encoded with $n-w$-digit data ${\bf{b}}$. For both strictly non-overflow and ${\alpha}$-bounded non-overflow schemes, a cloud user can store at most $\sum\limits_{j=1}^{n}{{l_{d}}}({c_{j}})-w$ digits of encoded data to the cloud under the perfect secrecy criterion. *

Proof.

Let $\mathbf{e}^{(h)}$ represent a subset containing any $h$ components of vector $\mathbf{e}$. We use $\mathbf{e}_{i:j}$ to denote the subvector formed from the $i$-th to the $j$-th position of vector $\mathbf{e}$. The set of rows from the $i$-th to the $j$-th position of matrix $\mathbf{D}$ is represented as $\mathbf{D}_{i:j}$. In addition, $b_{i}$ are independent random variables uniformly distributed over $\mathbf{F_{\emph{q}}}$ with entropy $H(b_{i})=H(b)$.

For simplicity, without loss of generality, assume that $t$ contiguous components of the encoded data $\mathbf{c}_{p+1:p+t}$ are stored to the clouds. Then we can obtain

[TABLE]

In the above equations, (5) holds because of the perfect secrecy criterion and due to the fact that the secret information can be reconstructed if the entire codewords are given. In (8), we have $H({{\bf{c}}_{p+1:p+t}}|{{\bf{b}}^{(w)}})-H({\bf{c}}|{{\bf{b}}^{(w)}})\leq 0$ since

[TABLE]

Since $b_{i}$ are i.i.d random variables, it follows that

[TABLE]

where $seq(j)$ is the $j$-th element of a random integer sequence within the range $1$ to $n$. Because the encoded data vector $\mathbf{c}$ contains the entire information of $\mathbf{b}$ at most, we can obtain

[TABLE]

Moreover, the $n\times n$ Vandermonde matrix $\mathbf{A}$ is nonsingular [2]. Thus the eavesdropper can apply the Gaussian elimination to obtain the reduced row echelon form of the submatrix $\mathbf{S}$, whose elements are $[S_{i,j}]=[A_{i,j}]$ for $p+1\leq i,j\leq p+t$. The Eavesdropper Reduced Matrix $\mathbf{M}$ can be obtained as

[TABLE]

where the other element of $\mathbf{M}$ are the same as $\mathbf{A}$. Hence, the eavesdropper have $t$ equations to solve $n$ unknown elements. It implies that

[TABLE]

Substituting (9), (33) and (10) into (8), we obtain

[TABLE]

The above equation shows that we can store at most the $n-w$ components of encoded data to the clouds under perfect secrecy criterion. For the strictly non-overflow scheme, we have only one digit in each component of encoded data. Thus, we can store at most $\sum\limits_{j=1}^{n}{{l_{d}}}({c_{j}})-w$ digits of encoded data to the clouds, while keeping the remaining $w$ digits in the local machines. However, we may have multiple digits in each component of encoded data for ${\alpha}$-bounded non-overflow scheme. Let ${\mathbf{e}^{(\tilde{h})}}$ represent a subset containing any $w$ fragmentary components of vector $\mathbf{e}$. With at least $n$ unknown digits, knowing ${\mathbf{c}^{(\tilde{w})}}$ cannot help solve $\mathbf{b}$. As a result, it follows that

[TABLE]

Not that we still have $t$ equations to solve $n$ unknown elements. That is,

[TABLE]

Finally, we obtain

[TABLE]

Consequently, we can select $w$ digits of encoded data from different $w$ components, i.e., select one digit for each component. These $w$-digit encoded data can be stored in the local machines, while the remaining $\sum\limits_{j=1}^{n}{{l_{d}}}({c_{j}})-w$ digits are stored to the clouds.

VI Storage Minimization

We are motivated to analyze the amount of stored encrypted data with the security requirement in terms of the probability that an eavesdropper can correctly guess the original data. This is because only a certain amount of encoded data fragments can be stored in the local machines to enhance the security level, as shown in the previous section. As the required security level increases, the amount of encoded data stored at the local site should increase.

VI-A Solving Storage Minimization Problem

Consider a cloud user keeps encoded data with length $l$ in each encoding operation and stores the remaining encoded data to $p$ cloud databases as shown in Fig. 3. We assume all the cloud databases have the same capability of preventing attacks (i.e., ${P_{{e_{i}}}}$=${P_{{e}}}$) and the security requirement is ${P_{{u}}}$, which specifies the maximum probability that an eavesdropper can guess the original message. In addition to the encoded data, the encoding matrix is stored at the local site.

The storage cost at the local site is the function of encoding matrix size $n$ and the amount of encoded data stored at a local machine for every encoding operation, denoted by $l$. Let ${m}$ denote the length of the original message and $\alpha$ represent the number of encoding operations. Subject to a given security requirement ${P_{{u}}}$, the storage cost minimization problem is expressed as

[TABLE]

where $s$ is defined in Theorem 1. Note that an eavesdropper can guess the original message only if he/she can invade all the cloud databases and guess the encoded data in the local machine. It is observed that the optimization problem is nonconvex even if we relax the noncovex constraints $n,l\in{\mathbb{Z}^{+}}$. The complete algorithm for solving this optimization problem is given in the Appendix.

VI-B Discussions

Figure 4 shows the optimal parameter setting for encoding matrix size ${n}$ versus the original message length ${m}$ for $d=2$, ${P_{e}}=0.5$, $p=3$, and ${P_{u}}={10^{-6}}$. As the message length increases, the size of the encoding matrix increases. A smaller encoding matrix size is preferred if Galois field size is large. Due to the integer constraints in the optimization problem, the encoding matrix size increases in a step-like function.

Figure 5 shows the storage cost $f(n,l)$ versus message length ${m}$ for $d=2$, ${P_{e}}=0.5$, and $p=3$. Intuitively, we need more storage space for lower ${P_{u}}$. However, the storage cost with various ${P_{u}}$ are the same when ${m}$ exceeds certain threshold. This is because the considered system is in the case of lower bound cost (i.e., ${l}=1$). Noteworthily, a larger ${k}$ can yield a smaller lower bound cost when ${m>1000}$. In a general setting $k\in[8,16]$ [27]. For ${m<1000}$ it is suggested that the value of $k$ is set to ${k=8}$; otherwise, ${k=16}$.

VII Experimental Results

Since the encoding process is performed on local machines, processing delay may be performance bottlenecks. Thus, it is of importance to investigate the impact of the system design parameters on the delay performance when considering a secure network coding storage scheme. We performed experiments on a commodity computer with an Intel Core i5 processor running at 2.4 GHz, 8 GB of RAM, and a 5400 RPM Hitachi 500 GB Serial ATA drive with an 8 MB buffer.

Figure 6 shows the multiplication processing time of the network coding storage system with different sizes of Galois Field. Although the complexity for the network coding is $O({n^{2}})$ modular multiplication, our result shows that the field size has only slight impact on the processing time, which supports our design methodology of selecting $k$. Specifically, it indicates the possibility that the security level can be enhanced significantly by selecting an appropriate design of $k$ but only pay a very small computational cost.

Figure 7 shows the processing time between the strictly non-overflow and the ${\alpha}$-bounded non-overflow schemes for 2MB file with $p=2$, where $\alpha=5$. The processing time is longer for a smaller $n$ or $k$ since the numbers of encoding times increase. As a result, the system spends more time in I/O operations and fetching data between the kernel and user [7]. Compared to the strictly non-overflow scheme, the ${\alpha}$-bounded non-overflow scheme requires more computation cost. The ${\alpha}$-bounded non-overflow scheme costs more than 11 times and 22 times of the processing time than that of the strictly non-overflow scheme when $k=16$ and 8, respectively. Finally, the best performance is achieved when $n>100$ for both non-overflow schemes. Because increasing $n$ results in a larger cost than increasing $k$, we suggest to fix $n=100$ and adjust $k$ to meet the security requirements.

Figure 8 compares the processing time of the strictly non-overflow and the ${\alpha}$-bounded non-overflow schemes versus the power of Galois Field characteristic $k$. As shown in the figure, the strictly non-overflow scheme is preferable to the ${\alpha}$-bounded non-overflow scheme. It is noteworthy that $k$ has negligible effect on the processing time of the strictly non-overflow scheme while it has a great impact on that of the ${\alpha}$-bounded non-overflow scheme.

VIII Conclusions

In this paper, we investigated the overflow problem in a network coding cloud storage system. When the overflow problem occurs, it does not only require more storage spaces but increases the processing time in encoding. We developed the network coding based secure storage (NCSS) scheme. A systematic approach for the optimal encoding and storage parameters was provided to solve the overflow problem and minimize the storage cost. We also derived an analytical upper bound for the maximal allowable stored data in the cloud nodes under perfect secrecy criterion. Our experimental results demonstrated that encoding efficiency in terms of processing time can be improved by jointly design of the encoding and the storage system parameters. More importantly, we suggested the key design guidelines for secure network coding storage systems to optimize the performance tradeoff among security requirement, storage cost per node, and encoding processing time. In the future research, we will further incorporate the factors of user budgets and file recovery into the secure network coding distributed storage system.

Appendix

Here we first show that the original storage cost minimization (38) is not convex even when the integer constraint is relaxed. Then we give the algorithm for solving the optimization problem by minimizing over separated variables.

Theorem 5**.**

*The objective function of the original storage cost minimization (38) is not convex. *

Proof.

We consider the case of strictly non-overflow scheme. Substituting ${s_{i}}=s=\frac{k}{{{{\log}_{2}}d}}$ into (38), the original storage cost minimization is equivalent to

[TABLE]

Then we prove the theorem by showing that the Hessian matrix of the objective function is not positive semidefinite. The Hessian matrix of $\tilde{f}(n,l)$ is

[TABLE]

where $a=\frac{k}{{{{\log}_{2}}d}}>0$ and $b=\frac{{m{{\log}_{2}}d}}{k}>0$. Then, we solve the characteristic equation

[TABLE]

We can obtain

[TABLE]

Since the eigenvalues of $H(\tilde{f})$ is not all positive, $H(\tilde{f})$ is not positive semidefinite. Thus $\tilde{f}$ is not convex.

We are now ready for solving the equivalent optimization problem (39) by minimizing over separated variables. Define ${{\tilde{f}}^{*}}(n,l)\triangleq\mathop{\min}\limits_{n\in\mathbf{B},l\in\mathbf{A}}{\tilde{f}}$ and ${l^{*}}\triangleq\arg\mathop{\min}\limits_{l\in\mathbf{A}}\tilde{f}(n,l)$, where $\mathbf{A}=\{x|x\in{\mathbb{Z}^{+}},\frac{{nk}}{{m{{\log}_{2}}d}}{\log_{d}}\frac{{{P_{u}}}}{{{{(1-{P_{c}})}^{p}}}}\leqslant x<n\}$ and $\mathbf{B}=\{x|x\in{\mathbb{Z}^{+}},2\leqslant x<{2^{k}}\}$. We first minimize over $n$

[TABLE]

Since $\mathop{\min}\limits_{l\in A}\tilde{f}(n,l)$ is a linear function with one variable in $\mathbb{Z}_{++}^{1}$ for fixed $n$ and the coefficient is positive, we obtain

[TABLE]

As a result, we can solve the optimization problem iteratively as:

• •

Step 0: Initiate $\mathbf{C}=\emptyset$ and $\mathbf{B}=\{x|x\in{\mathbb{Z}^{+}},2\leqslant x<{2^{k}}\}$.

• •

Step 1: Select $n\in\mathbf{B}$ and set $l=\left\lceil{\frac{{-nk}}{{m{{\log}_{2}}d}}{{\log}_{d}}\frac{{{P_{u}}}}{{{{(1-{P_{c}})}^{p}}}}}\right\rceil$.

• •

Step 2: Calculate $c=\tilde{f}(n,l)$.

• •

Step 3: Set $\mathbf{C}=\mathbf{C}\cup\{c\}$ and $\mathbf{B}=\mathbf{B}-\{n\}$.

• •

Step 4: Iterate 1 to 4 until $\mathbf{B}=\emptyset$.

• •

Step 5: Obtain ${{\tilde{f}}^{*}}(n,l)=\min\{\mathbf{C}\}$.