an algorithm of text in text steganography using ... - Wiley Online Library

SECURITY AND COMMUNICATION NETWORKS Security Comm. Networks 2016; 9:6004–6016 Published online 8 February 2017 in Wiley Online Library (wileyonlinelibrary.com). DOI: 10.1002/sec.1752

RESEARCH ARTICLE

AH4S: an algorithm of text in text steganography using the structure of omega network Abdullah M. Hamdan1 and Ala Hamarsheh2* 1 2

Computer Science—Faculty of Engineering and IT, Arab American University—Jenin, Palestine Computer Information Technology—Faculty of Engineering and IT, Arab American University—Jenin, Palestine

ABSTRACT This article introduces a new technique to hide text-in-text messages. The proposed mechanism uses the structure of omega network to hide and extract secret messages. The generation of secret message is made as follows, take every letter from the original message, use the omega network to generate two related letters from the selected letter, and finally search the dictionary for a suitable English cover word to hide the generated two letters. In order to increase the chance of find a suitable words, the generated two letters need not to be adjacent in the cover word. As a result, the white-space steganography is used in order to hide the position of the two letters in the selected cover word. The experiments show that the proposed mechanism gives a better execution time and better cover words than the current similar mechanisms especially when we are trying to hide long text messages. Copyright © 2017 John Wiley & Sons, Ltd. KEYWORDS original message; omega network; white-space steganography; text steganography; initial cover message; final cover message *Correspondence Ala Hamarsheh, Computer Information Technology—Faculty of Engineering and IT, Arab American University—Jenin, Palestine. E-mail: [email protected]

1. INTRODUCTION In the current usage of data, like civilization, education, and military, these data must be secure. One of data securing mechanisms is steganography; steganography is a mechanism of hiding the secret message in a non-secret cover media (message). It has many methodologies based on the nature of secret message and covering messages [1,2]. Because there are many shapes of data (e.g., text, sound, images, and videos), different steganography techniques have been proposed. The key point of steganography is in creating an observed cover message. This left to the outsiders or third parties an impression that is no secret message embedded in the message. Based on the secret message and cover message, there are many existing mechanisms do not consider the type and/or the format of the secret message as the secret message will finally be translated into binary format. 1.1. Hiding data in a video file This technique is mostly used for copy right. In this technique, embedding process focuses on modifying the 6004

quantization scale modulation, BCH coding, flipping no coefficients, or flipping at most one coefficient [1]. In this mechanism, to hide a text into video needs a lot of processing time and space (to convert into bit stream (macro block)); changing the values of each bit stream depends on the binary value of secret message to generate the matrix of bit stream (and converting the matrix into the final video). There is another risk on hiding the data using this technique, like extracting corrupted message after comprising the cover message and it leaves an impression to the outsider that there are modifications on this file (video)—depending on the rate of changing the value of each bit stream—and there is a secret message hidden in it. 1.2. Hiding data in image file This technique is used for copy right [2], by hiding an information (name or signature) about the owner inside the image. Additionally, there are many usages of image steganography more than copy right, like sending a secret message inside an image. Hiding the data in an image file raises many risks. On one hand, the bit quality will be changed (e.g., resolution or color). Additionally, there are many applications that can Copyright © 2017 John Wiley & Sons, Ltd.

A. M. Hamdan and A. Hamarsheh

be used to detect the existence of secret messages in a wellknows images by comparing the pixels of the original image with currently received image. On the other hand, the limitations on the binary string length, size, and number of pixels in the image, which each pixel hides one bit in it using one of the image steganography algorithms [2]. 1.3. Hiding data in audio file This technique is almost used for sound watermarking, for example hiding information about an author. Depending on the audio file and the hiding mechanisms, sound steganography has many types, which are LSB Coding, Parity Coding, Phase Coding, Spread Spectrum, and Echo Hiding [3]. All of the previous mechanisms have weaknesses, which are the noise on the cover media and the limitation on the secret message size [4]. 1.4. Hiding data in text

AH4S

