**1. Introduction**

Massive Internet of things (Massive IoT) involves an immense number of devices that require to be connected reliably and gigantic loads of data that need to travel safely through the Internet. With the growing public concerns over Internet privacy and security, there is an urgent appeal for research into secure communications in massive IoT. Pioneering works include the aggregate-signcryption [1], decentralized blockchain [2], FORGE system [3], and chaotic maps [4]. In this paper, we address this issue with a novel approach based on secret image sharing.

We propose to conceal the private data into a pair of image shadows and transmit them to separate devices over public networks. An authorized recipient should be able to access the image shadows stored on the separate devices and retrieve the private data via low-cost computations. The core component of the proposed secret image sharing scheme is the maze matrix, which belongs to a group of reference matrices originating from steganographic methods.

Steganography is the art and science of hiding information. It can be used to protect secret information by concealing it into cover images. These techniques can be broadly categorized into the transformed domain [5–9] and the spatial domain [10–17] methodologies. For the former class of methods, some commonly used transformations are the discrete cosine transform (DCT) [5,6], vector quantization (VQ) [7], and absolute moment block truncation coding (AMBTC) [8,9]. As for the latter class of methods, reference matrix-based algorithms have proved to be efficient in terms of the distortion versus capacity tradeoff. Common magic matrix-based steganographic schemes include the exploiting modified direction (EMD) [10,11], the turtle shell [12], the octagon-shaped shell [13], and the Sudoku [14–17] schemes.

Another closely related research stream is visual cryptography, which was first proposed by Naor and Shamir [18]. Typical visual cryptography schemes encrypt a secret image by breaking it up into n shares of obfuscated meaningless images, which are then printed onto separate transparencies. When k out of n transparencies are stacked and overlaid, the secret image will appear and become recognizable, where k is a pre-defined threshold. Methods of visual cryptography has constantly evolved, and the later developments contrived to produce shares in such a form that they themselves are images with meaningful contents [19–22].

A significant visual cryptography (SVC) [23] was recently proposed to securely transfer real-time images without compromising the visual quality. In the author's scheme, random share values are hidden in a cover image by LSB embedding. The signific secret image with induced errors can be revealed using a (k, n) SVC scheme, while the exact secret image can be revealed using an (n, n) scheme. However, this scheme is not capable of detecting cheaters.

As a notable improvement, a verifiable secret sharing scheme with combiner verification and cheater identification [24] was recently developed. Its share generation and secret reconstruction mechanisms were based on the polynomial interpolation technique invented by Shamir [25]. Its combiner verification and cheater identification were realized via a pre-shared key and a verifier code generated from the combiner's ID and password.

A recent development by Liu et al. [26] demonstrated that it is possible to identify the tampered shadows by restricting the use of elements at certain locations of the reference matrix and checking justness of the mapped elements in the secret extracting process. Through this mechanism, dishonest behaviors can be detected without the help of a pre-shared secret key or a password system.

In this paper, we proposed a novel secret image sharing scheme for massive IoT applications. The image shadows were generated under the guidance of the maze matrix. By leveraging the special characteristics of the maze matrix, we were able to inspect whether cheating behaviors took place. A two-layered cheat detection mechanism was devised. A joint cheat detection can discover cheating behaviors and a blind cheater identification can trace which shadow is inauthentic.

The proposed scheme shares the same merits as Liu et al.'s scheme, as that no pre-shared secret key or password system is required. In addition to this, the proposed maze matrix was explicitly designed to enable the scheme to detect cheats under the paradigm of secret sharing. Moreover, we formulated a pair of Lagrange polynomials to compute the exact pixel values of the shadow images rather than adopting time-consuming and computationally expensive conventional searching strategies. As a consequence, the time efficiency of the proposed share construction algorithm can be dramatically improved.

This remainder of this paper is organized as follows. Section 2 reviews a state-of-the-art secret image sharing scheme. Section 3 presents the proposed secret image sharing scheme based on maze matrix and the two-layered cheat detection mechanism. Experimental results and performance comparisons are shown in Section 4. This paper is concluded in Section 5.

