Implemented Audio steganography (avinashkranjan#991)

Author: Trisanu-007

Audio_Steganography/Algos/Decrypt.py

@@ -0,0 +1,95 @@
+import os
+import wave
+import simpleaudio as sa
+import numpy as np
+from scipy.io import wavfile
+import binascii
+
+"""
+
+ [NOTE] In this decryption algorithm we simply read the path of the audio from the user and we 
+ get a numpy array from the same. We then read the LSB of the binary representation of the data and get a string 
+ of binary data. Finally we convert this string to ascii charecters and write it to a file.
+
+"""
+
+
+class Decrypt:
+
+    def __init__(self, audio_path):
+        self.audio_path = audio_path
+        self.audio_wave_obj = wave.open(audio_path)
+
+    """ 
+      This function is there for playing audio.
+    """
+
+    def play_audio(self) -> None:
+
+        playing = sa.WaveObject.from_wave_read(self.audio_wave_obj)
+        obj = playing.play()
+
+        if obj.is_playing():
+            print(f"Playing audio")
+
+        obj.wait_done()
+
+    """
+      The decryption is done here.
+    """
+
+    def decrypt_audio(self, output_dir: str, file_name: str, gen_file_status: bool) -> (str, bool):
+        if gen_file_status:
+            curr_dir_path = os.getcwd()
+            output_dir_path = os.path.join(curr_dir_path, output_dir)
+
+            try:
+                os.mkdir(output_dir_path)
+            except:
+                pass
+
+        print(f"This might take some while if your secret message is big and might contain some rubbish data.")
+
+        # Reading the data from the wav file
+        samplerate, data = wavfile.read(self.audio_path)
+        m, n = data.shape
+        # Reshaping it to make the data easier to handle
+        data_reshaped = data.reshape(m*n, 1)
+
+        s = ""
+        zeros = 0
+
+        # Getting the LSB from each number
+        for i in range(m*n):
+            t = str(data_reshaped[i][0] & 1)
+            if zeros < 9:
+                s += t
+            else:
+                break
+            if t == '0':
+                zeros += 1
+            if t == '1':
+                zeros = 0
+
+        # Making sure the bit-string is of length divisible by 8 as we have stored the input-secret as 8-bits only
+        s = s[:((len(s)//8)*8)]
+
+        # Converting bbinary string to utf-8
+        in_bin = int(s, 2)
+        byte_num = in_bin.bit_length() + 7 // 8
+        bin_arr = in_bin.to_bytes(byte_num, "big")
+        result = bin_arr.decode("utf-8", "ignore")
+
+        # Writing to output file if status was given true
+        if gen_file_status:
+            try:
+                with open(os.path.join(output_dir_path, file_name), "w", encoding="utf-8") as f:
+                    f.write(result)
+                print("Success !!!")
+                return result, True
+            except:
+                print(("Error !!!"))
+                pass
+                return None, False
+        else:
+            return result, True

Audio_Steganography/Algos/Encrypt.py

@@ -0,0 +1,120 @@
+import os
+import wave
+import simpleaudio as sa
+import numpy as np
+from scipy.io import wavfile
+
+
+"""
+  [NOTE] In this algorithm we make use of LSB Steganographic method of encoding. In this algorithm we have converted each charecter
+  of the secret text into 8-bit binary string and then we have stored it to a numpy array of size x*8 where x = no. of charecters.
+  After that we have copied the same into the LSB of the binary form of the audio file we have read.
+"""
+
+
+class Encrypt:
+
+    def __init__(self, message_audio_file_path: str, secret_message: str):
+        self.message_audio_file_path = message_audio_file_path
+        self.secret_message = secret_message
+
+        # For getting name of the file
+        self.message_filename = message_audio_file_path.split(os.sep)[-1]
+
+        # Reading the .wav audio file as a Wave obj - to be used later
+        self.message_audio = wave.open(message_audio_file_path)
+
+        # Getting the numpy array from the secret string.
+        self.secret_as_nparr = self.get_bin_npapp_from_path(
+            secret_message)
+
+        self.mess_as_nparr = None
+
+    """
+      This function is used as a helper function
+    """
+
+    def get_bin_npapp_from_path(self, secret: str) -> np.ndarray:
+
+        strings = ' '.join('{0:08b}'.format(ord(word), 'b')
+                           for word in secret)
+        lst = []
+        for word in strings.split(" "):
+            # arr = np.fromstring(word, dtype="u1")-ord('0')
+            temp_lst = [int(i) for i in word]
+            lst.append(np.array(temp_lst))
+
+        return np.array(lst)
+
+    """
+      This function is there for playing audio.
+    """
+
+    def play_audio(self) -> None:
+
+        playing = sa.WaveObject.from_wave_read(self.message_audio)
+        obj = playing.play()
+
+        if obj.is_playing():
+            print(f"Playing audio : {self.message_filename}")
+
+        obj.wait_done()
+
+    """
+      This function is for encryption
+    """
+
+    def encrypt_using_lsb(self, output_dir: str, file_name: str) -> (np.ndarray, bool):
+
+        # Getting the ouput path
+        curr_dir_path = os.getcwd()
+        output_dir_path = os.path.join(curr_dir_path, output_dir)
+
+        try:
+            os.mkdir(output_dir_path)
+        except:
+            pass
+
+        print(f"This might take some while if either your audio file or your secret message is big")
+
+        # Reading shape of secret message and reshaping
+        m1, n1 = self.secret_as_nparr.shape
+        secret_reshape = self.secret_as_nparr.reshape(m1*n1, 1)
+
+        # Reading the .wav file
+        samplerate, self.mess_as_nparr = wavfile.read(
+            self.message_audio_file_path)
+
+        # Reading the shape of .wav file and reshaping
+        m2, n2 = self.mess_as_nparr.shape
+        message_reshape = self.mess_as_nparr.reshape(m2*n2, 1)
+
+        # Edge case
+        if m1*n1 > m2*n2:
+            print("Coudn't be done")
+            quit()
+
+        # Encryption part
+        k = 0
+        for i in range(m2*n2):
+            if k < m1*n1:
+                # This line is for copying the bit off the secret message to the LSB of the audio
+                message_reshape[i][0] = message_reshape[i][0] & 0xFE | secret_reshape[k][0]
+                k += 1
+            else:
+                message_reshape[i][0] = 0
+                break
+
+        # Reshaping back again
+        message_reshape = message_reshape.reshape(m2, n2)
+
+        try:
+            # Writing into ouput file
+            p = wavfile.write(os.path.join(output_dir_path, file_name),
+                              samplerate, message_reshape.astype(message_reshape.dtype))
+            print("Success !!!")
+            return message_reshape, True
+        except:
+            print("Error !!!")
+            pass
+            return None, False

Audio_Steganography/Algos/__init__.py

@@ -0,0 +1,27 @@
+# Audio Steganography
+This is a package to encrypt a given message into a .wav audio file. It can decrypt from audio as well.
+- Encrypt : This is used for the encryption part. Can play the audio as well.
+- Decrypt : This is used for decryption part. Can play audio as well.
+
+## Setup instructions
+- It is recommended to install a virtualenv before you proceed. This can be done by ```virtualenv {name_of_virtualenv}```
+- Do 
+    ```python3
+    pip install -r requirements.txt
+    ```
+- You can import Encrypt from Algos.Encrypt and decrypt from Algos.Decrpyt
+- The TestingCode.py file has an example implementation. Please refer to it if you face any issue.
+
+## Output
+- The code in TestingCode.py will produce 2 Directories as well as produce sound that is inside the .wav files that you have passed as a parameter to ```Encrypt```. 
+- The Encryption and Decryption parts each will produce a directory with a name of your choice as well as file inside it containing the encrypted audio file or decrypted text file .
+- An Example of what you might expect :
+  - Before
+    ![Before](Images/Before.jpg)
+  - After 
+    ![After](Images/After.jpg)
+
+- Dont worry if your decrypted sentence looks a bit funky-it is to be expected.
+
+## Author(s)
+[Trisanu Bhar](https://github.com/Trisanu-007)

Audio_Steganography/Images/After.jpg

@@ -0,0 +1,26 @@
+from Algos.Encrypt import Encrypt
+from Algos.Decrypt import Decrypt
+
+"""
+   [NOTE] Here we demostrate an use of the Encrypt and Decrypt algorithms 
+   We also play the audio file as well.
+"""
+# You can try with Forest.wav as well
+message_path = input("Enter path of Audio file: ")
+secret = input("Enter secret message: ")
+
+# Using Encrypt
+en = Encrypt(message_path, secret)
+en.play_audio()
+res, status = en.encrypt_using_lsb("Encrypted", "encrypted.wav")
+
+if status:
+    print(res)
+
+# Using Decrypt
+dec = Decrypt("Encrypted\encrypted.wav")
+dec.play_audio()
+res, status = dec.decrypt_audio("Decrypted", "decrypted.txt", False)
+
+if status:
+    print(res)