From this Pseudo-code, the digit “1” is defined as two extra spaces inside the cover messages, and “0” digit is defined as one extra space. This method has many limitations. For example, the length of binary string must be less than or equal to the number of word spaces. 1.4.2. Random and statistical generation methods These methods automatically generate the cover text message; it does not need an existing cover message. The generated cover message uses the secret message in generation process. This algorithm uses this language structure and properties—i.e., how to create the sentences, what is the past format of a verb … etc. Also, these methods use grammar to produce suitable cover message. In this type of text steganography, an extra complexity is added (time and space) to generate a full paragraph; this consumes long time to embed and extract the secret message in/from the cover message.

Text steganography is a mechanism of hiding secret text message inside another text as a covering message or generating a cover message related with the original secret message [5]. There are three main categories used to hide text-in-text messages, that is, format based, random and statistical generations, and linguistic method [5–8].

1.4.3. Linguistic methods This method is used to hide a message in another message depending on the linguistic structure of the cover message (the punctuation marks) or the words semantic as a place to hide the message, which has two main types:

1.4.1. Format based In this method, the covering message will not be changed in case of its words and sentences; modifications will just be made on the spaces between the words, lines, or/and paragraphs using special characters, that is, whitespace steganography. In using this method, the number of added special character (i.e., white space) to the other spaces in the cover message depends on the value of the binary string digits. The following pseudo code shows how to hide the secret message into word spaces:

In order to hide a message, the cover message must have punctuation marks (i.e., comma, full stop …etc.) to hide the secret message in behind. These punctuation marks are the identification sign for the secret message. This technique has drawbacks, such as the data size depends on the number of the punctuation marks of the cover message.

Pseudo code of white-space steganography //start Read secret_message() Read Cover_message() BinStr = Convert secret message into binary string () I=0 position = 0 for I in Cover_message.length if Cover_message.at(I) is space and BinStr.at(position) is “1”: /// is there space at position I append three spaces to the cover_message in place of value of position(I); go to new position has value equal space; else if Cover_message.at(I) is space and binStr.at(position) is “0”: append two spaces to the cover_message in place of value of position(I); go to new position has value equal space; position + = 1; //End

• Linguistic structure:

• Semantic method: This type of steganography uses the synonyms of each word to hide the message; this method is done by searching for synonyms for each word in the secret message to generate the output cover message. This technique failed in protecting the sent message when the outsider tries to find the original message by swapping each word to the original one using the semantic algorithms. This article proposes a new methodology of hide textin-text message using the structure of Multi-stage Omega Network.

2. EMBEDDING AND EXTRACTING PROCESSES Obviously, any steganography mechanism has two main functions, embedding and extracting. The embedding process is used to hide data, whereas the extracting process is used to retrieve the hidden data. This section describes the embedding process of AH4S mechanism.

Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

6005

A. M. Hamdan and A. Hamarsheh

AH4S

2.1. Embedding process Basically, this process is responsible for embedding secret messages. The process uses the structure of omega network to embed secret messages. These messages may contain English letters (lower case letters) and special characters (full stop, comma, space, question mark, exclamation mark and apostrophe). The structure of omega network contains 32 different characters. The embedding process is organized as follows, read the secret message character by character, randomize positions at the end of two generated cover characters, create words from the generated cover characters, generate error detection code, and finally hide the generated key. These steps are summarized as follows (Figures 1–3). Step 1. Reading the secret message: The mechanism takes the secret message character by character and puts the character at the structure of omega network. Then, it performs left shifting and right shifting on the character position inside the stages of omega network. Hence, two covering characters will be generated. The embedding process starts with locating secret character in the middle stage inside the structure of omega network, then performing a left shifting and right shifting to