### **2. Related Work**

In this section, we briefly review the secret image sharing scheme proposed by Liu et al. [26] with a discussion of its merits and demerits. Our proposed scheme was based on the similar framework and is introduced in the next section.

The secret image sharing scheme proposed by Liu et al. [26] allows a dealer to share secret message into two different meaningful images. It adopts the turtle shell matrix *M*(*p*1*i*, *p*2*i*), proposed by Chang et al. [12], to guide the embedding of secret message, as shown in Figure 1. Before constructing secret shares of shadow images, the binary stream of secret message is converted to 8-ary secret set *S* = *sgk <sup>k</sup>* <sup>=</sup> 1, 2, ... , *<sup>n</sup>* . The pixels of two distinct grayscale cover images with size *H* × *W* are rearranged into *C*<sup>1</sup> = *p*1*i <sup>i</sup>* <sup>=</sup> 1, 2, ... , *<sup>H</sup>* <sup>×</sup> *<sup>W</sup>* and *C*<sup>2</sup> = *p*2*i <sup>i</sup>* <sup>=</sup> 1, 2, ... , *<sup>H</sup>* <sup>×</sup> *<sup>W</sup>* . Each pair of pixels (*p*1*i*, *p*2*i*) is used to embed a secret digit *sgk* in a way like conventional reference matrix-based data hiding scheme.

**Figure 1.** The turtle shell matrix for secret image sharing scheme.

For the purpose of cheating detection, the elements in the reference matrix are classified into back elements and edge elements. As implied by the name, an edge element is an element located on the common edges of adjacent hexagons. On the contrary, a back element is located inside a single hexagon. The embedding rules are as follows. The cover pixel pair (*p*1*i*, *p*2*i*) is applied to locate a reference element in the matrix first. For an edge reference element, the rocket-shaped turtle shells as shown in the figure are the candidates of embedding, while the flower-shaped turtle shells are the candidates for a back-reference element. By searching the candidates to find the nearest back element that *M* - *p* 1*i* , *p* 2*i* = *sgk*, the obtained pixels - *p* 1*i* , *p* 2*i* are recorded to the image shadows. After all secret digits are embedded, the shadow images *S*<sup>1</sup> = *p* 1*i <sup>i</sup>* <sup>=</sup> 1, 2, ... , *<sup>H</sup>* <sup>×</sup> *<sup>W</sup>* and *S*<sup>2</sup> = *p* 2*i <sup>i</sup>* <sup>=</sup> 1, 2, ... , *<sup>H</sup>* <sup>×</sup> *<sup>W</sup>* are constructed. By restricting the embedding candidates to the back elements only, the cheating event can be detected while the shadow pixel pair - *p* 1*i* , *p* 2*i* is mapped to an edge element *M* - *p* 1*i* , *p* 2*i* .

Two typical examples of data hiding are illustrated in Figure 1. In the first example, the cover pixel pair is (*p*1*i*, *p*2*i*) = (2, 4) and the secret digit is *sgk* = 7. First, the cover pixel pair (2, 4) is mapped to the edge reference element *M*(2, 4). By searching its associated rocket-shaped candidate turtle shells, the only matched back element is *M*(2, 2) = 7 = *sgk*. The recorded shadow pixels are therefore - *p* 1*i* , *p* 2*i* = (2, 2). Although *M*(3, 5) and *M*(0, 3) are also matched with the secret digit, they are not back elements and thus conflict with the embedding rule.

The second example uses (*p*1*i*, *p*2*i*) = (10, 5) and *sgk* = 5 as inputs. The reference element *M*(10, 5) is a back element, therefore the candidates of embedding are the flower-shaped turtle shells shown in the figure. The matched candidates *M*(9, 5) and *M*(12, 7) are edge elements and excluded. Two legal candidates are *M*(11, 4) and *M*(9, 8). The nearest matched back element *M*(11, 4) is the final solution and the shadow pixels are given by - *p* 1*i* , *p* 2*i* = (11, 4).

