Esempio n. 1
0
        /**
         * Masks a file with an image given a file and image.
         */
        public static string[] Mask(string file, string image)
        {
            //Create a new Bitmap objects and map pixels/bits.
            var img = new Bitmap(image);

            Color[] pixels = GetPixels(img);
            var pixelBits = new int[pixels.Length];

            for (int n = 0, length = pixels.Length; n < length; n++)
                pixelBits[n] = Util.ColorToBits(pixels[n]);

            //Read all bits from the file to mask.
            byte[] bytes = File.ReadAllBytes(file);
            var bits = new BitArray(bytes);

            //Merge bits.
            var tour = new Tour(img.Width, img.Height);
            pixelBits = Merge(bits, tour, pixelBits);

            //Generate pixel colors based on each the merged bits.
            for (int n = 0, length = pixelBits.Length; n < length; n++)
                pixels[n] = Util.BitsToColor(pixelBits[n]);

            Bitmap maskedImage = CreateImage(img.Width, img.Height, pixels);

            //Save the new image.
            string dir = Path.GetDirectoryName(image);
            string name = Path.GetFileNameWithoutExtension(image);
            string extension = Path.GetExtension(image);

            Benchmark mark = new Benchmark("Time to Write Masked File", true);

            maskedImage.Save(dir + "\\" + name + " - Masked" + extension);

            mark.Time();

            //Generate AES keys and return.
            mark = new Benchmark("Time to Generate Encryption Keys", true);

            string[] hash = Crypt.Encrypt(Path.GetFileName(file) + ":" + bits.Length + ":" + tour.Export());

            mark.Time();

            return hash;
        }
Esempio n. 2
0
        /**
         * Creates a file given an image and a valid hash and key.
         */
        public static void Unmask(string image, string hash, string key)
        {
            //Create a new Bitmap object and decrypt the AES hash.
            var img = new Bitmap(image);
            string info = Crypt.Decrypt(hash, key);

            if (info != null)
            {
                string name = info.Split(':')[0];
                int size = int.Parse(info.Split(':')[1]);

                var tour = new Tour(img.Width, img.Height);
                Square path = tour.Import(info.Split(':')[2]);

                //Get pixel data and extract bits from the data.
                Color[] pixels = GetPixels(img);
                var pixelBits = new int[pixels.Length];

                for (int n = 0, length = pixels.Length; n < length; n++)
                    pixelBits[n] = Util.ColorToBits(pixels[n]);

                var file = new byte[size/8];

                Extract(pixelBits, tour, path, size).CopyTo(file, 0);

                //Write the bits to a file.
                File.WriteAllBytes(Path.GetDirectoryName(image) + "\\" + name, file);
            }
        }
Esempio n. 3
0
        /**
         * Merges colors represented as 32-bit integers with an array of bits
         * from a given file.
         */
        private static int[] Merge(BitArray bits, Tour tour, int[] pixels)
        {
            //Clone pixels to prevent destruction.
            var newPixels = (int[]) pixels.Clone();

            Benchmark mark = new Benchmark("Time to Generate Tour", true);

            Square start = tour.CreateTour();
            Square current = start;

            mark.Time();

            mark = new Benchmark("Time to Modify Pixel Channels", true);

            for (int n = 0, length = bits.Length; n < length; n += 3)
            {
                //Calculate the bit depth to use.
                int depth = n/newPixels.Length;

                //Select the pixel to operate on and get the color channels.
                int index = Util.ToIndex(tour.Width, current.X, current.Y);
                int pixel = newPixels[index];

                //Get channel values and create a bool representation.
                int r = (pixel >> 16) & 0xFF;
                int g = (pixel >> 8) & 0xFF;
                int b = pixel & 0xFF;

                bool red = bits[n];
                bool green = n + 1 < length && bits[n + 1];
                bool blue = n + 2 < length && bits[n + 2];

                //Set pixel channel values based on the above bools.
                if (red) r = r | 1 << depth;
                else r = r & ~(1 << depth);

                if (green) g = g | 1 << depth;
                else g = g & ~(1 << depth);

                if (blue) b = b | 1 << depth;
                else b = b & ~(1 << depth);

                newPixels[index] = Util.BitsToColor(r, g, b);

                //Select the next pixel to manipulate.
                current = current.Next ?? start;
            }

            mark.Time();

            return newPixels;
        }
Esempio n. 4
0
        /**
         * Returns a BitArray object containing the bits extracted from
         * the pixel array "bits".
         */
        private static BitArray Extract(int[] bits, Tour tour, Square path, int size)
        {
            var file = new BitArray(size);
            Square start = path;

            for (int n = 0; n < size; n += 3)
            {
                int depth = n/bits.Length;
                int index = Util.ToIndex(tour.Width, path.X, path.Y);
                Color color = Util.BitsToColor(bits[index]);

                int r = color.R;
                int g = color.G;
                int b = color.B;

                r = r & 1 << depth;
                g = g & 1 << depth;
                b = b & 1 << depth;

                file.Set(n, Util.IntToBool(r));
                if (n + 1 < size) file.Set(n + 1, Util.IntToBool(g));
                if (n + 2 < size) file.Set(n + 2, Util.IntToBool(b));

                //Select the next pixel to read from.
                path = path.Next ?? start;
            }

            return file;
        }