Exemplo n.º 1
0
        public void ShouldCalculateDifferencesOnLsb(int payloadSize, string filename)
        {
            payloadSize = payloadSize / 8;
            var          inputMessage           = GeneratePayload(payloadSize);
            Bitmap       cleanImage             = new Bitmap(filename);
            LSBHeader    header                 = new LSBHeader(MessageType.Plaintext, inputMessage.Length);
            string       inputMeesageInBits     = MessageConverter.Instance.TextToBit(inputMessage);
            InputMessage inputMessageWithHeader = new InputMessage(inputMeesageInBits, header);

            Console.WriteLine("Message size is in bits is {0}", inputMeesageInBits.Length);
            Console.WriteLine("Message with header size is {0}", inputMeesageInBits.Length + LSBHeaderConstants.PlainTextHeaderLength);

            var capacity = cleanImage.Width * cleanImage.Height * 3;

            Console.WriteLine("Image capacity  is {0}", capacity);

            Bitmap        encryptedImage     = LSB.Instance.Encode(cleanImage, inputMessageWithHeader);
            OutputMessage imageMessageInBits = LSB.Instance.Decode(encryptedImage);
            string        imageMessage       = AlgorithmUtility.bitMessageToText(imageMessageInBits.GetContent(), (int)LSBHeaderConstants.PlainTextHeaderLength);

            Assert.AreEqual(imageMessage, inputMessage);

            double mse = MSE.Instance.CalculateDifference(cleanImage, encryptedImage);

            Console.WriteLine("MSE is {0}", mse);

            double psnr = PSNR.Instance.CalculateDifference(mse);

            Console.WriteLine("PSNR is {0}", psnr);

            double imageSimilarity;

            ImageDifference.Instance.CalculateDifference(cleanImage, encryptedImage, out imageSimilarity);
            Console.WriteLine("Image Similiarity is {0}", imageSimilarity);
        }
Exemplo n.º 2
0
        public void LSBTest()
        {
            string filename1 = "C:\\Users\\mokry\\Desktop\\Uroboros_Files\\Grayscale_images\\cleaned.png";


            Bitmap       inputImage             = new Bitmap(filename1);
            string       message                = "myMessage";
            LSBHeader    header                 = new LSBHeader(MessageType.Plaintext, message.Length);
            InputMessage inputMessageWithHeader = new InputMessage(message, header);
            Bitmap       outputImage            = LSB.Instance.Encode(inputImage, inputMessageWithHeader);

            double error = MSE.Instance.CalculateDifference(inputImage, outputImage);

            Console.WriteLine("Error is {0}", error);

            Assert.AreNotEqual(0, error);
        }
Exemplo n.º 3
0
        // placeholder function
        private void encrypt_Click(object sender, RoutedEventArgs e)
        {
            // TO DO add checks for nulls

            // if message is image
            string      message       = null;
            MessageType messageType   = MessageType.Plaintext;
            Bitmap      imageToEncode = null;

            if (Equals(messageTabControl.SelectedItem, textItem))
            {
                TextViewer tab = messageTabControl.SelectedContent as TextViewer;
                message = tab.textBox.Text;
            }
            else if (Equals(messageTabControl.SelectedItem, binaryImageItem))
            {
                ImageViewer tab = messageTabControl.SelectedContent as ImageViewer;
                imageToEncode = new Bitmap(tab.filename);
                messageType   = MessageType.BinaryImage;
                message       = MessageConverter.Instance.BinaryImageToBit(imageToEncode, imageToEncode.Width, imageToEncode.Height);
            }
            else if (Equals(messageTabControl.SelectedItem, grayscaleImageItem))
            {
                ImageViewer tab = messageTabControl.SelectedContent as ImageViewer;
                imageToEncode = new Bitmap(tab.filename);
                messageType   = MessageType.GrayscaleImage;
                message       = MessageConverter.Instance.GrayscaleImageToBit(imageToEncode, imageToEncode.Width, imageToEncode.Height);
            }
            else if (Equals(messageTabControl.SelectedItem, colorImageItem))
            {
                ImageViewer tab = messageTabControl.SelectedContent as ImageViewer;
                imageToEncode = new Bitmap(tab.filename);
                messageType   = MessageType.ColorImage;
                message       = MessageConverter.Instance.ColorImageToBit(imageToEncode, imageToEncode.Width, imageToEncode.Height);
            }

            Bitmap image = new Bitmap(carrierViewer.filename);

            if (algorithmsComboBox.SelectedItem.ToString() == "LSB")
            {
                if (message != null)
                {
                    LSBHeader header = null;
                    switch (messageType)
                    {
                    case MessageType.Plaintext:
                        header  = new LSBHeader(MessageType.Plaintext, message.Length);
                        message = MessageConverter.Instance.TextToBit(message);
                        break;

                    case MessageType.BinaryImage:
                        header = new LSBHeader(MessageType.BinaryImage, message.Length, imageToEncode.Width, imageToEncode.Height);
                        break;

                    case MessageType.GrayscaleImage:
                        header = new LSBHeader(MessageType.GrayscaleImage, message.Length, imageToEncode.Width, imageToEncode.Height);
                        break;

                    case MessageType.ColorImage:
                        header = new LSBHeader(MessageType.ColorImage, message.Length, imageToEncode.Width, imageToEncode.Height);
                        break;
                    }
                    InputMessage inputMessageWithHeader = new InputMessage(message, header);
                    image = LSB.Instance.Encode(image, inputMessageWithHeader);
                }
            }
            else if (algorithmsComboBox.SelectedItem.ToString() == "Histogram shifting")
            {
                HSHeader header = null;
                if (message != null)
                {
                    switch (messageType)
                    {
                    case MessageType.Plaintext:
                        header  = new HSHeader(MessageType.Plaintext, message.Length);
                        message = MessageConverter.Instance.TextToBit(message);
                        break;

                    case MessageType.BinaryImage:
                        header = new HSHeader(MessageType.BinaryImage, message.Length, imageToEncode.Width, imageToEncode.Height);
                        break;

                    case MessageType.GrayscaleImage:
                        header = new HSHeader(MessageType.GrayscaleImage, message.Length, imageToEncode.Width, imageToEncode.Height);
                        break;

                    case MessageType.ColorImage:
                        header = new HSHeader(MessageType.ColorImage, message.Length, imageToEncode.Width, imageToEncode.Height);
                        break;
                    }
                }
                InputMessage inputMessageWithHeader = new InputMessage(message, header);
                image = HS.Instance.Encode(image, inputMessageWithHeader);
            }

            ImageFormat    format = ImageFormat.Png;
            SaveFileDialog sfd    = new SaveFileDialog();
            string         ext    = System.IO.Path.GetExtension(carrierViewer.filename);

            switch (ext)
            {
            case ".png":
                sfd.Filter = "Save Format|*.png";
                format     = ImageFormat.Png;
                break;

            case ".jpg":
                sfd.Filter = "Save Format|*.jpg";
                format     = ImageFormat.Jpeg;
                break;

            case ".bmp":
                sfd.Filter = "Save Format|*.bmp";
                format     = ImageFormat.Bmp;
                break;
            }
            if (sfd.ShowDialog() == true)
            {
                image.Save(sfd.FileName);
            }
            //Bitmap encryptedImage = new Bitmap(sfd.FileName);
        }