To extract secret data, both shares of the image shadows should be obtained from the participants. The corresponding pair of pixels from the two shadows is mapped to the secret digit through the guidance of the turtle shell matrix. In case an edge element is mapped, we can conclude someone is cheating. The exact cheater can only be identified by a faithful participant. To overcome this weak point, we propose a new scheme in the following section.

#### **3. The Proposed Secret Image Sharing Scheme**

The proposed secret image sharing scheme was to convert two distinct cover images into a pair of shadow images through the guidance of a new proposed maze matrix. By cooperating the pair of shadow images occupied by two different participants, the embedded secret data could be extracted. In addition, a cheater detection mechanism was devised such that any cheating share of shadow images could be detected without help of the other share.

#### *3.1. The Maze Matrix*

The maze matrix was constructed using a basic structure matrix of size 6 × 6 as enclosed by the red square shown in Figure 2. Distinct numbers in the radix-16 number system were arranged by circulating the outmost boundary of the region except for a horizontal and a vertical gap. Other elements were marked with 'x'. By repeated mirroring operations, the rest of a 256 × 256 maze matrix was constructed. The first mirror matrix of the red basic structure to the *p*α direction of axis was enclosed by a blue square in the figure. The resulting matrix *M* - *p*α, *p*<sup>β</sup> looks like a big maze map and was named the maze matrix.

**Figure 2.** The maze matrix for secret image sharing scheme.

#### *3.2. The Data Embedding and Extraction Scheme*

Following the same problem formulation as the turtle shells matrix-based secret image sharing scheme [26], we constructed a pair of image shadows using a pair of distinct cover images through the guidance of the proposed maze matrix.

Before constructing secret shares of shadow images, the binary stream of secret message was converted to 16-ary secret set *S* = *sgk <sup>k</sup>* <sup>=</sup> 1, 2, ... , *<sup>n</sup>* . Pixels of two distinct grayscale cover images with size *H* × *W* are rearranged into *C*<sup>1</sup> = *p*1*i <sup>i</sup>* <sup>=</sup> 1, 2, ... , *<sup>H</sup>* <sup>×</sup> *<sup>W</sup>* and *C*<sup>2</sup> = *p*2*i <sup>i</sup>* <sup>=</sup> 1, 2, ... , *<sup>H</sup>* <sup>×</sup> *<sup>W</sup>* .

Each pair of pixels (*p*1*i*, *p*2*i*) was used to embed a secret digit *sgk* through the guidance of the maze matrix. For a cover pixel pair (*p*1*i*, *p*2*i*), it was mapped to the maze matrix *M*(*p*1*i*, *p*2*i*) first. Then, we searched the neighboring elements to find the nearest matched element *M* - *p* 1*i* , *p* 2*i* = *sgk* and record the shadow pixels - *p* 1*i* , *p* 2*i* to the shadow images. After all secret digits were embedded, the shadow images *S*<sup>1</sup> = *p* 1*i <sup>i</sup>* <sup>=</sup> 1, 2, ... , *<sup>H</sup>* <sup>×</sup> *<sup>W</sup>* and *S*<sup>2</sup> = *p* 2*i <sup>i</sup>* <sup>=</sup> 1, 2, ... , *<sup>H</sup>* <sup>×</sup> *<sup>W</sup>* were constructed. Note that the elements marked with 'x' can never be the target element. This property will be applied to devise the cheating detection mechanism.

The data extraction process is rather simple: Collect the pair of image shadows provided by different participants and construct the same maze matrix as embedding. Then, consecutively extract secret digits by *sgk* = *M* - *p* 1*i* , *p* 2*i* until all secrets are extracted.

To detect cheating events, the 'x'-marked forbidden zone is the key. Any pair of shadow pixels which maps to an 'x'-marked element indicates someone is cheating. In addition, while the mapped element lies at a horizontal or vertical gap of the maze matrix, the exact cheater can be identified.

The detailed algorithms of the data embedding and extraction processes are discussed in the following subsections. In the last subsection, we discuss the cheater detection mechanism of the proposed secret image sharing scheme.

### *3.3. The Sshare Construction Algorithm*

