Professional Documents
Culture Documents
hide binary data within an image while adding few noticeable changes. Technological advancements over the past decade or so have brought terms like mp3, jpeg, and mpeg into our everyday vocabulary. These lossy compression techniques lend themselves perfectly for hiding data. We have chosen this project because it gives a chance to study several various aspects of DSP. First, we devised our own compression technique which we loosely based off jpeg. There have been many steganographic techniques created so far, which compelled us to create two of our own strategies for hiding data in the images we compress. Our first method, zero hiding, adds the binary data into the DCT coefficients dropped in compression. Our other method, which we called bit-o-steg, uses a key to change the values of coefficients that remain after compression. Finally, we had to find ways to analyze the success of our data hiding strategies, so through our research we found both DSP and statistical methods to qualitatively measure our work. Steganography, or hidden writing can be traced back to 440 BC in ancient Greece. Often they would write a message on a wooden panel, cover it in wax, and then write a message on the wax. These wax tablets were already used as writing utensils, so the hiding of a message in a commonly used device draws very little suspicion. In addition to use by the Greeks, the practice of steganography was utilized by spies in World War II. There were even rumors that terrorists made use of steganography early in 2001 to plan the attacks of September 11.The first description of the use of steganography dates back to the Greeks. Herodotus tells how a message was passed to the Greeks about Xerses' hostile intentions underneath the wax of a writing tablet, and describes a technique of dotting successive letters in a cover text with a secret ink, due to Aeneas the Tactician. Pirate legends tell of the practice of tattooing secret information, such as a map, on the head of someone, so that the hair would conceal it. Kahn tells of a trick used in China of embedding a code ideogram at a prearranged position in a dispatch; a similar idea led to the grille system used in medieval Europe, where a wooden template would be placed over a seemingly innocuous text, highlighting an embedded secret message. During WWII the grille method or some variants were used by spies. In the same period, the Germans developed microdot technology, which prints a clear, good quality photograph shrinking it to the size of a dot. There are rumors that during the 1980's Margareth Thatcher, then Prime Minister in UK, became so irritated about press leaks of cabinet documents, that she had the word processors programmed to encode the identity of the writer in the word spacing, thus 4
being able to trace the disloyal ministers. During the "Cold War" period, US and USSR wanted to hide their sensors in the enemy's facilities. These devices had to send data to their nations, without being spotted. Today, steganography is researched both for legal and illegal reasons. Among the first ones there is war telecommunications, which use spread spectrum or meteor scatter radio in order to conceal both the message and its source. In the industry market, with the advent of digital communications and storage, one of the most important issues is copyright enforcement, so digital watermarking techniques are being developed to restrict the use of copyrighted data. Another important use is to embed data about medical images, so that there are no problems with matching patient's records and images. Among illegal ones is the practice of hiding strongly-encrypted data to avoid controls by cryptography export laws.
compared with the suspect files. Through this statistical comparison you can, in theory, detect variations from the normally generated files. The key here is that the known, good files need to originate from the same source as the suspect files (that is, the digital camera or scanner), or as close a match as possible for the comparison to be effective. Some variations in this technique look for deviations from known compression algorithms in play on JPEGs, MP3s, and other files, as the compression algorithm is publicly known. One more advanced technique in use is known as Noise Floor Consistency Analysis. Without making this sound like a doctoral thesis in mathematics, in this method, comparison is made at the bit level between the MSB and the LSB components of a piece of data. Because the MSB and LSB should have a basic correlation between them, the alteration of the LSB by some steganographic techniques can break this relationship, making detection possible. In fact, some applications that perform this technique can detect hidden data within a highly reliable degree of confidence. Something to keep in mind with steganalysis techniques is that another layer of complexity may be added to the detection of hidden data. Consider this: If you want to add another element of protection to your hidden data, you could combine it with encryption before embedding the data. In this case, if detection is successful, decryption must also be performed. Steganalysis tools, like many security tools, are highly specialized, often with a highly specialized price tag. However, if you would like to experiment with some of the techniques, there is an open source project, Stegsecret ,which will begin your exploration.
The environment required in the development of system is any windows platform The observer pattern along with factory pattern will update the results eventually The language used in the development is .NET(C#)
Chapter 4 ANALYSIS
4.1 SYSTEM ANALYSIS
Steganography system requires any type of image file and the information or message that is to be hidden .It has two modules encrypt and decrypt. One of .Net tools for pictures and images is auto-converting most types of pictures to BMP format. I used this tool in this software called Steganography that is written in C#.Net language and you can use this software to hide your information in any type of pictures without any converting its format to BMP (software converts inside it).The algorithm used for Encryption and Decryption in this application provides using several layers lieu of using only LSB layer of image. Writing data starts from last layer (8th or LSB layer); because significant of this layer is least and every upper layer has doubled significant from its down layer. So every step we go to upper layer image quality decreases and image retouching transpires. The encrypt module is used to hide information into the image; no one can see that information or file. This module requires any type of imag e and message and gives the only one image file in destination. The decrypt module is used to get the hidden information in an image file. It take the image file as an output, and give two file at destination folder, one is the same image file and another is the message file that is hidden it that. Before encrypting file inside image we must save name and size of file in a definite place of image. We could save file name before file information in LSB layer and save file size and file name size in most right-down pixels of image. Writing this information is needed to retrieve file from encrypted image in decryption state.
IMAGE FILE
INFORMATION FILE
BMP FILE
10
BMP FILE
INFORMATION FILE
IMAGE FILE
11
4.4 STEGANALYSIS
Steganalysis is the art and science of detecting messages hidden using steganography; this is analogous to cryptanalysis applied to cryptography. The goal of steganalysis is to identify suspected packages, determine whether or not they have a payload encoded into them, and, if possible, recover that payload. Unlike cryptanalysis, where it is obvious that intercepted data contains a message (though that message is encrypted), steganalysis generally starts with a pile of suspect data files, but little information about which of the files, if any, contain a payload. The steganalyst is usually something of a forensic statistician, and must start by reducing this set of data files (which is often quite large; in many cases, it may be the entire set of files on a computer) to the subset most likely to have been altered.
Start Application
Encryption
Decryption
Image
Message file
Image file
Image
Message file
12
4.5FORMING LOGICAL MODEL OF THE SYSTEM WITH THE HELP OF DATA FLOW DIAGRAM (DFD)
Encryption Keys
13
Login Form
Output
Authentication form
Exit
Resources
14
The main objectives that are done during the input design are:
Data are collected from the source Transfer of data to an input form is done 15
Data is converted to a computer acceptable form The converted data are verified. Data are checked for its accuracy. Validation of input data are done
Process reviewing the study phase activities and making decisions about which functions are to be performed by the hardware, software, and human ware started in the design phase. The output, input and file design for each of the programs was done. Finally, the generalized systems were explained to the management for approval .The steps involved in designing phase were The function to be performed is identified) The input, output and file design is performed . The system and component cost requirements is specified The design phase report is generated.
17
18
19
A good test has a high probability of finding an error. A good test is not redundant. A good test should be best of breeds. A good test should neither too simple nor too complex.
QUALITY ASSURANCE GOALS CORRECTNESS The extent to which the program meets system specifications and user objectives. RELIABILITY- The degree to which the system performs Intended functions overtime. EFFICIENCY- The amount of computer resources required by a program to perform a function. USABILITY- The effort required learning and operating a system. 20
MAINTAINABILITY -To use with which program errors are located and corrected. TESTABILITY -The effort required testing a program to ensure its correct performance. PORTABILITY -The ease of transporting a program from one hardware configuration to another. ACCURACY -The required portion in input editing, computation and output.
21
using System; using System.Drawing; using System.Windows.Forms; using System.Text; using System.IO; namespace PictureKey { public class CryptUtility { /// <summary>Hides a message in a bitmap</summary> /// <param name="messageStream">The message to hide</param> /// <param name="bitmap">The carrier bitmap</param> /// <param name="keyStream">The key to use</param> public static void HideMessageInBitmap(Stream messageStream, CarrierImage[] imageFiles, FilePasswordPair[] keys, bool splitBytes){ HideOrExtract(ref messageStream, imageFiles, keys, splitBytes, false); messageStream = null; } /// <summary>Extracts an hidden message from a bitmap</summary> /// <param name="bitmap">The carrier bitmap</param> /// <param name="keyStream">The key used for hiding the message</param> /// <param name="messageStream">Empty stream to receive the message</param> public static void ExtractMessageFromBitmap(CarrierImage[]imageFiles, FilePasswordPair[] keys, ref Stream messageStream, bool splitBytes){ HideOrExtract(ref messageStream, imageFiles, keys, splitBytes, true); } /// <summary>Steps through the pixels of a bitmap using a key pattern and hides or extracts a message</summary> /// <param name="messageStream">If exctract is false, the message to hide - otherwise an empty stream to receive the extracted message</param> /// <param name="bitmap">The carrier bitmap</param> /// <param name="keyStream">The key specifying the unchanged pixels between two hidden bytes</param> /// <param name="extract">Extract a hidden message (true), or hide a message in a clean carrier bitmap (false)</param> private static void HideOrExtract(ref Stream messageStream, CarrierImage[] imageFiles, FilePasswordPair[] keys, bool splitBytes, bool extract){ //index for imageFiles int indexBitmaps = 0;
22
//load all bitmaps and count available pixels Bitmap[] bitmaps = new Bitmap[imageFiles.Length]; long countPixels = 0; for(indexBitmaps=0; indexBitmaps<imageFiles.Length; indexBitmaps++){ bitmaps[indexBitmaps] = new Bitmap(imageFiles[indexBitmaps].sourceFileName); countPixels += imageFiles[indexBitmaps].countPixels; } //Stores the color of a pixel Color pixelColor; //Length of the message Int32 messageLength; //combine all keys Stream keyStream = GetKeyStream(keys); if(extract){ //Read the length of the hidden message from the first pixel pixelColor = bitmaps[0].GetPixel(0,0); messageLength = (pixelColor.R << 16) + (pixelColor.G << 8) + pixelColor.B; messageStream = new MemoryStream(messageLength); }else{ messageLength = (Int32)messageStream.Length; if(messageStream.Length >= 16777215){ //The message is too long String exceptionMessage = "The message is too long, only 16777215 bytes are allowed."; throw new Exception(exceptionMessage); } } //calculate count of message-bytes to hide in (or extract from) each image long sumBytes = 0; for(int n=0; n<imageFiles.Length; n++){ float pixels = (float)imageFiles[n].countPixels / (float)countPixels; imageFiles[n].messageBytesToHide = (long)Math.Ceiling( (float)messageLength * pixels ); sumBytes += imageFiles[n].messageBytesToHide; } if(sumBytes > messageLength){ //correct Math.Ceiling effects imageFiles[imageFiles.Length-1].messageBytesToHide -= (sumBytes messageLength); } if( ! extract) { //Check size of the carrier image long countRequiredPixels; int readByte; String errorMessage = String.Empty;
23
for(int n=0; n<imageFiles.Length; n++){ //One pixel of the first image is used for the message's length countRequiredPixels = (n==0)?1:0; //Count pixels long countRequiredPixelsImage; if(splitBytes){ //use 8 pixels for a message byte countRequiredPixelsImage = imageFiles[n].messageBytesToHide * 8; }else{ //use one pixel for a message byte countRequiredPixelsImage = imageFiles[n].messageBytesToHide; } for(int countBytes=0; countBytes<countRequiredPixelsImage; countBytes++){ readByte = keyStream.ReadByte(); if(readByte < 0){ keyStream.Seek(0,SeekOrigin.Begin); readByte = keyStream.ReadByte(); } countRequiredPixels += readByte; } if(countRequiredPixels > imageFiles[n].countPixels){ errorMessage += "The images "+imageFiles[n].sourceFileName+" is too small for this message and key. "+countRequiredPixels+" pixels are required.\n"; } } if(errorMessage.Length > 0){ //One or more images are too small throw new Exception(errorMessage); } //Write length of the bitmap into the first pixel int colorValue = messageLength; int red = colorValue >> 16; colorValue -= red << 16; int green = colorValue >> 8; int blue = colorValue - (green << 8); pixelColor = Color.FromArgb(red, green, blue); bitmaps[0].SetPixel(0,0, pixelColor); } //Reset the streams keyStream.Seek(0, SeekOrigin.Begin); messageStream.Seek(0, SeekOrigin.Begin); //Loop over the message and hide each byte if(splitBytes){ HideBits(keyStream, messageStream, messageLength, imageFiles, bitmaps, extract); } else{
24
HideBytes(keyStream, messageStream, messageLength, imageFiles, bitmaps, extract); } for(indexBitmaps=0; indexBitmaps<bitmaps.Length; indexBitmaps++){ if( ! extract ){ SaveBitmap( bitmaps[indexBitmaps], imageFiles[indexBitmaps].resultFileName ); } bitmaps[indexBitmaps].Dispose(); } keyStream.Close(); } private static void MovePixelPosition(CarrierImage[] imageFiles, Bitmap[] bitmaps, int countBytesInCurrentImage, Stream keyStream, ref int indexBitmaps, ref Point pixelPosition, ref int bitmapWidth){ //Repeat the key, if it is shorter than the message if(keyStream.Position == keyStream.Length){ keyStream.Seek(0, SeekOrigin.Begin); } //Get the next pixel-count from the key, use "1" if it's 0 byte currentKeyByte = (byte)keyStream.ReadByte(); int currentStepWidth = (currentKeyByte==0) ? (byte)1 : currentKeyByte; //Perform line breaks, if current step is wider than the image while(currentStepWidth > bitmapWidth){ currentStepWidth -= bitmapWidth; pixelPosition.Y++; } //Move X-position if((bitmapWidth - pixelPosition.X) < currentStepWidth){ pixelPosition.X = currentStepWidth - (bitmapWidth - pixelPosition.X); pixelPosition.Y++; }else{ pixelPosition.X += currentStepWidth; } //Proceed to the next bitmap if(countBytesInCurrentImage == imageFiles[indexBitmaps].messageBytesToHide){ indexBitmaps++; pixelPosition.Y = 0; countBytesInCurrentImage = 0; bitmapWidth = bitmaps[indexBitmaps].Width-1; //bitmapHeight = bitmaps[indexBitmaps].Height-1; if(pixelPosition.X > bitmapWidth){ pixelPosition.X = 0; } } } private static byte GetReverseKeyByte(Stream keyStream){ //jump to reverse-read position and read from the end of the stream long keyPosition = keyStream.Position; keyStream.Seek(-keyPosition, SeekOrigin.End); byte reverseKeyByte = (byte)keyStream.ReadByte(); //jump back to normal read position keyStream.Seek(keyPosition, SeekOrigin.Begin);
25
return reverseKeyByte; } /// <summary>Loop over the message and hide each byte in one pixel</summary> /// <param name="keyStream">The key</param> /// <param name="messageStream">A stream containing the message (extract==false) or an empty stream (extract==true)</param> /// <param name="messageLength">Expected length of the message</param> /// <param name="imageFiles">CarrierImages describing the bitmaps</param> /// <param name="bitmaps">The bitmaps</param> /// <param name="extract">Hide the message (false) or extract it (true)</param> private static void HideBytes(Stream keyStream, Stream messageStream, long messageLength, CarrierImage[] imageFiles, Bitmap[] bitmaps, bool extract){ //Color component to hide the next byte in (0-R, 1-G, 2-B) //Rotates with every hidden byte int currentColorComponent = 0; //Index of the current bitmap int indexBitmaps = 0; //Maximum X and Y position in the current bitmap int bitmapWidth = bitmaps[0].Width-1; //int bitmapHeight = bitmaps[0].Height-1; //Current position in the carrier bitmap //Start with 1, because (0,0) contains the message length Point pixelPosition = new Point(1,0); //Count of bytes already hidden in the current image int countBytesInCurrentImage = 0; //Stores the color of a pixel Color pixelColor; //A value read from the key stream in reverse direction byte currentReverseKeyByte = 0; for(int messageIndex=0; messageIndex<messageLength; messageIndex++){ MovePixelPosition(imageFiles, bitmaps, countBytesInCurrentImage, keyStream, ref indexBitmaps, ref pixelPosition, ref bitmapWidth); currentReverseKeyByte = GetReverseKeyByte(keyStream); countBytesInCurrentImage++; //Get color of the "clean" pixel pixelColor = bitmaps[indexBitmaps].GetPixel(pixelPosition.X, pixelPosition.Y); if(extract){ //Extract the hidden message-byte from the color byte foundByte = (byte)(currentReverseKeyByte ^ GetColorComponent(pixelColor, currentColorComponent)); messageStream.WriteByte(foundByte); //Rotate color components currentColorComponent = (currentColorComponent==2) ? 0 : (currentColorComponent+1); }else{
26
//To add a bit of confusion, xor the byte with a byte read from the keyStream int currentByte = messageStream.ReadByte() ^ currentReverseKeyByte; if(imageFiles[indexBitmaps].useGrayscale){ pixelColor = Color.FromArgb(currentByte, currentByte, currentByte); }else{ //Change one component of the color to the message-byte SetColorComponent(ref pixelColor, currentColorComponent, currentByte); //Rotate color components currentColorComponent = (currentColorComponent==2) ? 0 : (currentColorComponent+1); } bitmaps[indexBitmaps].SetPixel(pixelPosition.X, pixelPosition.Y, pixelColor); } } } private static void HideBits(Stream keyStream, Stream messageStream, long messageLength, CarrierImage[] imageFiles, Bitmap[] bitmaps, bool extract){ //Color component to hide the next byte in (0-R, 1-G, 2-B) //Rotates with every hidden byte int currentColorComponent = 0; //Index of the current bitmap int indexBitmaps = 0; //Maximum X and Y position in the current bitmap int bitmapWidth = bitmaps[0].Width-1; //Current position in the carrier bitmap //Start with 1, because (0,0) contains the message length Point pixelPosition = new Point(1,0); //Count of bytes already hidden in the current image int countBytesInCurrentImage = 0; //Stores the color of a pixel Color pixelColor; //A value read from the key stream in reverse direction byte currentReverseKeyByte = 0; //The current byte of the message stream byte currentByte; for(int messageIndex=0; messageIndex<messageLength; messageIndex++){ currentReverseKeyByte = GetReverseKeyByte(keyStream); if(extract){ currentByte = 0; }else{ currentByte = (byte)messageStream.ReadByte();
27
//To add a bit of confusion, xor the byte with a byte read from the keyStream currentByte = (byte)(currentByte ^ currentReverseKeyByte); } for(byte bitPosition=0; bitPosition<8; bitPosition++){ MovePixelPosition(imageFiles, bitmaps, countBytesInCurrentImage, keyStream, ref indexBitmaps, ref pixelPosition, ref bitmapWidth); //Get color of the "clean" pixel pixelColor = bitmaps[indexBitmaps].GetPixel(pixelPosition.X, pixelPosition.Y); if(extract){ //Extract the hidden message-byte from the color byte foundByte = GetColorComponent(pixelColor, currentColorComponent); bool foundBit = GetBit(foundByte, 0); currentByte = SetBit(currentByte, bitPosition, foundBit); //Rotate color components currentColorComponent = (currentColorComponent==2) ? 0 : (currentColorComponent+1); }else{ bool currentBit = GetBit(currentByte, bitPosition); if(imageFiles[indexBitmaps].useGrayscale){ byte r = SetBit(pixelColor.R, 0, currentBit); byte g = SetBit(pixelColor.G, 0, currentBit); byte b = SetBit(pixelColor.B, 0, currentBit); pixelColor = Color.FromArgb(r, g, b); }else{ //Change one component of the color to the messagebyte byte colorComponentValue = GetColorComponent(pixelColor, currentColorComponent); colorComponentValue = SetBit(colorComponentValue, 0, currentBit); SetColorComponent(ref pixelColor, currentColorComponent, colorComponentValue); //Rotate color components currentColorComponent = (currentColorComponent==2) ? 0 : (currentColorComponent+1); } bitmaps[indexBitmaps].SetPixel(pixelPosition.X, pixelPosition.Y, pixelColor); } } if(extract){ currentByte = (byte)(currentByte ^ currentReverseKeyByte); messageStream.WriteByte(currentByte); }
28
countBytesInCurrentImage++; } } /// <summary>Get the value of a bit</summary> /// <param name="b">The byte value</param> /// <param name="position">The position of the bit</param> /// <returns>The value of the bit</returns> private static bool GetBit(byte b, byte position){ return ((b & (byte)(1 << position)) != 0); } /// <summary>Set a bit to [newBitValue]</summary> /// <param name="b">The byte value</param> /// <param name="position">The position (1-8) of the bit</param> /// <param name="newBitValue">The new value of the bit in position [position]</param> /// <returns>The new byte value</returns> private static byte SetBit(byte b, byte position, bool newBitValue){ byte mask = (byte)(1 << position); if(newBitValue){ return (byte)(b | mask); }else{ return (byte)(b & ~mask); } } /// <summary>Return one component of a color</summary> /// <param name="pixelColor">The Color</param> /// <param name="colorComponent">The component to return (0-R, 1-G, 2-B)</param> /// <returns>The requested component</returns> private static byte GetColorComponent(Color pixelColor, int colorComponent){ byte returnValue = 0; switch(colorComponent){ case 0: returnValue = pixelColor.R; break; case 1: returnValue = pixelColor.G; break; case 2: returnValue = pixelColor.B; break; } return returnValue; } /// <summary>Changees one component of a color</summary> /// <param name="pixelColor">The Color</param> /// <param name="colorComponent">The component to change (0-R, 1-G, 2-B)</param> /// <param name="newValue">New value of the component</param> private static void SetColorComponent(ref Color pixelColor, int colorComponent, int newValue){ switch(colorComponent){ case 0: pixelColor = Color.FromArgb(newValue, pixelColor.G, pixelColor.B); break;
29
case 1: pixelColor = Color.FromArgb(pixelColor.R, newValue, pixelColor.B); break; case 2: pixelColor = Color.FromArgb(pixelColor.R, pixelColor.G, newValue); break; } } private static String UnTrimColorString(String color, int desiredLength){ int difference = desiredLength - color.Length; if(difference > 0){ color = new String('0', difference) + color; } return color; }
private static void SaveBitmap(Bitmap bitmap, String fileName){ String fileNameLower = fileName.ToLower(); System.Drawing.Imaging.ImageFormat format = System.Drawing.Imaging.ImageFormat.Bmp; if((fileNameLower.EndsWith("tif"))||(fileNameLower.EndsWith("tiff"))){ format = System.Drawing.Imaging.ImageFormat.Tiff; }else if(fileNameLower.EndsWith("png")){ format = System.Drawing.Imaging.ImageFormat.Png; } //copy the bitmap Image img = new Bitmap(bitmap); //close bitmap file bitmap.Dispose(); //save new bitmap img.Save(fileName, format); img.Dispose(); } //--------------------------------------------- combining the keys /// <summary>Combines key file and password using XOR</summary> /// <param name="key">The key/password pair to combine</param> /// <returns>The stream created from key and password</returns> public static MemoryStream CreateKeyStream(FilePasswordPair key){ FileStream fileStream = new FileStream(key.fileName, FileMode.Open); MemoryStream resultStream = new MemoryStream(); int passwordIndex = 0; int currentByte = 0; while( (currentByte = fileStream.ReadByte()) >= 0 ){ //combine the key-byte with the corresponding password-byte currentByte = currentByte ^ key.password[passwordIndex]; //add the result to the key stream resultStream.WriteByte((byte)currentByte);
30
//proceed to the next letter or repeat the password passwordIndex++; if(passwordIndex == key.password.Length){ passwordIndex = 0; } } fileStream.Close(); resultStream.Seek(0, SeekOrigin.Begin); return resultStream; } /// <summary>Combines all key files and passwords into one key stream</summary> /// <param name="keys">The keys to combine</param> /// <returns>The resulting key stream</returns> private static MemoryStream GetKeyStream(FilePasswordPair[] keys){ //Xor the keys an their passwords MemoryStream[] keyStreams = new MemoryStream[keys.Length]; for(int n=0; n<keys.Length; n++){ keyStreams[n] = CreateKeyStream(keys[n]); } //Buffer for the resulting stream MemoryStream resultKeyStream = new MemoryStream(); //Find length of longest stream long maxLength = 0; foreach(MemoryStream stream in keyStreams){ if( stream.Length > maxLength ){ maxLength = stream.Length; } } int readByte = 0; for(long n=0; n<=maxLength; n++){ for(int streamIndex=0; streamIndex<keyStreams.Length; streamIndex++){ if(keyStreams[streamIndex] != null){ readByte = keyStreams[streamIndex].ReadByte(); if(readByte < 0){ //end of stream - close the file //the last loop (n==maxLength) will close the last stream keyStreams[streamIndex].Close(); keyStreams[streamIndex] = null; }else{ //copy a byte into the result key resultKeyStream.WriteByte( (byte)readByte ); } } } } return resultKeyStream; }}}
31
32
If the password doesnt match then the following error will occur:
33
9.1 CONCLUSION
Steganography is not intended to replace cryptography but rather to supplement it. If a message is encrypted and hidden with a steganographic method it provides an additional layer of protection and reduces the chance of the hidden message being detected. Steganography is still a fairly new concept to the general public although this is likely not true in the world of secrecy and espionage. Digital watermark technology is currently being used to track the copyright and ownership of digital content. Efforts to improve the robustness of the watermarks are necessary to ensure that the watermarks and embedded information can securely defend against watermarking attacks. With continuous advancements in technology it is expected that in the near future more efficient and advanced techniques in steganalysis will emerge that will help law enforcement to better detect illicit materials transmitted through the Internet. The tutorial introduces a tiny part of the art of steganography. Steganography goes well beyond simply hiding text information in an image. Steganography applies not only to digital images but to other media as well, such as audio files, communication channels, and other text and binary files.
34
35
36
37
10.6
SCREEN
LAYOUT
FOR
EXTRACTING
FILES
38
REFERNCES
Websites Following websites are referring to create this project reports. http://www.microsoft.com http://www.programmer2programmer.net http://www.codeproject.com http://www.asp.net http://www.asp123.com http://www.wikipedia.org http://www.jjtc.com http://www.scribd.com
Books Following books and eBook are used to complete this project reports. Mastering C# .NET Black Book Professional C#, 2nd Edition
39