Abstract: Embedded devices have taken a prominent role in today’s data communication. Steganography, an ancient method has immense budding to shield electronic data from threats in the modern world. The focus on this study is to make use of Hilbert Space Filling Curve (SFC) to implement random steganography on a single chip embedded device that embeds textual information on grey scale images. The written embedded C program was optimized for in terms of code size and execution time and the results are compared. The results of the proposed method are also compared with a similar methodology hosted on an equivalent embedded device. The main aim of this implementation is to make use of the specialized bit operation capabilities of ARM processor to improve the security level of the embedding algorithm by introducing bit level arbitrariness in the selection of data to be embedded.
INTRODUCTION
Information security has been in the foreground ever since the parturition of communication. Steganography, an antique method in the modern era shelters the electronic data during its journey between the targets (Amirtharajan et al., 2012; Amirtharajan and Rayappan, 2013; Cheddad et al., 2010). Hiding of information by itself requires great skill. Greater is the skill needed to protect it from the eagle eyes of eavesdroppers. People who master the art of steganography have found numerous ways (Amirtharajan et al., 2013c, g; Wu and Tsai, 2003; Luo et al., 2011; Mohammad et al., 2011; Thanikaiselvan et al., 2012a-c, 2013a, b; Thien and Lin, 2003) to cleverly elude these listeners and continue to protect their information. This technique is broadly classified in domains such as spatial, transform (Amirtharajan and Rayappan, 2012c; Praveenkumar et al., 2012a, 2014a-i; Qi and Wong, 2005; Wong et al., 2007; Zhang and Wang, 2004) and spread spectrum (Praveenkumar et al., 2012b, 2013a, b, 2014j; Thenmozhi et al., 2012).
Change in LSB position on any data does not produce perceivable changes to the original information. This fact is made use of in LSB steganography, where, the LSB is replaced with the bit(s) of a secret message (Janakiraman et al., 2014a). Various random embedding methods have been proposed by several steganography experts till now (Amirtharajan and Rayappan, 2012a; Amirtharajan and Rayappan, 2013, Amirtharajan et al., 2013a, b, d, f, h, i, j). The degree of randomization can be thought of to be directly proportional to the level of security a system provides. Variable data size embedding techniques such as pixel indicator raises the security level at the cost of low payload compared to its equivalent fixed embedding techniques with greater K value (Amirtharajan et al., 2013e; Janakiraman et al., 2012a).
Space Filling Curves (SFC) often plays a role in block based algorithms for the purpose of random traversal (Rajagopalan and Upadhyay, 2011, Rajagopalan et al., 2014a, d) within the cover block (Amirtharajan and Rayappan, 2012d; Zhao and Luo, 2012). These algorithms concentrate only on the way to randomize the place of embedding and still leave the procedure for aligning the extracted data to be chronological. The use of programmable hardware such as, microcontrollers, embedded processors and reconfigurable systems to gain data security through cryptography have been in practice for a long time (Salem et al., 2011; Janakiraman et al., 2012b, 2014b; Rajagopalan et al., 2012a, b). The steganographic hardware systems started gaining its place in the world of data security in recent days through FPGAs (Janakiraman et al., 2013; Ramalingam et al., 2014a, b; Rajagopalan et al., 2014b, c) and embedded devices (Stanescu et al., 2009).
The implementation of image steganography on embedded devices such as microcontrollers with ARM7 architecture is obtainable in the literature. The use RGB images as cover, demands interfacing of external memory devices like SRAM for storage of image data. Random image steganography algorithm using grey scale cover images on suitable embedded devices with sufficient on-chip RAM, makes it possible to eliminate the need of external memory (Rajagopalan et al., 2012b).
As the Einstein’s words go, “Make things as simple as possible but not simpler”. This study organised as follows, after knowing the existing literature, this study provides a simple yet an ingenious way to hide information. The next section of this study intend to make use of Hilbert Space Filling Curve (SFC) to present a three way randomization approach on data embedding sequence to advance the algorithm intricacy and data protection. The algorithm was implemented and tested on LPC2148 microcontroller with ARM7 core to attain the results. The performance metrics of the proposed algorithm on selected hardware with respect to code size and execution time are compared with implementation results of quad block algorithm (Rajagopalan et al., 2012b).
PROPOSED METHODOLOGY
This LSB algorithm (Chan and Cheng, 2004) employs an 8x8 Hilbert curve (Amirtharajan and Rayappan, 2012b, d) as shown in Fig. 1 available in the form of Look-up Table (LUT) accessible from on-chip code memory to facilitate randomness in image steganography. The size of the cover image can be any number of 8x8 blocks with 8-bit grey pixels. In every 8x8 cover block, the 8x8 Hilbert curve dictates the order of pixel selection for data embedding. On considering one bit embedding, the number of secret bytes for full embedding will be 1/8 of the number of cover pixels. This makes the number of secret bytes for every block as 8, when K = 1. At every embedding point within the block, the random number obtained from LUT is divided by 8.
| Fig. 1: | Hilbert space filling curve (8x8) |
The Quotient (Q) and Reminder (R) results in a single digit octal value (0-7). This selects the byte and bit positions, respectively in the secret data block corresponding to the cover block.
The embedding procedure given for a single 8x8 block may be continued for any image size with multiple 8x8 blocks. For multi bit embedding with K>1, the number of secret bytes corresponding to each cover block is given by Kx8. On multi bit embedding, the byte and bit position of the secret data byte is given by Q+(ix8) and, R, respectively, where, ‘i’ is referred to as the bit position of the cover pixel in which the secret data bit gets embedded. In the case of embedding, the Hilbert LUT is used to identify the cover pixel and secret data bit to be embedded. During the process of retrieval the Hilbert LUT is used to align the extracted secret data bit of every stego pixel in apposite position so as to get back the original unseen information.
| Pseudo code for embedding (K = 1): | |
| Fig. 2: | Basic block diagram of stego implementation on LPC2148 |
| Pseudo code for Retrieval (K = 1): | |
The existing on-chip data memory of 32 kB is highly sufficient to accommodate the maximum requirement of on-chip SRAM which comes to a value of less than 9 kB. This includes the space to store cover and stego images of 4 kB each in addition to 1536 bytes of secret textual information with maximum embedded bits per pixel (K = 3). Figure 2 shows the basic block diagram of the embedded device (LPC2148) with program and data memory contents used for embedding algorithm.
RESULTS AND DISCUSSION
The grey scale image of size 64x64 is used as cover. A string of english characters (text) is embedded in each cover pixel selected in the order dictated by the Hilbert curve. The tool chain from KEIL MDK μvision4 was used to obtain the implementation results. The code was written using embedded C language and compiled for Philips LPC 2148 microcontroller using ARMCC compiler. The compiler options have been enabled to optimize the code for execution time (Speed) and code size (flash memory occupancy).
| Fig. 3: | Code size for embedding algorithm |
| Fig. 4: | Execution time for embedding algorithm |
The use of Micro Library (MicroLIB) significantly reduces the code size whereas, the use of same is not suggested for applications that demands speed as its crucial end.
The proposed embedding algorithm when optimized for code size as given by Fig. 3 results in the reduction of memory footprint around 30% in comparison with its counterpart, the time optimization. The graph results also show that for embedding with K>1, every rise in the value of ‘K’ makes only a paltry contribution towards the rise of code size. The execution time for the code and time optimized version of proposed embedding algorithm always grows radically with rise in bits embedded per pixel as given in Fig. 4.
The algorithm described in this study (Rajagopalan et al., 2012b) has been implemented again on the same hardware LPC2148 with which the proposed algorithm has been implemented. The execution time and clock cycles are analyzed with the KEIL MDK at 60 MHz the maximum operating frequency of LPC2148. The graph on Fig. 5 and 6 depicts the comparison results with two variants of optimization on code size and execution time respectively obtained in the proposed method with respect to the one obtained in this study.
The Fig. 7a and 8a shows the 64x64 cover images taken and Fig. 7b-c, 8b-c gives the stego images with K = 1 and 2, respectively. The quality of the stego image is analyzed for imperceptibility in terms of two error metrics namely Mean Square Error (MSE) and Peak Signal to Noise Ratio (PSNR) are tabulated in the Table 1 for full embedded capacity as given by the following equations:
| Fig. 5: | Code size comparison |
| Fig. 6: | Speed comparison |
| Fig. 7(a-c): | Peppers, (a) Cover image, (b) Stego image (K = 1) and (c) Stego image (K = 2) |
| Fig. 8(a-c): | Cameraman, (a) Cover image, (b) Stego image (K = 1) and (c) Stego image (K = 2) |
| Table 1: | Error metrics |
SX,Y: |
Stego pixel value |
| CX,Y: | Cover pixel value |
| C2max: | Maximum intensity value of the pixel (255 for gray scale image) |
CONCLUSION
The use of Hilbert LUT provides a tri coat technique for the selection of arbitrary cover pixel, plus bit and byte positions of the data to be embedded. The proposed technique consumes only less than 0.2% of 512 kB code space accessible on the selected embedded device. It offers a great benefit in applications where the code size is decisive, making the algorithm suitable as well for tiny embedded devices such as microcontrollers. Here, a random choice on the selection of cover pixel for embedding was done with the help of LUT in code memory in addition, the selection on secret data byte were also done in a random fashion to improve the security level with a negligible amount of trade-of f in execution cycles. Therefore, further enhancements may be considered by building multiple LUTs on flash memory making ample choices to raise the unpredictability and security.