As described in the previous subsection, a secret digit is embedded by modifying the cover pixel pair to the target element through the guidance of maze matrix. However, the searching process is time-consuming. To improve the embedding efficiency, we devised a Lagrange polynomial to determine the target element of modification. Let - *px*, *py* be the cover pixel pair in the range 0 ≤ *px* ≤ 4, 0 ≤ *py* ≤ 4. According to the maze matrix as shown in Figure 2, the target elements of modification for embedding different secret digits are listed in Table 1.

**Table 1.** Target elements of modification for different secret digits.


Let

$$X = \langle \mathbf{x}\_0, \mathbf{x}\_1, \mathbf{x}\_2, \dots, \mathbf{x}\_{15} \rangle = \langle 0, 0, 0, 0, 0, 1, 2, 3, 5, 5, 5, 5, 5, 3, 2, 1 \rangle,\tag{1}$$

$$Y = \{y\_0, y\_1, y\_2, \dots, y\_{15}\} = [0, 2, 3, 4, 5, 5, 5, 5, 5, 4, 3, 2, 0, 0, 0, 0].\tag{2}$$

The modified pixel pair *p <sup>x</sup>*, *p y* can be represented by the Lagrange polynomial functions of *sj* as shown below:

$$p\_x'(s\mathbf{g}\_j) = \sum\_{r=0}^{15} x\_r \prod\_{\substack{k \neq r \\ k \neq r}}^{15} \frac{\left(s\mathbf{g}\_j - k\right)}{(r-k)},\tag{3}$$

$$p\_y'(sg\_j) = \sum\_{r=0}^{15} y\_r \prod\_{\substack{k \neq r \\ k \neq j}}^{15} \frac{\left(sg\_j - k\right)}{(r-k)}.\tag{4}$$

By leveraging the periodic property of the maze matrix, we modulated a reference element *M* - *p*α, *p*<sup>β</sup> to the fundamental period of *M* - *px*, *py* , 0 ≤ *px* ≤ 9, 0 ≤ *py* ≤ 9. Then, the fundamental period was further divided into four reflective symmetric parts. According to the secret digit *sj* to be embedded, a quasi-target element *M* - *p x* - *sgj* , *p y* - *sgj* can be obtained. By reflection and backward modulation, the target element *M p* <sup>α</sup>, *p* β can be determined. The detailed algorithm is summarized as follows.

The construction of image shadows:

Input: Cover images *C*<sup>1</sup> and *C*2, secret message *S*

Output: Image shadows *S*<sup>1</sup> and *S*<sup>2</sup>

Step 1. Arrange the cover images into two separate pixel streams and convert the secret message to 16-ary secret digits.

$$\mathbf{C}\_{1} = \{p\_{1i} | i = 1, 2, \dots, H \times W\},\tag{5}$$

$$\mathbf{C}\_2 = \{p\_{2i} | i = 1, 2, \dots, H \times W\},\tag{6}$$

where *H* × *W* is the image size.

$$S = \{ \mathbf{s} \mathbf{g}\_k | k = 1, 2, \dots, n \}, \tag{7}$$

where *n* is the total number of digits.

Step 2. Retrieve a cover pixel pair (*p*1*i*, *p*2*i*) and let

$$\begin{pmatrix} p\_{\alpha\_{\prime}}, p\_{\beta} \end{pmatrix} = \begin{cases} (p\_{1i}, p\_{2i}), & \text{for } i \text{ is odd,} \\ (p\_{2i}, p\_{1i}), & \text{for } i \text{ is even.} \end{cases} \tag{8}$$

Step 3. Modulate the pixel values to the fundamental period.

$$p\_x = m \alpha (p\_{a\nu}, 10),\tag{9}$$

$$p\_{\mathcal{Y}} = mod(p\_{\mathcal{Y}}, 10). \tag{10}$$

$$M = \left\lfloor \frac{p\_a}{10} \right\rfloor. \tag{11}$$

$$N = \left\lfloor \frac{p\_{\beta}}{10} \right\rfloor. \tag{12}$$

Step 4. Using the Lagrange polynomial defined as Equations (1) to (4), determine the target element of modification.

