An Innovative Information Hiding Scheme Based on Block-Wise Pixel Reordering

1. Introduction

In modern days, iCloud data transmission replaces the physical mails to speed up the time spent on exchanging information. Needless to mention, the Internet is a key element in the transmission process. Digital activities involve both virtual world and physical world can be foreseen in the near future. If a hospital technician uploads an x-ray image, a CT-scan photo, or its patient’s information to a data center for a list of specific doctors to download them to discuss various treatments over an online meeting. To protect the privacy of the patient, no one should see the information other than related doctors. Encrypting and decrypting of these digital information are getting more and more important to increase the security. At the same time, there can be diagnostics information to be passed to one or some particular doctors. Data hiding then plays another crucial role in these data transitions [1].

When a content owner wants to send an image to a data receiver, the owner would like to add a secret message in the image before transmitting it to the receiver. Adding the secret message normally needs to go through a data hider and it may not be desirable for the data hider to see the image content, the owner encrypts the the image before sending the image to hide the message. A receiver holding the encryption key can recover the image and a receiver having the data hiding key can extract the secret information.

There are various data hiding schemes designed to protect data effectively in different application circumstances and demonstrated exceptional results. Data hiding is branched out to reversible data hiding (RDH) [2] and non-reversible data hiding depending on if the image content can be recovered or not. A wider range of applications adopted RDH schemes because of their reversibility and thus RDH studies became more popular in the recent decades. According to the hiding carriers, the hiding schemes can be catalogued into four different domains: spatial, frequency, compression and encryption. When in the spatial domain, digital cover images are modified directly to embed data. As for the frequency domain, images are transformed by wavelet transform methods before embedding data. Images are first compressed by compression technique prior to embedding information in the compression domain. In the encryption domain, images are encrypted using encryption keys before sending to data hider to hide secret in the encrypted image [3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26]. Reversible data hiding in encrypted images (RDH-EI) combines cryptography and RDH technology to achieve higher levels of protection. In order to better secure information privacy, our scheme focuses on using encrypted images to hide data. Our research goal is to achieve larger embedding capacity without degrading visual quality of recovered images. The core contributions of the scheme are described as below:

• The scheme offers large embedding capacity.
• To sustain the visual quality of encrypted images.
• Extracting secret messages and recovering images can be independent.

The rest of the paper is structured as the follows: Section 2 discusses the related works which including the LSB encryption, the sorting applied and the key index reordering method. Section 3 describes the details of the novel scheme and Section 4 shows the experiments conducted and their analyses. Finally, Section 5 is the conclusion.

2. Related Work

Our novel scheme employs the principle idea of a vector quantization (VQ) [12] codeword index reordering scheme [13] as the basic technique to embed and extract data. This section describes the data embedding and data extraction using the codeword index reordering.

When there is a codebook, it is sorted first before embedding secret data. The data is embedded through the new indices in a stego codebook. Figure 1 indicates the flow of the codeword index reordering scheme including data embedding, data extraction and image recovery. The stego codebook with the new ordered indices is then sent to receivers to extract the data.

2.1. Sort Codewords by Projected Values

A sorted codebook is an essential component for a codeword index reordering scheme [13]. There is a VQ codebook $CB=\{{cw}_0,{cw}_1,,{cw}_{m-1}\}$, where $m$ is the number of the codewords in the codebook. A data hider will find an n-dimensional point $D=\{r_1,r_2,\cdots ,r_n\}$, $r_1,r_2,\cdots ,r_n$ are randomly generated using a random seed. A line $\overrightarrow{OD}$ connecting $D$ and the origin $O=\{0,0,\cdots ,0\}$ is a line that codewords in a codebook can project and get their projected values. These projected values are denoted as ${\lambda }_1$, ${\lambda }_2$, ...., ${\lambda }_n$ using Eq. (1) and to be used to sort the codewords in the codebook.

$${\lambda }_k={cw}_k\cdot \overrightarrow{OD},0\le k\le m-1.$$

(1)

The codebook $CB$ is sorted and resulted to a sorted codebook $CB\text{'}=\{{cw}_0^{\text{'}},{cw}_1^{\text{'}},\cdots ,{cw}_{m-1}^{\text{'}}\}$.

An example of a codebook consists of eight 2-dimensional codewords is demonstrated in Figure 2 for better understanding of projected values and the sorting result according to their projected values.

2.2. Data Embedding of the Codeword Index Reordering

When there is a secret data $S=\left\{s_0,s_1,\cdots ,s_k\right\},s_k=\left\{0,1\right\}$, embedding procedure is stepped as the following:

Step 1: Initialize a stego codebook $SCB$.

Step 2: Calculate the number of bits to embed

$$b=\lfloor {log}_2\left(length\right(SCB\left)\right)\rfloor .$$

(2)

Step 3: Convert secret bits to a decimal index

$${\left(indx\right)}_{10}={(s_0\parallel s_1\parallel \cdots \parallel s_{b-1})}_2.$$

(3)

Step 4: Move the codeword ${scw}_{indx}$ out from $CB\text{'}$ and add to $SCB$.

Step 5: Repeat Step 2 thru Step 4 until there is no codeword in $CB\text{'}$.

Step 6: Send $SCB$ to receivers.

Using the example in Figure 1, the embedding results is illustrated in Figure 3.

2.3. Data Extraction of the Codeword Index Reordering

When a receiver receives a stego codebook $SCB=\{{scw}_0,{scw}_1,\cdots ,{scw}_{m-1}\}$, the stego codebook needs to be sorted by the projected values of codewords using the received projecting line $\overrightarrow{OD}$ before extracting secret data. The following steps showing how the secret data are extracted:

Step 1: Project the codewords in $SCB$ to the line $\overrightarrow{OD}$ and sort the codebook by using the projected values of the codewords to get the recovered codebook $RCB$.

Step 2: Initialize recovered secret $RS$.

Step 3: Initialize the current codeword index c$i$ to 0.

Step 4: Match the current codeword ${scw}_i$with the codewords in the recovered codebook $RCB$ and get the index $si$ in the $RCB$.

Step 5: Convert ${\left(si\right)}_{10}$ to a binary bit stream $RS’=$ ${({rs}_0\parallel {rs}_1\parallel \cdots \parallel {rs}_{k\text{'}})}_2$.

Step 6: Append $RS’$ to $RS$.

Step 7: Increase the current codeword index c$i$ by 1.

Step 8: Repeat Step 4 thru Step 7 until all codewords in $SCB$ are exhausted.

Continue to use the example above, Figure 4 demonstrates how the data are extracted from the stego codebook $SCB$.

3. Proposed Scheme

To protect the privacy of original cover images, our novel scheme encrypts the cover image before data embedding using an encryption key. A content owner sends the encrypted image to a data hider to hide secret messages. The data hider sends the marked images, the encryption key and the data hiding key to designated receivers after hiding data.

3.1. Image Encryption

Content owners can use any of the existing encryption methods to protect the privacy of the original images and send the encrypted images to third-party data hiders. The Stream Cipher technique [14], an exclusive OR operation to encrypt a cipher stream generated by using an encryption key $k_e$, is a well-known, simple and efficient method to encrypt images. When there is an original image $I$ of size $M\times N$, a pseudorandom matrix used as an encryption key $k_e$with the matching size of the image $I$ and whose values are ranged between 0 and 255 is generated by using a random seed value. The stream cipher is a symmetrical encryption algorithm which uses the encryption key $k_e$ in both encryption and decryption. A pixel value and its corresponded encryption key value are converted to 8-bit binary system using Eqs. (4) and (5),

$$I_{ij}^x=⌈\frac{I_{ij}}{2^{x-1}}⌉mod2,$$

(4)

where $ij$ represents the $(i,j)$ coordinates, 1 $\le$ i $\le M$ and 1 $\le$ j $\le N$.

$${k_e}_{ij}^x=⌈\frac{{k_e}_{ij}}{2^{x-1}}⌉mod2,$$

(5)

where $ij$ represents the $(i,j)$ coordinates, 1 $\le$ i $\le M$, 1 $\le$ j $\le N$ and $x$ is the bit order from right to left can be represented as $x$=1,2,⋯,8. After binary conversion, a bit-level XOR as Eq. (6) is applied,

$${I_e}_{ij}^x=I_{ij}^x\oplus {k_e}_{ij}^x.$$

(6)

Encrypted image ${I_e}_{ij}^x$ is converted back to decimal encrypted image

$$I_{ij}^{\text{'}}=\sum _{x=1}^8{I_e}_{ij}^x\times 2^{x-1}.$$

(7)

3.2. Codeword Table Generation

After a data hider obtains the encrypted image $I^{\text{'}}$, it is converted into a pixel stream. Depending on the block size desired, it is broken into pixel blocks. An owner can set the number of blocks in a group to perform the index reordering technique which is derived from the codeword index reordering.

After obtaining the encrypted image $I^{\text{'}}$which consists of $M\times N$ pixels, it is denoted as $I^{\text{'}}=\{p_0,p_1,\cdots ,p_{\left(M\times N\right)-1}\}$. The encrypted image is cut into pixel-blocks and each pixel-block contains $n$ contiguous pixels. A current pixel-block can be denoted as $b_c=\{p_{n\left(c-1\right)},p_{n\left(c-1\right)-1},\cdots ,p_{n(c-1)-(n-1)}\}$, where $c$ is the number of the current pixel-block. After pixel-blocks are formed, $m$ pixel-blocks are grouped together to be a block-group $g_l=\{b_{m(l-1)},b_{m\left(l-1\right)+1},\cdots ,b_{m\left(l-1\right)+(m-1)}\}$, where $l$ is the number of the current block-group and m is the length of a desired codeword table for the codeword index reordering detailed in Section 2. The total number of block-groups is $K=\frac{(M\times N)}{(m\times n)}$ and the block-groups in the encrypted image $I^{\text{'}}$can be represented as $G=\{g_0,g_1,\cdots ,g_{K-1}\}$. A codeword table containing $m$ n-dimensional codewords is generated for each corresponding block-group $g_l$.

Figure 6 is an example on how pixel-blocks and block-groups are created for a $512\times 512$ image. When a pixel-block consisting of 8 pixels and a block-group combining 255 blocks, there are 32768 pixel-blocks and 128 block-groups are formed in total for the encrypted image.

A codeword table for the block-group $g_0$of the example in Figure 6 is illustrated in Figure 7. The codeword table is treated as a codebook used in the codeword index reordering to hide data at a later stage.

3.3. Pixel-Block Number Embedding

Before hiding data, recording the indices of pixel-blocks in a block group is needed for the image recovery. The original index of a pixel-block $N_b$ in a block-group is calculated based on

$$N_b=b_{i}modm,$$

(8)

where $m$ is the number of pixel-blocks in a block-group and $b_i$ is the current pixel-block. For example, the number of pixel-block $b_2$ in block-group $g_0$is 2 and the number of pixel-block $b_{257}$ in block-group $g_1$is 1. Figure 8 shows a diagram on how pixel-blocks are numbered in each block-group.

Since there are $n$ pixels in a pixel-block, the least significant bit (LSB) [15] of each pixel in the block is used to indicate its pixel block number in a block group. Figure 9 demonstrates how to embed a calculated block number $N_b$to LSBs. The LSB bit in each pixel inside of a pixel-block is replaced with the binary bit value of its calculated block number in its group. The example shows the decimal value of 1 which is the calculated block number for $b_1$ in $g_0$.

After embedding the calculated block numbers as metadata into the LSBs, the encrypted image $I_e$ is now an encrypted image embedded with image recovery information. It is then sent to the data hider to hide secret data.

3.4. Data Hiding

When the data hider receives the encrypted image $I_e$ with embedded block numbers, a data hiding key $k_s$ and a secret message $SM=\left\{{sm}_0,{sm}_1,\cdots ,{sm}_k\right\},{sm}_k=\left\{0,1\right\}$, an n-dimensional line $L$ is generated according to the extraction key $k_s$. The pixels in each pixel-block form a codeword and get a projected value by projecting the codeword to the line $L$. A codeword table $T$ is created for each block group by using these codewords and sorted by their projected values. The sorted codeword table $T\text{'}$ is then used to embed the secret bits by applying the codeword index reordering technique described in Subsection 2.2.

The Algorithm 1 detailed the steps of how to embed the secret message $SM$:

3.5. Data Extraction and Image Recovery

After receiving the marked image $I_m$, the secret message can be extracted when a receiver has the data hiding key $k_s$. When a receiver has the encryption key $k_e$, a recovered image with high visual quality can be obtained. If a receiver has both keys, the secret message can be extracted and the recovered image can be obtained.

3.5.1. Data Extraction

If a receiver has a data extraction key $k_s$, the secret data can be extracted. The marked image $I_m$ is converted into a pixel stream first. Depending on the size of a pixel-block $n$ and the number of blocks $m$ in a block-group received, it is divided into pixel-blocks and block-groups first. A n-dimensional line $L$ is generated by using the extraction key $k_s$. The pixels in each pixel-block form a codeword and get a projected value by projecting the codeword to the line $L$. A codeword table $T$ is created for each block group of the marked image by using these codewords and is sorted by their projected values. Both the sorted codeword table $T\text{'}$ and the codeword table $T$ created from the marked image are used to extract the secret data. The detailed steps are in Algorithm 2.

3.5.2. Image Recovery

If a receiver has an encryption key $k_e$, a recovered image with high visual quality can be obtained. The marked image $I_m$ is converted into a pixel stream first. Depending on the size of a pixel-block $n$ and the number of blocks $m$ in a block-group received, the marked pixel stream is broken into pixel-blocks and block-groups. The pixels in each pixel-block form a codeword and a codeword table $T$ is created for each block group of the marked image by using these codewords. We can extract the original pixel-blocks’ indices by extracting the values from the LSBs of pixels in pixel-blocks and recover the pixel values by using the encryption key $k_e$. Algorithm 3 goes through the recovery steps in more details.

4. Experimental Results

n this section, we conducted experiments utilizing the MATLAB environment, version 2017a, within the Windows PC operating system, to assess the performance of the proposed solution and compare it with some state-of-the-art (SOTA) schemes.

We evaluated the performance of the proposed data hiding scheme through experimental analysis. A binary data stream $S$, generated by a random number generator, was employed as the secret information. The two key factors that we pay attention during data hiding are good visual quality and high embedding quantity. To keep the visual quality means that the recovered images look as similar to the original cover images as possible. To efficiently measure the embedding quantity, embedding capacity (EC) is calculated, representing the total number of bits that the proposed scheme could embed in the image. With the evolution of data hiding techniques, numerous metrics have been utilized to assess the visual quality of the restored images. The commonly employed metrics include Peak Signal-to-Noise Ratio (PSNR) and Structural Similarity Index (SSIM). The calculation formulas are provided below:

$$\mathrm{M}\mathrm{S}\mathrm{E}=\frac{1}{W\times H}\sum _{i=1}^W\sum _{j=1}^H(O_{i,j}-R_{i,j}{)}^2,$$

(9)

$$\mathrm{PSNR}=10{\log }_{10}\frac{{\left(255\right)}^2}{\mathrm{MSE}}\left(\mathrm{dB}\right),$$

(10)

$$\mathrm{SSIM}=\frac{\left(2{\mu }_O{\mu }_D+c_1\right)\left(2{\sigma }_{OD}+c_2\right)}{\left[{\left({\mu }_O\right)}^2+{\left({\mu }_D\right)}^2+c_1\right]\left[{\left({\sigma }_O\right)}^2+{\left({\sigma }_D\right)}^2+c_2\right]},$$

(11)

where $W$ and $H$ represent the width and height of the images, $O_{i,j}$ and $R_{i,j}$ denote the pixel values at position $(i,j)$ for the cover image and the restored image. $\mu$ represents the mean value used as an estimate for luminance; and $\sigma$ is the standard deviation used as an estimate of contrast; ${\sigma }_{OD}$ denotes the covariance between the original image $O$ and the restored image $R$ and serves as a metric for structural similarity.; and $c_1$, and $c_2$ are two constants close to zero.

A higher PSNR value indicates less distortion caused by the hidden data. Typically, with PSNR values exceeding 30 dB suggests imperceptible image distortion to the human eye. SSIM combines three factors—luminance, contrast, and structure—to assess the similarity between two images. The SSIM range is from -1 to 1. As the value of SSIM approaches 1, it demonstrates a higher degree of similarity between the two images.

At the same time, information entropy is selected to test the security of the encrypted image, that is, the randomness of the image histogram is calculated by the following method:

$$\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{r}\mathrm{o}\mathrm{p}\mathrm{y}=\sum _{pi=0}^{255}P\left(pi\right)\log \frac{1}{P\left(pi\right)},$$

(12)

where $pi$ represents the image pixel value between 0 and 255, and $P\left(pi\right)$ is the probability of the image pixel value $pi$ occurring. An information entropy value closer to 8 means that the encrypted image has higher randomness.

In Section 4.1, we evaluate the performance of our proposed scheme under different test images. We give some execution results and security analysis in Section 4.2. Section 4.3 gives comparisons with other SOTA schemes.

4.1. Performances of our proposed scheme

The embedding capacity of the proposed scheme is contingent upon the pixel block size and the codeword table size. Therefore, we initially conducted performance tests on different test images by varying the pixel block sizes in a codeword table. The group size in Table 1 and Table 2 is what we call the codebook table size.

Table 1 lists the results of applying the proposed scheme to the test images for different pixel block size configurations with the same codebook table size. We observed that, when pixel blocks have an identical number of pixels, the shapes of the pixel blocks had no effect at all on EC values depicted in Table 1; the shapes also had no significant impact on PSNR, and SSIM. Therefore, we could simplify our scheme by converting the encrypted images to a pixel stream first and specifying the size of a pixel-block without the necessity of specifying the width and the height of a pixel-block. However, the number of pixels within a pixel block had a significant effect on EC, and the larger the size of the pixel block, the less EC the proposed scheme could provide. Moreover, the larger the pixel block, the higher the PSNR and SSIM values of the recovered image when the size of the codebook table was the same. Simultaneously, we observed that the most efficient partitioning is to have $2^n$ pixel-blocks within a block-group when the size of a pixel-block is n.

In addition to these metrics, we also employed the number of pixels changing rate (NPCR), unified average changed intensity (UACI), and mean absolute error (MAE) to evaluate image distortion between the original and the restored images. The calculation formulas for these metrics are as follows:

$$\mathrm{NPCR}=\frac{{\sum }_{i,j}D(i,j)}{W\times H}\times 100\%,$$

(13)

$$D\left(i,j\right)=\left\{\begin{array}{c}1,O(i,j)\ne R(i,j)\\ 0,otherwise\end{array}\right.,$$

(14)

$$\mathrm{UACI}=\frac{\sum |O\left(i,j\right)-R\left(i,j\right)|}{W\times H\times 255}\times 100\%,$$

(15)

$$\mathrm{M}\mathrm{A}\mathrm{E}=\frac{1}{W\times H}\sum _{i=1}^W\sum _{j=1}^H\left|O\left(i,j\right)-R(i,j)\right|,$$

(16)

where $W$ and $H$ represent the width and height of the images, $O(i,j)$ and $R(i,j)$ denote the pixel values at position $(i,j)$ for the cover image and the restored image.

NPCR is employed to compute the number of differing pixels between two images, while UACI is utilized to calculate the average change in pixels between two images. Unlike Table 1, Table 2 is a test of the proposed scheme with various codebook table sizes. From Table 2, it can be clearly found that, as the size of the codebook table becomes larger, the EC of the proposed scheme also becomes larger. Since the efficient pairing of codebook table size and pixel block size was utilized, the LSB of each pixel in a pixel block was used to record the original pixel block index in a group and the PSNR values of all tested scenarios were around 51dB. The PSNR values indicated that our recovered image had a good visual quality. As shown in Table 2, the proposed scheme involves replacing the LSB of pixels with the initial block index in a group after encrypting the image. Consequently, after extracting information and decrypting the image, the LSB of each pixel cannot be fully restored, with a 50% probability of being flipped. As a result, NPCR values are around 50% across various test images. UACI values are notably low, with the highest UACI not exceeding 0.2%, indicating that the average pixel changes induced by the proposed scheme are small even the images cannot be fully recovered. Mean Absolute Error (MAE) is also an indicator for assessing image quality, where a smaller MAE value corresponds to better image quality. From Table 2, we can find that the MAE values are small for all images. In summary, the proposed scheme causes very little damage to the cover images when embedding the secret data and the recovered images are very similar to the cover images.

4.2. Execution results and security analysis

Figure 10 presents the performance results of various test images at different stages. After image encryption, pixel values become disordered, rendering meaningful information indiscernible, and the pixel distribution in the histogram of the encrypted image is uniform consequently. Since our proposed data embedding scheme involves merely scrambling the positions of encrypted pixels after recording the original block indices using LSB replacements, the distribution of pixel values in the encrypted image does not undergo substantial changes. The histogram distributions of the recovered images that we are able to obtain after extracting the information are also very similar to the original histogram distributions.

In addition to information entropy, another way to analyze the differences between adjacent pixels is to use the correlation coefficient to assess the correlation between adjacent pixels. A natural image has a high correlation between neighboring pixels normally, but for a secure encrypted image, the lower the correlation between its neighboring pixels, the more secure it is. It is defined as

$$\mathrm{C}\mathrm{o}\mathrm{r}\mathrm{r}=\frac{{\sum }_{i=1}^N(x_i-\frac{1}{N}{\sum }_{i=1}^N{x}_i)(y_i-\frac{1}{N}{\sum }_{i=1}^N{y}_i)}{\sqrt{{\sum }_{i=1}^N{\left(x_i-\frac{1}{N}{\sum }_{i=1}^N{x}_i\right)}^2\times {\sum }_{i=1}^N{\left(y_i-\frac{1}{N}{\sum }_{i=1}^N{y}_i\right)}^2}}.$$

(17)

We divide the image into pixel pairs, take the former of all pixel pairs as $x_i$ and the latter of all pixel pairs as $y_i$, $N$ denotes the number of pixel pairs, and then calculate the correlation coefficient between them. Table 3, Table 4 and Table 5 were tested with the pixel block size of 8 and the codebook table size of 256. The information entropy and the pixel correlation results for horizontal and vertical pairs are shown in Table 3 and Table 4, respectively.

Table 3 provides measurements for the original, encrypted, and embedded encrypted images of different test images. Clearly, the entropy values for the encrypted and embedded encrypted images of each image are quite similar, as our proposed scheme only employs one-bit LSB replacement on encrypted pixels and subsequently scramble the pixel positions. On the other hand, the entropy values for different encrypted images are consistently close to 8, significantly higher than the entropy values of the original images. Consequently, the distribution of pixel values in encrypted images exhibits heightened randomness, thereby enhancing security.

As shown in Table 4, neighboring pixel values in the original image have strong positive correlation both horizontally and vertically. While the pixels of encrypted and marked images have only very low correlation both horizontally and vertically. Also, the correlation between the marked image and the encrypted image does not change much compared to the encrypted image both horizontally and vertically. This indicates that the Stream Cipher encryption completely encrypts the image, and the proposed scheme that utilizes the reordering of the codebook table to embed the secret data inherits this feature and does not make the correlation between the pixels higher due to the embedded data.

The security of the proposed scheme is further analyzed in Table 5 using two metrics, NPCR and UACI. The definition and computation of both NPCR and UACI have been mentioned in subsection 4.1. In terms of security analysis, the higher the NPCR value, the more effective the encryption algorithm is, because the higher the number of different pixels, the harder the encrypted image is to crack. For two uncorrelated images, the theoretical value of UACI is 33.33%. As shown in Table 5, for both encrypted and marked images, the NPCR value and UACI value of the proposed scheme are close to the theoretical optimal value, which indicates that our scheme can provide a high level of security against potential attacks.

4.3. Comparison with state-of-the-art schemes

In this section, we primarily compare our proposed scheme with some state-of-the-art schemes for data hiding in encrypted images in terms of PSNR, SSIM, and embedding capacity. In Table 6, the embedding capabilities of our proposed schemes all outperform the other schemes. Moreover, our proposed scheme consistently provides stable embedding capacity for any image, as long as the pixel block size and the number of blocks within a group remain unchanged. The independence of embedding capacity from image content is attributed to our utilization of indices within each group for data embedding. So as long as the number of blocks in the group and the size of the pixel blocks are consistent, images of the same size will have the same embedding capacity. From Table 6, it is evident that our proposed scheme also outperforms most of SOTA methods based on the PSNR values and SSIM values. Even though the PSNR is slightly lower than [18], our proposed scheme achieves a PSNR of approximately 51 dB, which is adequate for visual quality of a recovered image.

In Figure 11, we further compare the PSNR of our scheme with more SOTA schemes under different embedding capacities, with a pixel block size of 18 and 256 blocks within a codeword table. In Figure 11, we use the embedding ratio (ER) to represent the embedding capacity (ER = EC/ total number of pixels). As depicted in Figure 11, in most cases, the PSNR values of other schemes tends to decrease with increasing embedding capacity. In contrast, our proposed scheme consistently has a stable PSNR for the recovered image. Therefore, as the amount of embedded secret data increases, the advantages of our proposed scheme become more pronounced in terms of the PSNR and the SSIM of the recovered image. As long as the embedding rate is greater than 0.25 bpp, the proposed scheme has better visual quality and higher embedding capability than other schemes.

5. Conclusions

In the proposed scheme, a content owner encrypts an image first using the Stream Cipher technique with an encryption key and embedding pixel-block numbers in each block-group by replacing LSBs of pixels in each pixel-block. The encrypted image with embedding pixel-block numbers is then sent to a data hider to embed secret message and create a marked image by a data hiding key and the codeword table index reordering technique. The marked image is sent to the receivers. When a receiver has the data hiding key, the secret message can be extracted. When a receiver has the encrypted key, the image can be reconstructed.

With our experiment results, we assured that the proposed scheme could achieve our goal of increasing embedding capacity by significant amount comparing to the SOTA schemes. Our experiments showed that the consistency of embedding capability with any cover image as long as the sizes of pixel-blocks and block groups were the same. As for PSNRs, the results showed the proposed scheme could outperform the SOTA schemes as well.