reach the second and fourth stages, and pass them to the first (input) stage and fifth (output) stage to create two corresponding cover characters. The secret message may contain characters not included in the omega network nodes which leads to pass it to the cover message (i.e., no cover character will be generated). Other characters will be scheduled for further processing. Step 2. Randomizing positions: The first and last stages of the omega network are used to generate cover characters. It allows a random selection of the characters in these stages (e.g., stage 5: a or b), which helps in increasing the possibility of generating different cover characters of the same secret character. Additionally, it avoids the selection of non-alphabetical characters in case where a stage has alphabetical and nonalphabetical characters. Figure 4 illustrates this process. Step 3. Seeking for a suitable word: The next step after generating the two cover characters is to seek the dictionary for a suitable word to hide the secret characters. It is worth noting that the mechanism selects the first word from the dictionary which contains the two generated characters regardless of the characters’

Figure 1. Mechanisms of steganography.

Figure 2. Categories of text-in-text steganography.

6006

Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

A. M. Hamdan and A. Hamarsheh

AH4S

Figure 3. The used structure of omega network.

Figure 4. Choosing a cover characters randomly.

position in the selected word. Therefore, the embedding process generates a special 12-digit key for each word to record some important information concerning the generated characters. The structure of the key is described as follows (Figures 5 and 6): • The first digit determines if the first cover character is the first or the second character inside the node of input stage or not—because of the randomization process. • The second determines if the second cover character is the first or the second character inside the node of output stage or not—because of the randomization process. • The third digit determines if the secret character is capital or small character. • The digits from the fourth to the seventh digit are used to memorize the position of the first cover character inside the cover word.

Figure 6. The structure of the node inside omega networks.

• The eighth to the eleventh digits are used to memorize the location of the second cover character inside the cover word. • The last digit determines if the secret character is at the end of secret word or not. For example, assume the secret message is “A”, and the cover word is “abaca”, the key is going to be “001000000011”:

Figure 5. The structure of the key. Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

• “0” means the first cover character is the first entity inside the input node. 6007

A. M. Hamdan and A. Hamarsheh

AH4S

• The second “0” means the second character also takes the first entity of the output node. • “1” means the original—secret—character is upper case, if “0” then lower case. • “0000” is the binary value of the position of the first cover character inside the cover word. • “0001” is the binary value of the second cover character inside the cover word. • “1” means it is the end of the string or the secret word, if “0” then it is not the end point.

choose the position of the alphabet; add “1” to Key_str if the second entity is chosen; else add “0”; if character in position of the integer value(second_ch_position) is alphabet and character in the next position of the integer value(second_ch_position) is alphabet: Then : choose one of them randomly;

Step 4. Hiding the key inside the cover message: Basically, white-space steganography is used to sublime the key string inside the cover message. The cover message must be duplicated also—because the number of spaces in the cover message is not enough—the output will be the final cover message. Figure 7 shows the output from this step. Step 5. Calculating error control: The embedding process also generates an error control value. This can be made by calculating the sum of digits of the key string for all characters; then, it adds the summation value to the cover message string. The following pseudo code will describe the embedding process formally: // Start Secret_Msg ← Read the secret message(); Key_str ← empty string; Error control ← 0; Cover string ← empty string; for i ← 0; i < length of Secret_Msg; i ← i +1 : first_ch_position ← right_ shifting(binary value(Secret_Msg position inside omega network)); second_ch_position ← left_shifting (binary value(Secret_Msg position inside omega network)); if character in position of the integer value(first_ch_position) is alphabet and character in the next position of the integer value(first_ch_position) is alphabet: Then :

add “1” to Key_str if the second entity is chosen; else add “0”; else if one of character in position of the integer value(second_ch_position)or character in the next position of the integer value(second_ch_position) is not alphabet: Then: choose the position of the alphabet; add “1” to Key_str if the second entity is chosen; else add “0”; if Secret_Msg[i] is upper case: Then: add “1” to Key_str; else: add “0” to Key_str; first_ch ← the character inside omega network at the integer value of (first_ch_position); Second_ch ← the character inside omega network at the integer value of (second_ch_position); Cover word ← Search for word contains first_ch and second_ch from dictionary(); Cover string ← Cover string + Cover word; add the binary value of the position of first_ch and second_ch inside the cover word to Key_str; if Secret_Msg[i] is at the end of cover word : Then: add “1” to Key_str;