For 0 ≤ *px* ≤ 4 and 0 ≤ *py* ≤ 4,

$$p'\_{\alpha} = p'\_{\text{x}}(s\text{g}\_{\text{j}}) + 10 \times \text{M};\tag{13}$$

$$p\_{\beta}^{\prime} = p\_{y}^{\prime}(\text{sg}\_{\beta}) + 10 \times \text{N}.\tag{14}$$

For 5 ≤ *px* ≤ 9 and 0 ≤ *py* ≤ 4,

$$p\_{\alpha}^{\prime} = \left[10 - p\_{x}^{\prime}(s g\_{\circ})\right] + 10 \times M;\tag{15}$$

$$p\_{\beta}^{\prime} = p\_{y}^{\prime}(s\underline{\text{g}}\_{\beta}) + 10 \times \text{N}.\tag{16}$$

For 0 ≤ *px* ≤ 4 and 5 ≤ *py* ≤ 9,

$$p\_{\alpha}^{\prime} = p\_{\text{x}}^{\prime}(s\underline{s}\_{\text{j}}) + 10 \times M;\tag{17}$$

$$p'\_{\beta} = \left[10 - p'\_y(\text{sg}\_{\dot{\beta}})\right] + 10 \times N. \tag{18}$$

For 5 ≤ *px* ≤ 9 and 5 ≤ *py* ≤ 9,

$$p\_{\alpha}^{\prime} = \left[10 - p\_{\text{x}}^{\prime}(\text{sg}\_{\text{j}})\right] + 10 \times M;\tag{19}$$

$$p'\_{\beta} = \left[10 - p'\_{\mathcal{Y}}(s\underline{\text{g}}\_{\beta})\right] + 10 \times N. \tag{20}$$

Step 5. Record the shadow pixels.

$$\mathbf{P}\left(p'\_{1i'}, p'\_{2i}\right) = \begin{cases} \left(p'\_{\alpha'}, p'\_{\beta}\right) & \text{for } i \text{ is odd,} \\ \left(p'\_{\beta'}, p'\_{\alpha}\right) & \text{for } i \text{ is even.} \end{cases} \tag{21}$$

Step 6. Repeat Step 2 to 5 until all secret digits are embedded. Step 7. Output the pair of image shadows.

