diff --git a/encoded_image.png b/Image_Steg/encoded_image.png similarity index 93% rename from encoded_image.png rename to Image_Steg/encoded_image.png index 112f045..3bea4cf 100644 Binary files a/encoded_image.png and b/Image_Steg/encoded_image.png differ diff --git a/image.png b/Image_Steg/image.png similarity index 100% rename from image.png rename to Image_Steg/image.png diff --git a/img_steg.py b/Image_Steg/img_steg.py similarity index 100% rename from img_steg.py rename to Image_Steg/img_steg.py diff --git a/Txt_Steg/test.txt b/Txt_Steg/test.txt new file mode 100644 index 0000000..a4dabcd --- /dev/null +++ b/Txt_Steg/test.txt @@ -0,0 +1,25 @@ +Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam non ultricies mauris. Aliquam tristi +que dolor ac imperdiet iaculis. Nunc et est nec sapien dapibus sagittis. Suspendisse auctor facilisi +s felis, at lobortis tortor tristique in. Vestibulum consequat lobortis sem, ut efficitur nulla tinc +idunt id. Curabitur nec nisi ac tellus consequat euismod. Sed pulvinar dapibus leo, et convallis ero +s pharetra eu. Mauris eget malesuada neque, non congue ligula. Sed cursus vestibulum massa ac interd +um. Cras in aliquam dui. Morbi maximus metus et est cursus lacinia. Sed in malesuada mauris. Nulla f +acilisi. Nam auctor dolor sit amet turpis aliquam, non lacinia lacus hendrerit. Phasellus in turpis +at risus hendrerit consectetur vel eu ipsum. Sed gravida risus ut tellus iaculis, non rhoncus lorem +vulputate. In tincidunt arcu risus, eu lacinia metus viverra in. Maecenas id ipsum tortor. Nunc vita +e mauris vel turpis lobortis tincidunt sed sit amet purus. Aliquam sed pharetra neque. Sed eget nisi +id metus aliquam dapibus et nec felis. Cras quis ante rutrum, bibendum lacus ut, malesuada justo. Al +iquam consequat mi id turpis cursus bibendum. Ut varius faucibus lorem a egestas. Maecenas commodo l +uctus nunc non euismod. Vestibulum sed dapibus purus. Pellentesque habitant morbi tristique senectus +et netus et malesuada fames ac turpis egestas. Integer tincidunt viverra pharetra. Nam in risus eu l +acus tincidunt laoreet a eu nibh. Donec fringilla iaculis mi. Mauris varius odio id erat interdum, s +ed semper odio ultrices. Aliquam cursus ullamcorper lacus id posuere. Vivamus feugiat arcu ut nulla +elementum vestibulum. Proin interdum enim sed ante venenatis, eget feugiat nisi dapibus. Mauris a vu +lputate arcu, at facilisis quam. Proin ullamcorper velit et enim varius, nec dapibus tortor mollis. +Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Donec eget p +urus tristique, malesuada sem nec, sagittis lectus. Integer sed elit vel ex fringilla accumsan. Nam +sit amet metus ac lacus finibus malesuada id id nisi. Sed condimentum, felis ut faucibus euismod, to +rtor metus hendrerit metus, ut rhoncus metus enim eu velit. Sed blandit consequat est, sit amet rutr +um enim feugiat at. Mauris faucibus blandit diam. Curabitur venenatis efficitur mi, ac tristique nul +la hendrerit a. Nulla facilisi. Nullam sit amet lectus vitae metus venenatis rhoncus. Nunc condiment +um metus at ipsum tincidunt, ac semper orci viverra. Nunc feugiat efficitur ex, sit amet p diff --git a/Txt_Steg/txt_steg.py b/Txt_Steg/txt_steg.py new file mode 100644 index 0000000..0e34cda --- /dev/null +++ b/Txt_Steg/txt_steg.py @@ -0,0 +1,150 @@ +import numpy as np + + +class txt_steg: + def __init__(self, text_file: str = "text.txt", bit_to_hide: int = 2): + """ + Initialize the class + :param text_file: PathName of the text file to encode or decode + :type text_file: str + :param bit_to_hide: Bit to hide the data in (1 - LSB to 8 - MSB) + :type bit_to_hide: int + """ + self.text_file = text_file + self.bit_to_hide = 8 - bit_to_hide + self.delimiter = "abc12345" + + def to_bin(self, data: str) -> str | list[str]: + """ + Convert text file data to binary format as string + :param data: String + :type data: str + :return: Binary Data: String | List[String] + """ + if isinstance(data, str): + return ''.join([format(ord(i), "08b") for i in data]) + elif isinstance(data, bytes) or isinstance(data, np.ndarray): + return [format(i, "08b") for i in data] + elif isinstance(data, int) or isinstance(data, np.unit8): + return format(data, "08b") + else: + raise TypeError("Type not supported") + + def from_bin(self, data: str) -> str: + """ + Convert binary `data` back to the original format + :param data: String + :type data: str + :return: Original Data: String + """ + binary_data = ''.join([c for c in data if c in ('0', '1')]) # Remove non-binary characters + + # Split the binary data into chunks of 8 bits + binary_parts = [binary_data[i:i + 8] for i in range(0, len(binary_data), 8)] + + # Convert each chunk to its corresponding ASCII character + decoded_data = ''.join([chr(int(part, 2)) for part in binary_parts]) + + return decoded_data + + def encode(self, secret_data: str = "Hello World"): + """ + Encode the secret data into the text file + :param secret_data: String + :type secret_data: str + """ + print("[+] Encoding...") + # Read text file and covert to binary + if self.text_file != "": + with open(self.text_file, "r") as f: + data = f.read() + f.close() + data = self.to_bin(data) + else: + raise FileNotFoundError("File not found") + + bits_to_hide = self.bit_to_hide + + secret_data += self.delimiter # Add delimiter + binary_secret_data = self.to_bin(secret_data) + data_len = len(data) + + # Check if secret data can be encoded into text file + if len(binary_secret_data) > data_len: + raise ValueError(f"[-] Error: Binary Secret data length {len(binary_secret_data)} " + f"is greater than data length {data_len}") + + encoded_data = "" + + # For every 8 bits in the data, hide 1 bit of secret data in the bit_to_hide position + data_index = 0 + for i in range(0, data_len, 8): + data_byte = data[i:i + 8] + if data_index < len(binary_secret_data): + secret_bit = binary_secret_data[data_index] + modified_byte = data_byte[:bits_to_hide] + secret_bit + data_byte[bits_to_hide + 1:] + encoded_data += modified_byte + data_index += 1 + else: + encoded_data += data_byte + + encoded_data = self.from_bin(encoded_data) + + return encoded_data + + def decode(self) -> str: + """ + Decode the encoded data from the text file + :return: Decoded Data: String + """ + print("[+] Decoding...") + # Read text file and covert to binary + if self.text_file != "": + with open(self.text_file, "r") as f: + data = f.read() + f.close() + data = self.to_bin(data) + else: + raise FileNotFoundError("File not found") + + # Split the data into bytes + bytes_data = [data[i:i + 8] for i in range(0, len(data), 8)] + + # Extract the bits at the bit_to_hide position + secret_data = [byte[self.bit_to_hide] for byte in bytes_data] + + # Concatenate the bits into a binary string + binary_data = ''.join(secret_data) + + # Split the binary data using the delimiter + delimeter_as_bin = self.to_bin(self.delimiter) + binary_data = binary_data.split(delimeter_as_bin)[0] + + # Convert the binary data back to the original text + decoded_data = self.from_bin(binary_data) + + return decoded_data + + +def main(): + print("Welcome to Text Steganography") + print("1. Encode\n2. Decode\n3. Exit") + choice = int(input("Enter your choice: ")) + if choice == 1: + text_file_name = input("Enter name of text file to encode: ") + secret_data = input("Enter data to encode: ") + bit_to_hide = int(input("Enter bit to hide (1 - LSB to 8 - MSB): ")) + encoded_data = txt_steg(text_file_name, bit_to_hide).encode(secret_data) + extension = text_file_name.split(".")[-1] + with open(f"encoded_text.{extension}", "w") as f: + f.write(encoded_data) + print("Encoded Data:", encoded_data) + elif choice == 2: + text_file_name = input("Enter name of text file to decode: ") + bit_to_hide = int(input("Enter bit to hide (1 - LSB to 8 - MSB): ")) + decoded_data = txt_steg(text_file_name, bit_to_hide).decode() + print("Decoded Data:", decoded_data) + + +if __name__ == "__main__": + main()