Week 5

Password implementation was completed.
See below the section of our image where we are currently hiding information regarding the password as well as additional information used in the decryption process.

This is the bottom right corner of our output image containing the hidden image. These few modified pixels are virtually unnoticeable with the naked eye, but some software specially designed to detect suh anomalies might pick it up.

We encountered several problems with passing data from GUI functions to other GUI functions or other matlab functions and so we decided to take the quick solution and not complicate the software further and risk damaging it and we decided to write sensitive information imputed in the GUI functions to a file; the file would be read by other functions immediately (for the purpose of either hiding the data in the image or confirm that the data is the same as the one found in the image) and then deleted.

Week 4

Graphical User Interface has been implemented. Below we present a preview of how it looks like.

Even though there still are some bugs and errors generate by unknown causes, we are managing to 'fix' them by closing certain parts of the program after the code execution and before it starts to do things that were not meant to happen like printing out on the matlab terminal the whole content of our matrix

Password implementation is the next milestone for our project.

Week 3

This is the design for the Graphical interface for the program.

This flowchart shows that the program can provide three functions for user to choose. Function 'hide text in image', function 'hide image in image', function 'decrypt the hidden image'. In this program, users can choose the function which they want. In the encode function, users can hide the information in the image and then set the password to ensure the data's security. In the decode function, people can get the hidden information if they input the correct password. But if the password is wrong, they can only get the original image which does not show the concealed data. Also in the program, users can close the window or go back to the last window at anytime they want.

Week 2

This is the first design flowchart that Zihao made for the program:

These are the first images our program has created after decoding the hidden text in an image:

 

                            (1)                                                            (2)

 

                             (3)                                                            (4)

At this point we were concerned with how the text should look like when it is revealed on the image as concealing it in the cover image was fairly easy to do by simply overwriting the last digit of the cover image's pixels with a 1 for white color, 0 for black color and later on we decided to add a value of 2 for red color.

Picture (1) shows the text revealed on the image and it has a white background so it would be visible, but it looked rather ugly.

Picture (2) shows the text revealed on the image without any background, but it can be hard to read when the text overlaps with a part of the picture that has the same color as the text.

Picture (3) shows the approach that we were most satisfied with. White text where each character has red pixels around it to make it visible when overlapping any color of the cover image, however we overlooked a small detail when we hid the pixels and as a result, during the decoding process some pixels were lost and the result is fairly visible.

Picture (4) shows the output after the bug was fixed. The problem was that while preparing the cover image's pixels to receive data ( matrix(r, c, :) =round ( matrix(r, c, :)/10 ) *10  ) by setting their last digits to 0, we were rounding towards nearest integer. So 255/10 = 25.5 which rounds up to 26, we multiply by 10 and we get 260 which is cut down to the maximum pixel size of 255. And when we add the text value (1, 0 or 2) this values are lost, and that's why certain parts of the text in image (3) are missing. This was fixed fairly easy by subtracting 6 out of all pixels in the matrix with a value grater than 250.

On the other hand, hiding images inside other images has presented us with new challenges. We had to take into account what to do with different image sizes ( cover image is smaller that the image that was supposed to be concealed),  how well can we hide the image, how much would the image degrade if we hide it in different ways.

                                    

                                     (1)                                                                      (2)

            

                                        (3)

                      

                                   (4)                                                                      (5)            

                          

                                            (6)

Image (1) was hidden inside image (2). Image (3) shows the output of our not optimized code where the hidden image was still visible on the cover image (even if this was not so obvious). Image(2) shows the output of our optimized code where the hidden image is no longer visible on the cover image but if you zoom in you would see certain markers but you couldn't figure out what they represent. Image (4) shows the number of pixels that had the last digit between 0 and 9 in the cover image and the resulting stego image; This is proof that the image has indeed been modified compared to the original one. Image (5) shows the hidden image revealed over the Cover image in its modified state and image (6) shows the restored hidden image to its original dimensions. There are certain differences between the original hidden image and the restored one as some data is lost due to the nature of the concealing process and the image re-size.

Week 1

 

This is the work schedule for the following weeks. Reply, comment or post individual progress weekly.

INTRODUCTION

Hi Everyone,

This project is about data hiding using image steganography. We have decided to use a computing environment called MATLAB, and the method we have agreed to use is LSB (Least Significant Bit) method.



Lets introduce the team working on this:

* Ouwen (Team Leader): In charge of coordinating the group members, decides which ideas are best to use in the project.

* Patrick (Implementer): He is in charge of the writing the code and producing the prototypes to see which is the best.

* Zihao (Designer) : He is in charge of designing how to code should work, the necessary flow charts of the code.

* Abba (Technical Writer) : He is in charge of taking minutes during meetings, in charge of compiling the report and the poster.