choose one of them randomly; add “1” to Key_str if the second entity is chosen; else add “0”; else if one of character in position of the integer value(first_ch_position)or character in the next position of the integer value(first_ch_position) is not alphabet: Then:

6008

add space to Cover string; else: add “0” to Key_str; // end of cover words generation // calculate error control value; for k ← 0; k < length of Key_str; k ← k + 1: if Key_str[k] is “1”:

Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

A. M. Hamdan and A. Hamarsheh

AH4S

Figure 7. A final cover message after hiding the key. Then: Error control ← Error control +1 ; // make white space steganography on the cover string;

message. The extracting process is organized as the follow, key extracting from the cover message, key evaluating, extracting the cover characters from the cover message, and secret message generating: Step 1: Key extracting:this process is done by using the extracting algorithm of white-space steganography, to generate the hidden binary key string. As the following pseudo code:

White_space_steganography (Cover string, Key_str); // defined before Concatenate Error control value with the Cover string; // final cover message; //End

Figure 8 shows the final output of the cover message. The final output of the previous secret message (AAUJ) is: “aard aardvark abjection abricock aard aardvark abjection abricock aard aardvark abjection abricock aard aardvark abjection abricock aard aardvark abjection abricock aard aardvark abjection abricock aard aardvark abjection abricock aard aardvark abjection abricock aard aardvark abjection abricock aard aardvark abjection abricock aard aardvark abjection abricock aard aardvark abjection abricock 14”

2.2. Extracting process Extracting process is the methodology of recovering the secret message from the cover message. In this mechanism, omega network structure is also used to extract the secret

Pseudo code for key extracting // Start Read_the_cover_message() for I ← 0; I < covermsg.lenght I + =1 if covermsg[I] is space and covermsg[I + 1] is space THEN add 1 to the keyStr else if covermsg[I] is space and covermsg[I] is not space THEN add 0 to the keyStr return keyStr // End

Step 2. Key-error detection (key evaluating): The next step is to ensure the correctness of the key string, by calculating the summation key string digits; Then, compare the output with the error control value— which is already generated by the embedding process. If both are equal, the extracted key string is correct, otherwise, it is not. Figure 9 shows the case of error has been detected.

Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

Step 3. Extracting the cover characters: 6009

A. M. Hamdan and A. Hamarsheh

AH4S

Figure 8. The final cover message.

Figure 9. The error detection message.

6010

Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

A. M. Hamdan and A. Hamarsheh

AH4S

Step 5. If there are no more digits in the key string, then finish this process. The output is the secret message.

This step requires to deal with the key string and the cover message also, to extract the cover characters from the cover message, as the following: • Take the cover message word by word; also take 12 digits from the key string for each word. • Take the cover characters from each word in the cover message, based on the characters position which stored in the key string. • Locate “b” on the input stage, and “a” on the output stage of omega network. • The character position of “b” is “1”, and “a” is “0”, which means the binary value of “b” is “00001” and “a” is “00000”. • XOR (routing string) = 00001 XOR 00000 = 00001. Figure 10 shows how to move from the input stage to the meddle stage using the routing value. • The secret character is “a”. Step 4. Generate the secret character: This step requires the structure of omega network to generate the secret characters, as the following. 1. Locate the first character in the input stage of omega network. Also, locate the second character on the output stage of omega network. 2. Take the binary value of the position for each first character and second one. 3. Calculate XOR value from the binary values of the first and second characters. The output is called the routing value of the omega network. 4. Find the secret character by moving from the input stage to the second to the meddle stage using the generated routing string. The located character is a secret character. The following example explains how it is done.

Figure 11 shows the output of extracting process.

