Boolean-Based (k, n, m) Multi-Secret Image Sharing

Abstract

Multi-secret image sharing technology shares multiple secret images among shared images for participants and the recovery requires enough shared images for fulfilling the security property. Simultaneously, the adopted Boolean method preserves high performance. The proposed (k, n, m) multi-secret image sharing scheme shares m secret images among n participants and gathering k participants’ shared images perfectly recovers these m secret images. The proposed scheme exhibits high performance because of the usage of Boolean-based processing. Moreover, the usage of a sharing matrix based strategy acquires perfect reconstruction of the secret images under (k, n) thresholds. Two proposed schemes, the source-random-mixed (SRM) and the source-random-separate (SRS) methods, are presented in this study from different strategies of sharing the random image mixed with the secret images or separated to the secret images, respectively. Moreover, the proposed SRS method exhibits the better sharing capacity. Experimental results show that the proposed schemes perform well on sharing efficiency and security.

1. Introduction

The popular usage of multimedia content leads to a security problem on transmission or storage being increasingly more important. Secret image sharing technique, aiming to protect the multimedia content among participants, is one of the protection methods and has become an important research field [1].

The secret image sharing problem was first presented by Thien and Lin [2] with solving by the Shamir–Lagrange method [3]. The secret image sharing technique is then extended to various research areas, such as sharing among host images [4,5], sharing using Boolean operations [6,7], progressive sharing [8,9,10], sharing with visual cryptography property [11], multiple sharing [12,13], and scalable sharing [14]. Among these research topics, sharing multiple secret images efficiently is an important topic in real cases. Moreover, the Boolean-based scheme outperforms the functional-based schemes on computational complexity but is hard to achieve various properties such as (k, n) partial recovery, multiple sharing, or progressive sharing. Therefore, a Boolean-based secret image sharing scheme with (k, n) thresholds on multiple secret images sharing is very important and merits our study.

The Boolean-based approaches can be classified into two categories, the stacking-based and the XOR-based methods. The stacking-based methods [15,16,17,18], which are based on visual cryptography [19], are the least computational Boolean-based methods. However, the stacking-based methods always lead to a rough visual effect. Consequently, the XOR-based methods are the key technique having both efficient computation complexity and perfect recovered results. Therefore, our proposed method is based on XOR-based technique. Moreover, sharing matrix strategy [20] is an efficient method to achieve perfect recovery. Therefore, the proposed scheme is based on XOR operations and the concept of sharing matrix.

Over the past years, several Boolean-based approaches have been presented. Wang et al. [6] adopted simple Boolean operations to present an (n, n) threshold scheme. Chen and Wu [12] proposed a Boolean-based multiple secret image sharing method which used n − 1 secret images to generate n shared images. Collecting all shared images is the requirement of their proposed method. The Boolean-based multiple secret image sharing method [12] was then improved by Chen and Wu [13] by using a random number image generation function, which obtains the same random image from secret images or shared images. Therefore, the sharing capacity is increased due to the no random image requirement. Chen et al. [21] further modified the usage of random image generation to a Boolean-based symmetric recovery function. Notice that most previous Boolean-based schemes are mainly for (n, n) thresholds. Bao et al. [20] proposed the sharing matrix to acquire Boolean-based (k, n) secret image sharing. Prasetyo and Jing [22] present the Chinese remainder theorem and XOR-based (n, n) secret image sharing. Chattopadhyay et al. [23] acquired (n, n) secret image sharing with scalable shared images. Kabirirad and Eslami [24] present (k, n) secret image sharing with recovery by consecutive k shared images. Kabirirad and Eslami [25] proposed a Boolean-based multiple secret image sharing scheme. However, the size of the generated shared image must be the same as the secret image. Azza and Lian [26] present a multi-secret image sharing scheme using cellular automaton with steganography. Chen and Wu [27] proposed a multi-secret sharing scheme based on Boolean operation. Based on the proposed predefined access structure, the recovery of secret images does not require collection of all the shared images. Moreover, the way to construct multi-secret image sharing with general (k, n) thresholds is still not well solved.

This paper proposes a secure Boolean-based (k, n, m) multiple secret image sharing approach that shares m secret images among n shared images, and collecting k shared images perfectly recovers these m secret images. Two schemes are presented in this study: the source-random-mixed scheme (SRM) sharing the XOR result among each shared image and the random image, and the source-random-separate scheme (SRS) that shares the random image individually. Experimental results show the novel properties of the two proposed approaches. Moreover, the proposed SRS scheme outperforms others for its usage of sharing matrix on secret images distribution.

The paper is organized into the following sections. Section 2 gives a brief review of related works [20,21]. Section 3 presents details of two proposed sharing and recovery approaches, the source-random-mixed scheme (SRM) and the source-random-separate scheme (SRS). Section 4 presents the experimental results. Section 5 offers concluding remarks.

2. Review of Related Literature

This section briefly reviews the state-of-art in Boolean-based secret sharing schemes with the function of multiple images sharing. Section 2.1 introduces the secret sharing of multiple images based on the Boolean function proposed by Chen et al. [21]. Section 2.2 introduces the sharing matrix-based (k, n) secret image sharing method by Bao et al. [20].

2.1. Multiple Secret Images Sharing Scheme

Chen et al. [21] proposed a Boolean-based (n, n) secret image sharing scheme, in which n secret images are shared among n shared images and by Boolean operation. The sharing steps are introduced as follows.

1.

Acquire the random image R with the secret images $I_i\left(0\le i\le n-1\right)$ by Equation (1):

$$\begin{array}{c}{h=H(I}_0 ⨁{ I}_{1 }⨁{ I}_2\cdots ⨁{ I}_{n-1}),\\ \mathit{SI}=\mathit{image}\_\mathit{synthesis}\left(h\right),\\ R=\mathit{bit}\_\mathit{reverse}\left(I_0 ⨁{ I}_1 ⨁{ I}_2 ⨁ \cdots ⨁{ I}_{n-1}\right) ⨁ \mathit{SI},\end{array}$$

(1)

where H() represents the SHA-256 hash function, image_synthesis(h) synthesizes the random image from the seed h, and bit_reverse(I) reverses the image I on the bit plane.

2.

Shift the random image with different pixels to acquire a series of random images $R_i\left(0\le i\le n-1\right)$, as given in Equation (2):

$$R_i\left(x,y\right)=R\left(x - i,y - i\right).$$

(2)

3.

Acquire shared images $O_i$ for participant i from Equation (3):