$$S\_1 = \left\{ p'\_{1i} \middle| i = 1, 2, \dots, H \times W \right\} ; \tag{22}$$

$$S\_2 = \left\{ p'\_{2i} \middle| i = 1, 2, \dots, H \times W \right\}. \tag{23}$$

Note that there are many gaps at mod(*p*α, 10) = 4, 6 and mod*p*β, 10 = 1, 9 of the maze matrix. Using the conventional fixed assignment of - *p*α, *p*<sup>β</sup> = (*p*1*i*, *<sup>p</sup>*2*i*), the resulting *p* <sup>α</sup>, *p* β will lack the gapped pixel values. This may draw the eavesdropper's attention. To prevent the vacuums of pixel value, we alternatively assigned - *p*α, *p*<sup>β</sup> with (*p*1*i*, *p*2*i*) and (*p*2*i*, *p*1*i*) in Step 2 and switched back in Step 5 coordinately. The asymmetric gapping of maze matrix in the *p*α and *p*β directions made it possible to cover the gaps by leveraging the alternating assignment.

We provide two examples to demonstrate the operation of embedding process. Assume the first cover pixel pair is (*p*11, *p*21) = (83, 61) and the secret digit to be embedded is *sg*<sup>1</sup> = 5. Following the steps of embedding algorithm gives - *p*α, *p*<sup>β</sup> = (83, 61), - *px*, *py* = (3, 1), (*M*, *N*) = (8, 6), (*p <sup>x</sup>*(5), *p <sup>y</sup>*(5)) = (1, 5), and - *p* <sup>11</sup>, *p* 21 = *p* <sup>α</sup>, *p* β = (1 + 8 × 10, 5 + 6 × 10) = (81, 65). Let the second cover pixel pair and the second secret digit be (*p*12, *p*22) = (83, 66) and *sg*<sup>2</sup> = 14. Following the same calculation gives - *p*α, *p*<sup>β</sup> = (*p*22, *p*12) = (66, 83), - *px*, *py* = (6, 3), (*M*, *N*) = (6, 8), (*p <sup>x</sup>*(14), *p <sup>y</sup>*(14)) = (2, 0), and *p* <sup>α</sup>, *p* β <sup>=</sup> ((<sup>10</sup> <sup>−</sup> <sup>2</sup>) <sup>+</sup> <sup>6</sup> <sup>×</sup> 10, 0 <sup>+</sup> <sup>8</sup> <sup>×</sup> <sup>10</sup>) <sup>=</sup> (68, 80), and - *p* <sup>12</sup>, *p* 22 = *p* <sup>β</sup>, *p* α = (80, 68).

#### *3.4. The Data Extraction Algorithm*

The secret message can be extracted only through cooperation of the two shadow image owners. The secret data can be extracted by pairing the pixels from the two image shadows and applying each pixel pair to retrieve a 16-ary secret digit through the guidance of maze matrix. The 16-ary secret digits can be converted back to the binary secret stream if necessary. The data extraction algorithm is provided as follows.

The data extraction algorithm:

Input: image shadows *S*<sup>1</sup> and *S*<sup>2</sup>

Output: secret message *S*

Step 1. Arrange the image shadows into two separate pixel streams.

$$S\_1 = \left\langle p'\_{1i} \middle| i = 1, 2, \dots, H \times W \right\rangle;\tag{24}$$

$$\mathbf{S}\_2 = \left\{ p'\_{2i} \middle| i = 1, 2, \dots, H \times W \right\},\tag{25}$$

where *H* × *W* is the image size.

Step 2. Construct the fundamental period of maze matrix *M px*, *py* , 0 ≤ *px* ≤ 9, 0 ≤ *py* ≤ 9 as shown in Figure 2.

Step 3. Retrieve a shadow pixel pair *p* 1*i* , *p* 2*i* and let

$$(p\_{\alpha}, p\_{\beta}) = \begin{cases} (p'\_{1i'}, p'\_{2i}), & \text{for } i \text{ is odd,} \\ (p'\_{2i'}, p'\_{1i}), & \text{for } i \text{ is even.} \end{cases} \tag{26}$$

Step 4. Extract the secret digit *sgj* and record to *S*.

$$\log\_{\hat{\beta}} = M \{ mod(p\_{\alpha}, 10), mod(p\_{\beta}, 10) \}. \tag{27}$$

Step 5. Repeat Step 3 and 4 until all secret digits are extracted.

Step 6. Convert the 16-ary secret digits back to the binary secret stream.

Now, we apply the embedding results in the previous subsection *p* <sup>11</sup>, *p* 21 = (81, 65) and - *p* <sup>12</sup>, *p* 22 = (80, 68) as examples. For the first shadow pixel pair, the secret digit can be retrieved by directly calculating Equation (27), i.e., *sg*<sup>1</sup> = *M*(*mod*(81, 10), *mod*(65, 10)) = *M*(1, 5) = 5. For the second pixel pair, the pixels should be swapped according to Equation (26), i.e., - *p*α, *p*<sup>β</sup> = (68, 80). Then, calculate Equation (27)" i.e., *sg*<sup>2</sup> = *M*(*mod*(68, 10), *mod*(80, 10)) = *M*(8, 0) = 14. Both secret digits coincided with the embedded ones.

#### *3.5. The Cheat Event Detection and Cheater Detection Mechanism*

The most creative part of our secret sharing scheme was the cheater detection mechanism. Referring to Figure 2, the 'x'-marked elements in the maze matrix were the traps. Any pair of shadow pixels which maps to an 'x'-marked element was illegal and served as key information for cheat event detection. The algorithm is given as follows.

The cheat detection algorithm:

Input: image shadows *S*<sup>1</sup> and *S*<sup>2</sup>

Output: cheating pixel pairs *F*, cheating pixels *F*<sup>1</sup> and *F*<sup>2</sup>

Step 1. Arrange the image shadows into two separate pixel streams.

$$S\_1 = \left\{ p'\_{1i} \middle| i = 1, 2, \dots, H \times W \right\} \tag{28}$$

$$\mathbf{S}\_2 = \left| p'\_{2i} \middle| i = 1, 2, \dots, H \times W \right|,\tag{29}$$

where *H* × *W* is the image size.

Step 2. Construct the fundamental period of maze matrix *M* - *px*, *py* , 0 ≤ *px* ≤ 9, 0 ≤ *py* ≤ 9 as shown in Figure 2.

Step 3. Retrieve a shadow pixel pair *p* 1*i* , *p* 2*i* and let

$$\begin{pmatrix} p\_{\alpha\_{\prime}} p\_{\beta} \end{pmatrix} = \begin{cases} \left(p\_{1i'}' p\_{2i}'\right)\_{\prime} & \text{for } i \text{ is odd,} \\ \left(p\_{2i'}' p\_{1i}'\right)\_{\prime} & \text{for } i \text{ is even.} \end{cases} \tag{30}$$

Step 4. Detect cheating pixel pairs and individual cheating pixels. 

if *M mod*(*p*α, 10), *mod<sup>p</sup>*β, 10 <sup>=</sup> <sup>x</sup> , record *i* to *F*; if *mod*(*p*α, 10) = 4 or 6, record *i* to *F*<sup>1</sup> for *i* is odd; record *i* to *F*<sup>2</sup> for *i* is even. end if *mod*- *p*β, 10 = 1 or 9, record *i* to *F*<sup>2</sup> for *i* is odd; record *i* to *F*<sup>1</sup> for *i* is even. end

end

Step 5. Repeat Step 3 and 4, until all pixel pairs are checked.

The cheat detection included two layers. The outer layer was a joint cheat event detection. The shadow pixel pair was mapped to the maze matrix and check the legality. If an 'x'-marked element was mapped, the index *i* of the pixel pair was recorded to *F*. Under such circumstances, we could conclude that a cheat event was detected. The exact cheater could only be determined by a faithful participant. The inner layer was a blind cheater detection. We checked whether the mapped element

was located at a gap. If it was located at a horizontal gap, *p*α was a tampered pixel no matter what value *p*<sup>β</sup> is, because it was impossible to find a *p*<sup>β</sup> to make the pixel pair - *p*α, *p*<sup>β</sup> legal. For the same reason, a *p*β trapped in a vertical gap was a tampered pixel, and the participant who shared this shadow pixel was the cheater. The output sets *F*<sup>1</sup> and *F*<sup>2</sup> recorded the indices of tampered pixels from image shadows *S*<sup>1</sup> and *S*2, respectively.

#### **4. Experimental Results**

In this section, we give some experimental results to show the performance of the proposed secret image sharing scheme. Figure 3 shows six pairs of 512 × 512 grayscale cover images, including (a) Lena and baboon, (b) Tiffany and Barbara, (c) airplane and peppers, (d) boat and Goldhill, (e) toys and girl, and (f) Elaine and sailboat. According to the embedding capacity of the proposed scheme, we used a 362 × 362 grayscale secret image "office," as shown in Figure 4. The embedding capacity of a cover image pair was 512 × 512 × 4 = 1,048,576 bits, while the secret image contained 362 × 362 × 8 = 1,048,352 bits of data. The whole secret image can be embedded into a cover image pair. The remaining capacity was filled with random generated data.

**Figure 3.** Six pairs of grayscale cover images.

office

**Figure 4.** Secret image.

This section includes four subsections. In the first subsection, we demonstrate the applicability of the proposed share construction and data extraction scheme. The visual quality of the secret image shadows is also assessed. In the second subsection, we measure the detection ratio of tampered image regions. The effectiveness of cheat event detection and cheater detection are discussed. In the third subsection, the performance, including visual quality, hiding capacity, and cheat detection effectiveness, is compared with the Liu et al.'s scheme, which shares the same framework of secret image sharing scheme. Finally, the time efficiency of the new proposed share construction scheme is compared with conventional version in the last subsection.