3. EXPERIMENTAL RESULTS This section compares AH4S and old technique Exploiting Omega Networks to hide Text-in-Text Messages [9], based on functionality, efficiency, and complexity. 3.1. Functionality EONS hides messages that contain alphabetical small characters only. If there is a non-alphabet character found in the message, the algorithm will concatenate it with the cover message and continue, without hiding it inside a cover word. On the other hand, the proposed mechanism will react in different way if a non-alphabet character found in the message by generating a full covering message. In order to hide messages, AH4S builds a 5 × 5 omega network. However, EONS builds a 5 × 5 omega network structure which contains English small letters and the most used non-alphabetical characters. It is worth noting that the original mechanism did not look up for a word that contains the characters under the specific standards of it—i.e., to make a cover word, search for word inside the dictionary that has first cover character in the first position and the second character at the second position of the cover word. Instead, it will generate a random string (i.e., the string contains five ransom characters in length) and then concatenate the cover characters to the generated string which makes the stego message look like an encrypted message. Unlike AH4S, the proposed

Figure 10. The flow to extract the secret character from the two-cover characters using the key. Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

6011

A. M. Hamdan and A. Hamarsheh

AH4S

Figure 11. Extracting secret message from a cover message.

Figure 12. Hiding a non-alphabetical character.

6012

Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

A. M. Hamdan and A. Hamarsheh

AH4S

Figure 13. Embedding the character ‘A’.

Figure 14. Different cover message while embedding the character A. Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

6013

A. M. Hamdan and A. Hamarsheh

AH4S

mechanism looks up for a word that contains the cover characters without looking for characters positions. 3.2. Efficiency This section compares between the AH4S and EONS algorithms with respect to attackers detection, attackers prevention, key generation, and error detection. 3.2.1. Attacker detection When attackers want to read a stego-message, it is not easy recognize it is a stego-message, because text-in-text steganography—almost—generates readable message for the humans, and it is not easy to detect the hidden message inside it, based on the mechanism itself. EONS generates words that only contain the cover characters without looking for the paragraph structure. Furthermore, in case there is no suitable cover word for the cover characters, it generates a random cover word, which lefts impression of the existence of a secret message. Whereas, the AH4S generates cover message word by word, it takes both of cover characters and search for word which contains them without looking for the characters positions inside it, that means the cover message for the same input

may give different results (different cover words for the same secret character). Also, this technique avoids the case of random-generated cover word for the same reason, which is not easy to detect the stego-message existence.

3.2.2. Attacker prevention There are many ways to make the data secure. For example, use secure media like fiber optics or make changes on the data itself. Those techniques provide confidentiality on the communication process. In case of changing the data, both pairs of communication (i.e., sender and receiver) must have an algorithm and key to return the original data to understand each other [10–12]. There are many techniques to make the data not understandable, the main two techniques are encryption and steganography. Both encryption and steganography are used in the same ways, like establishing secure communication over network and keeping the secret information hidden from the outsiders. Unlike encryption, steganography is better than encryption in case of awareness; there is secure information being transmitted via transmission media. Steganography provides a higher level of data hiding, because it generates almost-readable message while encryption does not, which lefts no impression that there

Figure 15. The run-time complexity of AH4S and compare it with ENOS run-time complexity of embedding process.

Figure 16. The run-time complexity of AH4S and compare it with ENOS run-time complexity of extracting process.

6014

Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

A. M. Hamdan and A. Hamarsheh

AH4S

Table I. Comparison—embedding and extracting time complexity, stego-key existence, output quality, error detection existence, and the cover message length between AH4S and EONS algorithms. Algo.\Comp AH4S EONS

Embedding time

Extracting time

O(m*n) O(n2)

O(n) O(m*n)

Stego-key

Output quality

Error detection

Output length

Exist N/A

Better Good

Exist N/A

Good Better

is no secret message (to the attackers) in case of using steganography. In order to increase the security in this mechanism and make the job of the attacker much harder, the order of the binary code of the secret characters could be changed dynamically and randomly in both final and first stages. This makes the embedding process follow different routes in the structure of the omega network. Also, the output of each character is two characters; both are used to select appropriate word to hide both characters in any possession. There is a key which is used to give the possession of characters used to select each word to extract the secret message, which makes it not easy to detect and extract the secret message to the attackers (Figures 12–14). 3.3. Time complexity This section provides a run-time complexity comparative study between ENOS and AH4S, using machine with: • CPU: Intel core i5 vpro 3rd generation • Memory: 8 GB DDR3. • OS: Kali Linux 2.0. • Embedding process contains two main processes; generating the cover message and key hiding. • Generate the cover message time complexity = ∑ (n*m). • Key hiding time complexity = ∑ (12*n)—because the number of digits for each secret character = 12.