$$O_i= \{\begin{array}{l}{ I}_0\oplus R_0\oplus R_1, i = 0,\hfill \\ { I}_1\oplus R_1\oplus R_2, i = 1,\hfill \\ { I}_2\oplus R_2\oplus R_3, i = 2,\hfill \\ ⋮ \hfill \\ I_{n - 2}\oplus R_{n - 2}\oplus R_{n - 1}, i = n - 2,\hfill \\ I_{n - 1}\oplus R_{n - 1}\oplus R_0, i = n - 1.\hfill \end{array}$$

(3)

The recovery steps are introduced as follows.

1.

Collect all n shared images $O_i$ and perform XOR operation $O_0\oplus \dots \oplus O_{n-2}\oplus O_{n-1}$ on all shared images, as defined by Equation (4):

$$\begin{array}{l}{O}_0\oplus \dots \oplus O_{n - 2}\oplus O_{n - 1}\hfill \\ =\left(I_0\oplus R_0\oplus R_1\right)\oplus \dots \oplus \left(I_{n - 1}\oplus R_{n - 1}\oplus R_0\right),\hfill \\ {=I}_0\oplus \dots \oplus I_{n - 2}\oplus I_{n - 1}.\hfill \end{array}$$

(4)

2.

Apply the result of Equation (4) to Equations (1) and (2) to obtain a series of random images $R_i\left(0\le i\le n-1\right)$.

3.

Acquire the recovered secret images $I_i^{\prime }$ by applying $O_i$ and $R_i$ to Equation (5):

$$I_i^{\prime }=\{\begin{array}{cc}{O}_0\oplus R_0\oplus R_1,& i=0,\\ O_1\oplus R_1\oplus R_2,& i=1,\\ O_2\oplus R_2\oplus R_3,& i=2,\\ ⋮ & \\ O_{n-2}\oplus R_{n-2}\oplus R_{n-1},& i=n-2\\ O_{n-1}\oplus R_{n-1}\oplus R_0,& i=n-1.\end{array}$$

(5)

The recovered secret images $I_i^{\prime }$ and original secret images $I_i$ are consistent when all the shared images $O_i$ are correctly acquired. Moreover, Chen et al.’s scheme [21] only exhibits (n, n) secret image sharing for sharing among n shared images and recovery requirement is all n shared images. For acquiring a Boolean-based and robust (k, n) secret image sharing scheme, Bao et al. [22] presented sharing an important matrix-based method, which is introduced in the next section.

2.2. Boolean-Based (k, n) Secret Image Sharing Scheme

The Boolean-based scheme is difficult to achieve with (k, n) secret image sharing when $k\le n$. Bao et al. [20] present a novel (k, n) secret image sharing scheme by using the proposed sharing matrix to achieve the recovery of only acquiring k shared images rather than n shared images. Assume that a secret image with size r × c is shared among n shared images with recovery thresholds (k, n); their sharing algorithm is introduced as follows.

• Generate a series of n binary sharing matrices M_i(0 ≤ i ≤ n − 1) with size r × c, in which each matrix should satisfy the following two criteria:
  • Gathering k sharing matrices leads to each entry containing at least a 1 among these sharing matrices.
  • Gathering less than k sharing matrices leads to at least an entry without finding a 1 among these sharing matrices.
• Encrypt the secret image I to acquire a randomlike image R.
• For a sharing matrix M_i, each entry M_i(j,k)(0 ≤ j≤ r − 1,0 ≤ k ≤ c − 1) determines the corresponding shared image entry S_i(j,k), as defined in Equation (6):

$$S_i\left(j,k\right)=\{\begin{array}{c}R\left(j,k\right){, \mathit{if} M}_i\left(j,k\right)=1,\\ \mathit{Rand}(){, \mathit{if} M}_i\left(j,k\right)=0,\end{array}$$

(6)

where Rand() represents a random number generation function.

Since the encrypted image R in Step 2 is a randomlike image, Step 3 acquires a shared image that is also randomlike because part of the entries of R are $S_i$ and other entries are random numbers. According to the novel arrangement of the sharing matrices $M_i$, gathering k shared images $S_i$ can acquire all entries S_i(j,k)(0 ≤ j ≤ r − 1, 0 ≤ k ≤ c − 1) of R and then decrypt to the secret image I perfectly. However, gathering less than k shared images cannot acquire all entries of R and the secret image cannot then be decrypted.

The recovery algorithm is introduced as follows.

• Reconstruct the same series of n binary sharing matrices M_i(0 ≤ I ≤ n − 1) as applied in the sharing algorithm.
• Acquire the encrypted image R from $M_i$ and $S_i$ by applying Equation (7)

$${R(j,k)=S}_i{(j,k)\hspace{1em}\hspace{1em}\mathit{if} M}_i(j,k)=1.$$

(7)

3.

Decrypt the secret image from R to acquire the recovered secret image.

In Step 2, each entry of the randomlike image R will be correctly recovered because of the property of binary sharing matrices M_i, as introduced in Step 1 of the sharing algorithm.

3. The Proposed Approach

This section introduces our proposed XOR-based (k, n, m) multi-secret image sharing scheme, in which m secret images are shared among n participants with k thresholds for perfectly recovering all secret images.

Section 3.1 introduces the generation of the sharing matrix, Section 3.2 and Section 3.3 introduce two proposed XOR-based (k, n, m) multi-secret image sharing algorithms: the source-random-mixed method (SRM) and source-random-separate method (SRS), respectively. Examples of the proposed SRS sharing and recovery with thresholds (2, 3, 2) are demonstrated in Section 3.4.

3.1. Sharing Matrix Generation

Since the sharing matrix has to acquire the property of (k, n) thresholds, all secret images are consistent in size and the sharing matrices P_i(i = 1, 2, …, n) have the following properties:

• Each sharing matrix P_i has the same size with secret images.
• Each element in P_i are either 0 or 1.
• Selecting p matrices of P_i, for example, i = 1, 2, …, p, the following criteria should be satisfied.

  3.1

  When p ≥ k, at least one matrix has the value of 1 in all entries among these p matrices.

  3.2

  When p < k, at least one entry has the value of 0 in all p matrices.

Above three properties construct the sharing matrices P_i(i = 1, 2, …, n) that will be used in our two proposed methods. Without loss of generality, an example of (k, n) using threshold (3, 4) and matrix size 4 × 6 is illustrated in Figure 1. The predetermined selection of n = 4 acquires 4 sharing matrices P₁ to P₄ and k = 3 shows that selecting 3 sharing matrices should fit the above criterion 3.1. For example, the selection of P₁, P₂, and P₃ fits the requirement of 3.1 being at least one matrix having the value of 1 in all entries. However, the selection of $P_1$, and $P_2$ fits the criterion of Step 3.2, with entries such as P₁(1,1) = P₂(1,1) = 0 or P₁(2,6) = P₂(2,6) = 0. Therefore, the (k, n) thresholds determine the collection of k sharing matrices acquires at least one matrix that has the value of 1 in all entries and the collection of k − 1 sharing matrices at least have the value of 0 in one entry among sharing matrices.

The sharing matrix generation algorithm, a modification of Bao et al.’s method [20], is illustrated as follows for obtaining sharing matrices P_i(i = 1, 2, …, n) for (k, n, m) thresholds with r × c secret image size.

1.

Use Equation (8) to acquire an n × 1 binary vector M:

$$M=\mathit{createVector}(k,n),$$

(8)

where M includes (k − 1) number of value 0 and (n − k + 1) number of value 1.

2.

Acquire initial matrix N by permuting through M as Equation (9):

$$N=\mathit{permuteMatrix}\left(M\right),$$

(9)

where permuteMatrix(M) duplicates vector M $t=\frac{n!}{\left(k-1\right)!\left(n-k+1\right)!}$ times to acquire matrix N with size n × t.

3.

Extend one row vector of N, denoted by N(i,:), to acquire an extended matrix N_i with size r × t by using Equation (10):

$$N_i\left(x,:\right)=\mathit{shiftVector}\left(N\left(i,:\right),x\right), 1 \le x \le r \mathit{and} 1 \le i \le n,$$

(10)

where the function $shiftVector\left(V,x\right)$ circularly shifts the vector V to x positions.

4.

Exchange rows of $N_i$ to acquire exchanged matrix $N_i^{\prime }$:

$$N_i^{\prime }=\mathit{exchangeRows}\left(N_i,b\right),$$

(11)

where the function $exchangeRows\left(A,b\right)$ randomly permutes matrix A on rows by the seed b.

5.

Extend the matrix $N_i^{\prime }$ to fit the sizes of secret image for obtaining sharing matrix $P_i$:

$$P_i=\mathit{repeatMatrix}\left(N_i,w\right), w=\frac{c}{t},i=1,2,\dots ,n,$$

(12)

where the function repeatMatrix(A,w) duplicates the A matrix w times for acquiring the required size, which is the same size as the secret images.

Figure 2 shows sharing matrices generation step by step. Since the (k, n) thresholds are (3, 4), the generated binary vector M, as shown in Figure 2a, is 4 × 1 and 2 of these 4 elements are 1, as denoted in Step 1 of Equation (8). Figure 2b shows the generated initial matrix N, as defined in Step 2 and Equation (9). Figure 2c–e shows a series of extended matrix N₁, exchanged matrix $N_1^{\prime }$, and sharing matrix $P_1$, respectively. These matrices are acquired from Steps 3–5. In Figure 2c, N₁ is acquired from the first row of N with one position circular shift. Moreover, Figure 2f of N₂ is acquired from the second row of N with one positioned circular shift.

Figure 3 shows the sharing strategy of the proposed algorithms. The input images I_i are processed to acquire temporary images E_i. On the other hand, sharing matrices P_i are calculated from thresholds (k, n), as introduced in Equations (8)–(12). At last, shared images S_j are acquired from temporary images E_i and sharing matrices P_i.

3.2. The Proposed (k, n, m) Source-Random-Mixed (SRM) Algorithm

This section shows our first proposed (k, n, m) SRM sharing algorithm, in which m secret images with identical size are shared among n shared images and collecting k shared images perfectly recover these n secret images. Assume all the secret images are denoted by I_i(1 ≤ i ≤ m) with the same size r × c, and the generated shared images are S_j(1 ≤ j ≤ n). The sharing matrices introduced in Section 3.1 are needed in the proposed sharing and recovery algorithms. Figure 4 shows the proposed SRM sharing steps and the proposed SRM sharing algorithm is introduced as follows.

1.

Apply m secret images I_i (1 ≤ i ≤ m) to XOR operation for acquiring I_XOR by Equation (13):

$$I_{\mathrm{XOR} }{=I}_1⨁I_2⨁\cdots ⨁I_m,$$

(13)

where $⨁$denotes bit-based XOR operation.

2.

Generate a random image R by Equation (14):

$$\begin{array}{c}h=\mathit{hash}\left(I_{\mathit{XOR}}\right),\\ R=\mathit{image}\_\mathit{synthesis}\left(h,r,c\right),\end{array}$$

(14)

where the hash() is performed by SHA-256 hash function and the image_synthesis(h,r,c) synthesizes a randomlike image with size r × c from the seed h.

3.

Generate a series of randomlike images R_i (1 ≤ i ≤ m) from Equation (15):

$$R_i{=\mathit{pixel}\_\mathit{shift}(R,i),}_{}\hspace{1em}1 \le i \le m,$$

(15)

where pixel_shift(R,i) right circularly shifts the image R with i pixels.

4.

A series of temporary images E_i (1 ≤ i ≤ m) are acquired from I_i and R_i by Equation (16):

$$E_i= \{\begin{array}{l}{I}_1\oplus R_1\oplus R_2, i = 1,\hfill \\ I_2\oplus R_2\oplus R_3, i = 2,\hfill \\ I_3\oplus R_3\oplus R_4, i = 3,\hfill \\ ⋮ \hfill \\ I_{m - 1}\oplus R_{m - 1}\oplus R_m, i = m - 1,\hfill \\ I_m\oplus R_m\oplus R_1, i = m.\hfill \end{array}$$

(16)

5.

Based on (k, n) thresholds, generate sharing matrix P_j (1 ≤ j ≤ n) from Equations (8)–(12).

6.

Calculate initial shared images S_jⁱ by images E_i (1 ≤ i ≤ m) and P_j (1 ≤ j ≤ n), which is defined as:

$$S_j^i\left(x,y\right)=\{\begin{array}{c}{E}_i\left(x,y\right),\hspace{0.17em}\hspace{0.17em} \hspace{0.17em}\hspace{0.17em}if P_j\left(x,y\right)=1,\\ 0,\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}if P_j\left(x,y\right)=0,\end{array}$$

(17)

where the number and size of $S_j^i$ are m × n and r × c, respectively.

7.

Obtain shared images S_j (1 ≤ j ≤ n) by concatenating initial shared images S_jⁱ(1 ≤ I ≤ m), as shown in Equation (18):

$$S_j=\left[S_j^1⫽S_j^2⫽\dots ⫽S_j^m\right].$$

(18)

At last, the size of S_j is m × (r × c).

Figure 5 shows a shared image example of (3, 4, 5) thresholds. In the proposed (3, 4, 5) SRM sharing method, 5 secret images are shared to 4 shared images and collecting 3 shared images perfectly recovers these 5 secret images. Figure 5a–e shows 5 secret images and Figure 5f shows one of shared image $S_1$, which is a concatenation of 5 initial shared images $S_1^1~S_1^5$ as virtually segmented by dotted lines.

The recovery algorithm requires k shared images with the same size m × r × c. The proposed recovery algorithm of SRM is introduced as follows.

• Collect k shared images and denote them by S₁, S₂, …, S_k.
• Separate all collected shared images S_i(1 ≤ i ≤ k) to recovered shared images S_i^j(1 ≤ j ≤ m) with size r × c.
• Check all entries (k, l)(1 ≤ j ≤ k, 1 ≤ l ≤ c) among the images S_i^j(1 ≤ j ≤ k) to acquire the temporary image $S_j^{re}\left(1\le j\le m\right)$. For the entry (k, l) with one of the pixel $S_i^j\left(k,l\right)\ne 0$, assign $S_j^{re}\left(k,l\right)$ by the value of $S_i^j\left(k,l\right).$ If all values in the entry (k, l) are 0, then assign $S_i^j\left(k,l\right)$ by 0.
• Acquire the temporary image $I_{XOR}^{re}$ by Equation (19):

$$I_{\mathrm{XOR}}^{\mathrm{re}}{=S}_1^{\mathrm{re}}⨁S_2^{\mathrm{re}}⨁\cdots ⨁S_m^{\mathrm{re}}.$$

(19)

5.

Apply $I_{XOR}^{re}$ to Equation (14) for acquiring the random image $R^{re}$.

6.

Apply $R^{re}$ to Equation (15) for acquiring randomlike images $R_i^{re}$(1 ≤ i ≤ m).

7.

Apply $S_i^{re}$ and $R_i^{re}$ to Equation (20) for obtaining recovered secret images $I_i^{re}$:

$$I_i^{re} = \{\begin{array}{l}{S}_1^{re}\oplus R_1^{re}\oplus R_2^{re}, i = 1,\hfill \\ S_2^{re}\oplus R_2^{re}\oplus R_3^{re}, i = 2,\hfill \\ S_3^{re}\oplus R_3^{re}\oplus R_4^{re}, i = 3,\hfill \\ ⋮\hfill \\ S_{m - 1}^{re}\oplus R_{m - 1}^{re}\oplus R_m^{re}, i = m - 1,\hfill \\ S_m^{re}\oplus R_m^{re}\oplus R_1^{re}, i = m,\hfill \end{array}$$

(20)

After applying the above recovery algorithm by k correct shared images, the recovered secret images $I_i^{re}$(1 ≤ i ≤ m) are consistent with the original secret images. For the recovery of less than k correct shared images, all randomlike images are acquired. Moreover, in Step 3, the nonzero values of all $S_i^j$(k,l)(1 ≤ i ≤ k) should be consistent when no malicious attacks on shared images are applied.

Furthermore, the proposed SRM method assigns 0 to pixels of shared images when the corresponding coordinates of the sharing matrix are 0, as shown in Equation (17). Therefore, each shared image appears dark, as shown in Figure 5f.

3.3. The Proposed (k, n, m) Source-Random-Separate (SRS) Algorithm

This section introduces our second proposed (k, n, m) source-random-separate (SRS) algorithm. The sharing matrices introduced in Section 3.1 are also needed in the proposed sharing and recovery algorithms. Figure 6 shows the proposed SRS sharing steps, and the proposed SRS sharing algorithm is introduced as follows.

• Apply m secret images I_i(1 ≤ i ≤ m) to XOR operation for acquiring I_XOR by Equation (13).
• Generate a randomlike image Z with size r × c by the function image_synthesis(b,r,c) defined in Equation (14). The seed b is the same seed as used to generate the exchanged matrix in Equation (11).
• Apply the XOR operation between I_XOR and Z to acquire the randomlike image $S{R}_0$ by Equation (21):

$${\mathit{SR}}_0{=I}_{\mathit{XOR}}⨁Z.$$

(21)

4.

Based on (k, n) thresholds, generate sharing matrix P_j(1 ≤ j ≤ n) by Equations (8)–(12).

5.

Use Equation (22) to calculate images SR_j(1 ≤ j ≤ n) by sharing matrix P_j.

$$S{R}_j\left(x,y\right)=\{\begin{array}{c}S{R}_0\left(x,y\right), \hspace{0.17em}\hspace{0.17em}if P_j\left(x,y\right)=1,\hfill \\ randi\left(255\right),\hspace{1em} if P_j\left(x,y\right)=0,\hfill \end{array}$$

(22)

where j ranges between 1 and n, and randi(255) acquires a random integer between 0 and 255.

6.

Apply I_XOR and Equation (14) to generate the random image R.

7.

Generate a series of randomlike images R_i(1 ≤ i ≤ m) from the random image R by Equation (15).

8.

Apply I_i and R_i by Equation (16) to obtain encrypted images E_i(1 ≤ i ≤ m).

9.

Randomly select m columns from the initial matrix N in Equation (9) to acquire matrix N_part, i.e.,

$$N_{\mathit{part}}=\mathit{randSelect}\left(N,m,h\right),$$

(23)

where h is acquired from Equation (14) and matrix N is acquired from Equations (8) and (9) with size n × m.

10.

Use Equation (24) to acquire share $E_j^i$ by the matrix value of N_part:

$$E_j^i=\{\begin{array}{c}{E}_i,\hspace{0.17em}\hspace{0.17em} \hspace{0.17em}\hspace{0.17em}if N_{part}\left(j, i\right)=1,\\ \varnothing ,\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em} \hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}if N_{part}\left(j,i\right)=0,\end{array}$$

(24)

where two coordinates i and j are ranged as $1\le i\le m$ and $1\le j\le n$.

11.

Concatenate SR_j and $E_j^i$(1 ≤ i ≤ m) to acquire shared images S_j, i.e.,

$$S_j{=\mathit{SR}}_j⫽E_j^1⫽\cdots ⫽E_j^m.$$

(25)

Figure 6. Processes of the second proposed source-random-separate (SRS) algorithm.

Figure 6. Processes of the second proposed source-random-separate (SRS) algorithm.

The proposed SRS method shares XOR result I_XOR and the randomlike images R_i(1 ≤ i ≤ m) with secret images I_i (1 ≤ i ≤ m) separately. Especially, in Step 10, the images $E_i$ are selected according to the $N_{part}$ matrix. Assume in the proposed (3, 4, 5) SRS method with the encrypted images E_i(1 ≤ i ≤ 5) and the matrix $N_{part}=\left[\begin{array}{ccccc}1& 0& 1& 0& 0\\ 1& 0& 0& 1& 1\\ 0& 1& 0& 1& 0\\ 0& 1& 1& 0& 1\end{array}\right],$the concatenation of images $E_i$ is acquired from the matrix element of $N_{part}$. In the first row, the 1st and 3rd elements being 1 leads to share $E_1^i\left(1i 5\right)=\left\{E_1,\varnothing ,E_3,\varnothing ,\varnothing \right\}.$ From the N_part matrix, we can also acquire shares $E_2^i=\left\{E_1,\varnothing ,\varnothing ,E_4,E_5\right\}$,$E_3^i=\left\{\varnothing ,E_2,\varnothing ,E_4,\varnothing \right\},$and $E_4^i=\left\{\varnothing ,E_2,E_3,\varnothing ,E_5\right\}.$ Therefore, gathering 3 shares among $E_j^i\left(1\le j\le 4\right)$ acquires all $E_i\left(1\le i\le 5\right)$for the further recovery processing. Furthermore, size of the shared images is determined by the number of elements containing 1 in each row of the $N_{part}$ matrix. Therefore, size of shared image $S_j$ is t × r × c, in which t is equal to $1+\left|N_{part}^j\right|$ and $\left|N_{part}^j\right|$ denoted number of elements with 1 in the j rows of matrix $N_{part}$.

The recovery algorithm of the proposed (k, n, m) SRS is introduced as follows.

• Collect k shared images and denote them by S_j(1 ≤ j ≤ k).
• Extract each shared image $S_j$ with size r × c to acquire SR_j(1 ≤ j ≤ k).
• Generate an initial matrix N and sharing matrix $P_j\left(1\le j\le k\right)$ through Equations (8)–(12).
• Generate a randomlike image Z with size r × c by the function image_synthesis(b,r,c) defined in Equation (14), in which the seed b is the same seed as used to generate the exchanged matrix in sharing matrix generation step of Equation (11).
• Use Equation (26) to acquire $S{R}_0$:

$${\mathit{SR}}_0\left(x,y\right){=\mathit{SR}}_j\left(x,y\right){, \mathrm{if} P}_j\left(x,y\right)=1,$$

(26)

where $1\le x\le r, 1\le y\le c \mathrm{and} 1\le j\le k$.

6.

Apply XOR operation between the $S{R}_0$ and the randomlike image Z to acquire random image I_XOR, i.e.,

$$I_{\mathit{XOR}}{=\mathit{SR}}_0⨁Z.$$

(27)

7.

Apply Equations (14) and (15) with I_XOR to acquire h, R, and $R_j\left(1\le i\le m\right)$.

8.

Apply the initial matrix N and coefficient h with Equation (23) to acquire the matrix N_part.

9.

Split the remaining shared image $S_j$ in Step 2 to groups of r × c matrices and assign each r × c share to $E_j^i\left(1\le i\le m\right)$ by Equation (28):

$$E_j^i=\{\begin{array}{c}\mathrm{new} r\times c \mathrm{matrix}, if N_{part}\left(j,i\right)=1,\\ \varnothing , if N_{part}\left(j,i\right)=0.\end{array}$$

(28)

10.

Replace $E_i$ by extracting the nonempty $r\times c$ matrix to share $E_j^i\left(1\le j\le k\right)$. Moreover, two nonempty elements among r × c share $E_{j1}^i, \mathrm{and} E_{j2}^i\left(j1\ne j2\right)$ should be identical.

11.

Apply $E_i$ and $R_i$ to Equation (29) for covering the secret images $I_i^{re}\left(1\le i\le m\right)$, i.e.,

$$I_i^{\mathrm{re}}=\{\begin{array}{l}{E}_1⨁R_1⨁R_2, i=1,\hfill \\ E_2⨁R_2⨁R_3, i=2,\hfill \\ E_3⨁R_3⨁R_4, i=3,\hfill \\ ⋮\hfill \\ E_{m - 1}⨁R_{m - 1}⨁R_m, i=m - 1,\hfill \\ E_m⨁R_m⨁R_1, i=m.\hfill \end{array}$$

(29)

In Step 10, if two nonempty r × c sharing $E_{j1}^i \mathrm{and} E_{j2}^i\left(j1\ne j2\right)$ are not identical, at least one of the r × c shares $E_{j1}^i \mathrm{or} E_{j2}^i$ is maliciously modified.

3.4. Examples of Sharing and Recovery of the Proposed SRS with Thresholds (2, 3, 2)

In this section, examples of the (2, 3, 2) SRS sharing and recovery processes are introduced. The first way is to generate sharing matrix by the predefined (2, 3, 2) thresholds as follows.

• Use Equation (8) to generate matrix $M=\left[\begin{array}{c}0\\ 1\\ 1\end{array}\right]$ by threshold k = 2, n = 3.
• Apply matrix $M$ to Equation (9) for acquiring matrix N, i.e.,

$$N=\left[\begin{array}{ccc}0& 1& 1\\ 1& 0& 1\\ 1& 1& 0\end{array}\right]$$

3.

Acquire matrices N₁, N₂, and N₃ by applying matrix N to Equation (10), i.e.,

$$N_1={\left[\begin{array}{c}\begin{array}{ccc}1& 0& 1\\ 1& 1& 0\\ 0& 1& 1\\ 1& 0& 1\end{array}\\ ⋮\end{array}\right]}_{256\times 3},N_2={\left[\begin{array}{c}\begin{array}{ccc}1& 1& 0\\ 0& 1& 1\\ 1& 0& 1\\ 1& 1& 0\end{array}\\ ⋮\end{array}\right]}_{256\times 3},N_3={\left[\begin{array}{c}\begin{array}{ccc}0& 1& 1\\ 1& 0& 1\\ 1& 1& 0\\ 0& 1& 1\end{array}\\ ⋮\end{array}\right]}_{256\times 3}$$

4.

Acquire exchanged matrix $N_1^{\prime }, N_2^{\prime },\mathrm{and} N_3^{\prime }$ by applying matrices $N_i\left(1\le i\le 3\right)$ to Equation (11), i.e.,

$$N_1^{\prime }=\left[\begin{array}{c}\begin{array}{ccc}0& 1& 1\\ 1& 0& 1\\ 0& 1& 1\\ 1& 1& 0\end{array}\\ ⋮\end{array}\right], N_2^{\prime }=\left[\begin{array}{c}\begin{array}{ccc}1& 0& 1\\ 1& 1& 0\\ 1& 0& 1\\ 0& 1& 1\end{array}\\ ⋮\end{array}\right],N_3^{\prime }=\left[\begin{array}{c}\begin{array}{ccc}1& 1& 0\\ 0& 1& 1\\ 1& 1& 0\\ 1& 0& 1\end{array}\\ ⋮\end{array}\right]$$

5.

Acquire sharing matrices P₁, P₂, and P₃ by applying matrices $N_i^{\prime }\left(1\le i\le 3\right)$ to Equation (12):

$$\begin{array}{c}{P}_1={\left[\begin{array}{c}\begin{array}{cccccc}0& 1& 1& 0& 1& 1\\ 1& 0& 1& 1& 0& 1\\ 0& 1& 1& 0& 1& 1\\ 1& 1& 0& 1& 1& 0\end{array}\\ ⋮\end{array}\cdots \right]}_{256\times 258},{\begin{array}{c} \\ P\end{array}}_2={\left[\begin{array}{c}\begin{array}{cccccc}1& 0& 1& 1& 0& 1\\ 1& 1& 0& 1& 1& 0\\ 1& 0& 1& 1& 0& 1\\ 0& 1& 1& 0& 1& 0\end{array}\\ ⋮\end{array}\dots \right]}_{256\times 258},\\ P_3={\left[\begin{array}{c}\begin{array}{cccccc}1& 1& 0& 1& 1& 0\\ 0& 1& 1& 0& 1& 1\\ 1& 1& 0& 1& 1& 0\\ 1& 0& 1& 1& 0& 1\end{array}\\ ⋮\end{array}\cdots \right]}_{256\times 258}.\end{array}$$

Figure 7 shows an example of the proposed SRS method with thresholds (2, 3, 2). In the proposed (2, 3, 2) method, 2 secret images are shared among 3 shared images with XOR operations and gathering 2 of these 3 shared images perfectly recover these 2 secret images. Figure 7a,b shows two secret images with size 256 × 256 and Figure 7c,d shows two encrypted images in Step 8 of sharing algorithm. Figure 7e–g shows three generated shared images with size 256 × 512, 256 × 512, 256 × 768, respectively. The recovery of acquiring two secret images should collect 2 shared images. Applying Figure 7e,f to the proposed recovery algorithm acquires 2 secret images, as shown in Figure 7a,b.

The sharing processes of the proposed (2, 3, 2) SRS method is introduced as follows.

• Apply secret images $I_1$ and $I_2$ to Equation (13) for obtaining $I_{XOR}$.
• Generate randomlike image Z by Equation (14).
• Generate randomlike image $S{R}_0$ by Equation (21).
• Generate the sharing matrices P_i(1 ≤ i ≤ 3) above by thresholds (2, 3, 2) with size 256 × 256 by Equations (8)–(12).
• Applying $S{R}_0$ and $P_i\left(1\le i\le 3\right)$ to Equation (22) acquires $S{R}_i\left(1\le i\le 3\right)$.
• Apply $I_{XOR}$ and Equation (14) to generate the random image $R$.
• Generate randomlike images $R_1$ and $R_2$ from the random image $R$ by Equation (15).
• Apply $I_1, I_2$ and $R_1, R_2$ by Equation (16) to obtain encrypted images $E_1, E_2$, as shown in Figure 7c,d, respectively.
• Randomly select two columns of $N=\left[\begin{array}{ccc}0& 1& 1\\ 1& 0& 1\\ 1& 1& 0\end{array}\right]$ to acquire matrix $N_{part}=\left[\begin{array}{cc}0& 1\\ 1& 0\\ 1& 1\end{array}\right]$.
• Apply $N_{part}$ and $E_1$, $E_2$ to Equation (24) to generate $E_1^i=\left\{\varnothing ,E_2\right\}$, $E_2^i=\left\{E_1,\varnothing \right\}, E_3^i=\left\{E_1,E_2\right\}$.
• Acquire shared images by $S_1=\left[S{R}_1\parallel E_2\right],S_2=\left[S{R}_2\parallel E_1\right],S_3=\left[S{R}_3\parallel E_1\parallel E_2\right]$, as shown in Figure 7e–g, respectively.

The recovery processes of the proposed (2, 3, 2) SRS method is introduced as follows.

• Collect two shared images S₁ and S₂.
• Extract SR₁, SR₂ from S₁, S₂ with size of 256 × 256.
• Generate the initial matrix $N=\left[\begin{array}{ccc}0& 1& 1\\ 1& 0& 1\\ 1& 1& 0\end{array}\right]$ and sharing matrix P₁, P₂, P₃ from Equations (8)–(12).
• Generate a randomlike image Z with size r × c by Equation (14).
• Use Equation (26) with P₁, P₂ and SR₁, SR₂ to recover $S{R}_0$.
• Use Equation (27) with SR₀ and Z to acquire I_XOR.
• Apply Equations (14) and (15) with I_XOR to acquire R₁ and R₂.
• Acquire the matrix $N_{part}=\left[\begin{array}{cc}0& 1\\ 1& 0\\ 1& 1\end{array}\right]$.
• Assign the remaining part of shared images S₁ and S₂ to E₁ and E₂, respectively.
• Apply Equation (29) with R₁, R₂ and E₁, E₂ to recover secret images I₁, I₂.

4. Experimental Results and Discussions

This section demonstrates the experimental results of our proposed (k, n, m) approach. Section 4.1 presents experimental results of the proposed approach with different thresholds and recovery of attacked shared images. All experiments are performed on a PC with an Intel i7-4720HQ CPU, and 16 G RAM, using MATLAB 9.10 software. The size of all secret images is 256 × 256. Section 4.2 presents the performance of the proposed approach with comparing other multiple secret image sharing methods.

4.1. Experimental Results

Figure 8 and Figure 9 show the experimental results of two proposed schemes, the SRM and SRS methods, by sharing with thresholds (k, n, m) = (3, 4, 5) for sharing 5 secret images among 4 shared images and collecting 3 shared images that perfectly recover these 5 secret images. Figure 8 shows the results of our SRM method presented first. Figure 8a–e shows the 5 secret images: Lenna, Baboon, House, Cameraman, and Barbara with size 256 × 256. Figure 8f–i shows 4 shared images with size 256 × 1280, in which each shared image is the combination of five parts for every secret image with size 256 × 256. Therefore, the size of the shared images is proportional to the number of secret images as 5 times 256 × 256 in this example. Two kinds of recovered secret images are provided. Figure 8j–n shows 5 recovered secret images from Figure 8f–h, and Figure 8o–s shows 5 recovered secret images from the Figure 8f,g collection. Figure 8f–h fits the recovery threshold k = 3 for perfectly acquiring the images in Figure 8j–n that are identical to the original secret images. However, the collection shown in Figure 8f,g cannot satisfy the recovery threshold k = 3 and the recovered secret images all appear as noise images because of the failed acquisition of $I_{XOR}^{re}$ in Equation (19). Moreover, the proposed SRM method uses a sharing matrix to assign part of pixels in shared images to 0, as defined in Equation (17). Therefore, the shared images all appear darker than the random images. Moreover, because of the large usage of 0 pixels, some kinds of regularity can also be found.

Figure 9 shows the results of our second proposed SRS method. Figure 9a–e shows the same 5 secret images with size 256 × 256. Figure 9f–i shows 4 shared images of the parameter b = 1 in step 2 of sharing algorithm and generating matrix of size 4 × 5 as $N_{part}=\left[\begin{array}{ccccc}1& 0& 1& 0& 0\\ 0& 1& 0& 1& 0\\ 0& 0& 1& 1& 1\\ 1& 1& 0& 0& 1\end{array}\right]$ in Equation (23). The first and third elements in the first row of the matrix $N_{part}$ exhibit the element 1 and it leads the shares of $E_1\hspace{0.17em}$ and $E_3$ as defined in Equation (24). These two shares with the sharing of $S{R}_1$ lead to the shared image with a size that is three times that of the secret image. Therefore, the first shared image is shown in Figure 9f with the size 256 × 768, which is three times the secret image size 256 × 256. Moreover, the third row of $N_{part}$ leads to the share of $E_3$, $E_4$, and $E_5$ that are needed. Consequently, four times the secret image size is obtained, as shown in Figure 9h, with the size 256 × 1024. Therefore, sizes of shared images are according to the number of elements with 1, as shown in Figure 9f–i, being 256 × 768, 256 × 768, 256 × 1024, and 256 × 1024, respectively. In the recovery process, collecting k = 3 number of shared images is needed for perfect recovery. Collecting shared images shown in Figure 9f–h recovers the reconstructed images, as shown in Figure 9j–n. The collected shared images less than k, as shown in Figure 9g,i, recover the reconstructed images, as shown in Figure 9o–s, in which all recovered images appear as noise images.

Table 1. Performance of sharing and recovery procedures at different thresholds.

Thresholds	Sharing Computation Time (s)		Recovery Computation Time (s)
(k, n, m)	SRM	SRS	SRM	SRS
(2, 3, 4)	1.123222	0.377484	0.419478	0.333834
(3, 4, 5)	1.873811	0.521364	0.583452	0.415034
(3, 5, 3)	1.222763	0.539960	0.374655	0.332443

shows the computation time of the two proposed schemes, SRM and SRS, among three different thresholds. The two proposed XOR-based schemes require limited CPU computation time, and the performances of the proposed schemes are exhibited. Moreover, the computation complexities between the two proposed schemes, SRM and SRS, are different. In our first proposed SRM method, the complexity of the sharing and recovery algorithms are O(nm) and O(km), respectively. Furthermore, the sharing and recovery complexities of our second SRS method are O(n) and O(k), respectively.

Since our second proposed SRS method outperforms our first proposed SRM method in both less computation time and smaller size of shared images, more experimental results for our second proposed SRS method are illustrated. Figure 10 shows experimental results of the proposed (3, 5, 3) SRS method by the shared images with homogeneous regions. Figure 10a–c are three generated secret images, which are constructed by simple color regions with size 256 × 256. The generated $N_{part}$ is defined by $\left[\begin{array}{c}\begin{array}{ccc}0& 0& 1\\ 1& 1& 0\\ 1& 0& 1\end{array}\\ \begin{array}{ccc}1& 1& 1\\ 0& 1& 0\end{array}\end{array}\right]$ with size 5 × 3, the size that is determined by n × m under thresholds (k, n, m). From definition of the first row in $N_{part}$, the first shared image, shown in Figure 10d, includes the random image $S{R}_1$ and one share of the third secret image from Figure 10c. Therefore, the size of the first shared image is twice the secret images at 256 × 512. Moreover, Figure 10e shows the second shared image of the combination of the random image $S{R}_2$ and two shares of the first and the second secret images from Figure 10a,b, respectively. Therefore, the size of the second shared image is three times that of the secret images at 256 × 768. At last, the fourth shared image, shown in Figure 10g with size 256 × 1024, includes the random image $S{R}_4$ and three shares of the first, second, and third secret images from Figure 10a–c, respectively. Therefore, three different kind of sizes are found in the proposed (3, 5, 3) SRS method, as shown in Figure 10d–h, and these shared images all exhibit randomlike images. Two kinds of recovery results are also provided. Figure 10i–k are the recovered secret images from Figure 10d–f. Figure 10l–n are the recovered secret images from Figure 10g,h. Since the collected number of shared images is less than threshold k, the recovered secret images are all noiselike images that exhibit the threshold recovery property of our proposed scheme.

Figure 11 shows the recovery results of applying attacks on shared images of homogeneous secret images. Figure 11a–e exhibit five shared images, which are the same as Figure 10d–h as the shared images of Figure 11a–c. Figure 11f shows a malicious attack result on Figure 11a by replacing one small black block in the left area. Figure 11g–i shows the recovered shared image from Figure 11a–c. The recovery of Figure 11b,c,f is shown in Figure 11j–l, which shows that any attack leads to false recovery because of the incorrect random image generated. Therefore, security of the proposed scheme is identified.

4.2. Comparison and Discussion

This section compares the proposed method with other stacking or XOR-based secret image sharing methods. The comparison metrics include lossless recovery or not, recovery strategy, sharing threshold, multiple sharing or not, and sharing capacity. The stacking-based schemes generate visual similarity on recovered secret images. Therefore, only stacking-based schemes are not lossless recovery and other XOR-based methods can recover without loss all secret images. In sharing thresholds, the method of Kabirirad and Eslami [24] satisfies restrictively consecutive k shared images and only adopt sharing matrix strategies that satisfy the general (k, n) threshold property with $k\le n$. Other methods, such as stacking-based or XOR-based, only have (2, 2) or (n, n) thresholds. It should be noted that many related methods cannot solve the way to construct multi-secret image sharing with general (k, n) thresholds; however, the proposed multiple sharing property exhibits the structure of sharing several secret images simultaneously. In a Boolean-based (n, n) secret image sharing method, all the secret and shared images are the same size. The sharing capacity is the measurement of dividing the number of secret images by the number of shared images required to recover secret images. Therefore, in a Boolean-based (k, n) secret image sharing method, the sharing capacity is extended to dividing the size of secret images by the size of shared images required to recover secret images. Large sharing capacity means smaller shared image acquired. The sharing capacities of the proposed SRM method and SRS method are $\frac{1}{k}$ and $\frac{n}{{{\displaystyle \sum }}_{i=1}^k{u}_i+1}$ with $u_i$ < n, respectively. Furthermore, the value $u_i$ is determined by the matrix $N_{part}$ as the number of elements with 1 in the corresponding row.

Table 2. Comparisons between the two proposed approaches and related multiple secret image sharing methods.

	Lossless Recovery	Recovery Strategy	Sharing Threshold	Multiple Sharing	Sharing Capacity
Wu et al. [18]	No	Stacking	(2, 2)	No	$\frac{2}{2\times 4}$
Chen et al. [15]	No	Stacking	(2, 2)	Yes	$\frac{n}{2\times 4}$
Shyu et al. [16]	No	Stacking	(2, 2)	Yes	$\frac{n}{2\times \left(2\times n\right)}$
Lin et al. [17]	No	Stacking	(2, 2)	Yes	$\frac{2}{2}$
Wang et al. [6]	Yes	XOR	(n, n)	No	$\frac{1}{n}$
Chen and Wu [12]	Yes	XOR	(n, n)	Yes	$\frac{n-1}{n}$
Chen and Wu [13]	Yes	XOR	(n, n)	Yes	$\frac{n}{n}$
Chen et al. [21]	Yes	XOR	(n, n)	Yes	$\frac{n}{n}$
Bao et al. [20]	Yes	sharing matrix	(k, n)	No	$\approx \frac{2}{k}$
Prasetyo and Jing [22]	Yes	Chinese remainder theorem	(n, n)	Yes	$\frac{n}{n}$
Chattopadhyay et. al. [23]	Yes	XOR	(n, n)	Yes	$\frac{n}{n}$
Kabirirad and Eslami [24]	Yes	XOR	Consecutive (k, n)	Yes	$\frac{n}{n}$
Our proposed SRM method	Yes	XOR with sharing matrix	(k, n)	Yes	$\frac{1}{k}$
Our proposed SRS method	Yes	XOR with sharing matrix	(k, n)	Yes	$\frac{n}{{{\displaystyle \sum }}_{i=1}^k{u}_i+1}$

shows that the proposed SRM and SRS methods are the only XOR and sharing matrix-based methods that can perform (k, n) thresholds on multiple sharing with good sharing capacity.

Table 3. Sharing capacity comparisons among the proposed approaches and related multiple secret image sharing methods.

	Recovery Quality	(2, 2) Sharing Capacity	(2, 3) Sharing Capacity	(3, 3) Sharing Capacity	(3, 4) Sharing Capacity
Wu et al. [18]	recognizable	$0.25$		$\times$
Chen et al. [15]	recognizable	$0.375$		$0.5$
Shyu et al. [16]	recognizable	$0.25$		$0.25$
Lin et al. [17]	recognizable	$1$		$\times$
Wang et al. [6]	100%	$0.33$		$0.25$
Chen and Wu [12]	100%	$0.66$		$0.75$
Chen and Wu [13]	100%	$1$		$1$
Chen et al. [21]	100%	$1$		$1$
Bao et al. [20]	100%		$\approx 1$		$\approx 0.66$
Our proposed SRM method	100%		$0.5$		$0.33$
Our proposed SRS method	100%		0.5		$0.38$

shows an example of sharing capacity comparisons between the two proposed methods and other related methods. Since some conventional methods [6,12,13,15,16,17,18,21] only have the (n, n) thresholds; therefore, these methods are restricted to (2, 2) and (3, 3) sharing capacities. Moreover, only Bao et al. [20] and our two proposed methods satisfy the requirement of (k, n) thresholds. Therefore, these three methods have (2, 3) and (3, 4) sharing capacities. Although the method of Bao et al. [20] can only share one image secretly, its sharing capacity is higher because of adopting an encryption method during the sharing process. Finally, the two proposed schemes are the only methods for sharing multiple images secretly. Moreover, the proposed SRS method outperforms the proposed SRM method on more randomly shared images and better sharing capacity.

5. Conclusions

In this study, our contribution is a novel framework that can share m secret images among n participants, and gathering k participants’ shared images perfectly recover these m secret images. We propose two XOR-based (k, n, m) multi-secret image sharing schemes. The first is the source-random-mixed (SRM) method, which mixes the random image and secret images to generate shares for each secret image. The second is the source-random-separate (SRS) method, which separates the random image and secret images for constructing the shares for each secret image. Both of the proposed schemes reach the general (k, n) threshold by the usage of a sharing matrix, which is a popular property in mathematical-calculation-based methods such as the Shamir–Lagrange-based method. The proposed schemes have the properties of lossless recovery on collecting k shared images and no useful information acquired on collecting less than k shared images. The proposed schemes outperform other multiple sharing methods on the sharing rate of larger than or equal to 1. Therefore, these two proposed schemes exhibit good improvements on sharing multiple secret images through (k, n) thresholds by using XOR and a sharing matrix based Boolean operations.

In this study, we propose two efficient XOR-based (k, n, m) multi-secret image sharing schemes; however, there are several challenges and limitations to the proposed approach. First, the size of all the secret images used in the proposed approach must be equal, the multiple shared images generated are affected by the randomly generated matrix, and the sizes of each shared image are likely to be different. Second, the performance is relatively low compared to the secret image sharing method that simply uses Boolean operations. Based on these challenges and limitations, how to improve our proposed SRS method to identical size and how to apply the proposed approach in various actual applications, such as share authentication [28,29] and e-voting [30], merit our future study.