Table I summarizes the comparative case between the prosed mechanism and EONS.

4. CONCLUSIONS AND FUTURE WORK This article proposed a new mechanism to hide text message inside a text cover message. The old version of the mechanism has many limitations like the secret characters positions inside the cover word. Nevertheless, this mechanism has the ability to generate stego-covers based on secret messages, without looking for a specific position in the cover words that generates the cover message. The mechanism offers different probabilities for embedding process which gives better security and increases the difficulty of detecting secret messages by attackers and also detects the corruption or modifications on the cover message. The main drawback of the mechanism is the length of the cover message, because of the need of hiding the secret key inside the generated cover message. Additionally, the frequent use of the dictionary files to embed each character deteriorates the overall system performance. However, the future work might go towards finding solutions to the secret message drawbacks. Additionally, structuring and sending meaningful sentences using the generated words instead of sending separate words will be an interesting topic for the future work.

REFERENCES Then, the total time complexity = ∑ (n*m) + ∑ (12*n) ≈ O (n*m). Figure 15 shows comparison of the exact time complexity of embedding process between this algorithm and the old one ENOS (Exploiting Omega network to hide text in text). • Extracting process also contains two main processes: extract the key string and generate the secret message. • Extract the key string time complexity = ∑ (12*n). • Generate the secret message time complexity = ∑ (n). Then, the total time complexity = ∑ (12*n) + ∑ (n) ≈ O (n). Figure 16 shows comparison of the exact time complexity of extracting process between this algorithm and the old one ENOS. Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec

1. Hegde R. “A review: data transmission techniques over the network by using steganography”, SDM Institute of Technology, Ujire, P 2–4. 2. Faris AJ. “A novel steganography algorithm for hiding text in image using five modulus method”, Faculty of Administrative Sciences-Irbid National University, Jordan, 17, jun, 2013, P 39 – 42. 3. Jayaram P, Ranganatha HR, Anupama HS. “Information hiding using audio steganography—a survey. ” Department of Computer Science and Engineering, R V College of Engineering, Bangalore, India, 3, August 2011. 4. Kekre HB. “Information hiding in audio signals. “ MPSTME, SVKM’s NMIMS, Mumbai, October 2010. 5. Prasad RSR. “A new approach to Telugu text steganography” Acharya Nagarjuna University, Nagarjuna Nagar, Guntur, Andhra Pradesh, INDIA, September, 2011. 6015

A. M. Hamdan and A. Hamarsheh

AH4S

6. Govada SR. “Text steganography with multi level shielding” Dept. of Computer Science and Engineering KIET, Kakinada, INDIA, July, 2012. 7. Por LY, Ang TF, Delina B. “WhiteSteg: a new scheme in information hiding using text steganography” Faculty of Computer Science and Information Technology, University of Malaya, 50603, Kuala Lumpur, Malaysia, June, 2008. 8. Bennett K. “Linguistic steganography: survey, analysis, and robustness concerns for hiding information in text.” Center for Education and Research in Information Assurance and Security, Purdue University, West Lafayette, 2004.

6016

9. Hamarsheh H. “Exploiting omega networks to hide text-in-text messages” In: International Journal of computer and network security; 2015. 10. Stallings W. “Cryptography and network security principles and practice.” Pearson; 2011. p. 9 11. Furdek M, Skorin-Kapov N, Bosiljevac M, Sipus Z. “Analysis of crosstalk in optical couplers and associated vulnerabilities.” Proc. 33rd Int Convention (MIPRO) 2010:461–6 12. Shaneman K, Gray S. Optical network security: technical analysis of fiber tapping mechanisms and methods for detection & prevention. In: Proc. IEEE Military Communications Conf. (MOLCOM); 2004. 711–6

Security Comm. Networks 2016; 9:6004–6016 © 2017 John Wiley & Sons, Ltd. DOI: 10.1002/sec