Introduction
This article enhances part 1 by adding three important features to the application:
- Password protection for each key file
- Multiple carrier images
Multiple Keys
Symmetric keys contain a central problem: How do you transfer the key? Anyone who gets his hands on the key is able to decrypt every message you send or receive. So we have to make it difficult to steal the key. One idea might be keeping the keys short and don’t save them at all. But a short key always leaves a footprint in the encrypted file, in our case it wouldt be visible as a regular noise pattern.
Why not combine a short password with a long key? You can store a long key in a file, and encrypt that key using a short password which is stored only in your brain.
A password always belongs to its key file, just like that:
public struct FilePasswordPair{ public String fileName; public String password; public FilePasswordPair(String fileName, String password){ this.fileName = fileName; this.password = password; } }
Before we can use the keys, the file/password pairs have to be combined.
In this example the key file contains the text "hello-world". Whenever you hide or extract a message with the "hello-world"-key, you type the password "nothing". The application XOR-combines the bytes of the key file with the bytes of the password, repeating the password again and again.
Here is the same thing in C#
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); //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; }
The resulting stream is as long as your key file, but never stored anywhere. Of course this encryption is not really save, so we’ll use more keys and more passwords. Before the recipient is able to extract the message, he must have all the keys and know all the passwords. If somebody manages to copy one key or guess two passwords, there's no need to panic as long as the other key files are still save.
That means, before hiding or extracting data we create each key stream as shown above, and then combine all streams into one key stream:
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; }
As you can see, we don’t have to change the algorithm at all. We just call GetKeyStream
before hiding or extracting the message, then we can pass the complete key stream to HideOrExtract()
.
After that we have one picture containing all hidden information. Again, we are facing the problem of tranfer.
Spread the information over the images
If you're really paranoid, you won’t trust your mailbox. Of course you won’t trust the postman either. That means, you don’t dare sending the carrier bitmap in one piece.
That is no problem anymore, because you can hide one message in many bitmaps. It is quite similar to writing text across a couple of pages. According to this application, it means spreading the pixels over multiple images.
![]() |
![]() |
You can send each image in a separate e-mail, post them in different mailboxes, or store them on different discs. The GUI allows selecting carrier bitmaps the same way as selecting key files. The selection is stored as an array of CarrierImage
.
public struct CarrierImage{ //file name of the clean image public String sourceFileName; //file name to save the new image public String resultFileName; //width * height public long countPixels; //produce colorful (false) or grayscale noise (true) for this picture public bool useGrayscale; //how many bytes will be hidden in this image - this field is set by CryptUtility.HideOrExtract() public long messageBytesToHide; public CarrierImage(String sourceFileName, String resultFileName, long countPixels, bool useGrayscale){ this.sourceFileName = sourceFileName; this.resultFileName = resultFileName; this.countPixels = countPixels; this.useGrayscale = useGrayscale; this.messageBytesToHide = 0; } }
Larger images can hide more bytes (more pixels) than smaller images. This application uses the most simple distribution:
//calculate count of message-bytes to hide in (or extract from) each image for(int n=0; n<imageFiles.Length; n++){ //pixels = count of pixel in this image / count of all available pixels float pixels = (float)imageFiles[n].countPixels / (float)countPixels; //this image will hide (length of the message * pixels) bytes imageFiles[n].messageBytesToHide = (long)Math.Ceiling( (float)messageLength * pixels ); }
Now we start with the first carrier bitmap, loop over the message, hide a number of bytes, switch to the second carrier bitmap, and so on.
//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; //Index of the currently used image int indexBitmaps = 0; //Loop over the message and hide each byte for(int messageIndex=0; messageIndex<messageLength; messageIndex++){ //Calculate the position of the next pixel //... //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; } } //hide or extract a byte //... countBytesInCurrentImage++; }
In the end we must save the new images. Each image can be saved using a different format (bmp, tif or png). The new format has nothing to do with the format of the original image file. That means, you can select a BMP-, two PNG- and a TIFF-file as carrier images, and save the results into three TIFF- and one PNG-file.
//... for(indexBitmaps=0; indexBitmaps<bitmaps.Length; indexBitmaps++){ if( ! extract ){ //Extract mode does not change any images //Save the resulting image and close the source file SaveBitmap( bitmaps[indexBitmaps], imageFiles[indexBitmaps].resultFileName ); } } //... private static void SaveBitmap(Bitmap bitmap, String fileName){ String fileNameLower = fileName.ToLower(); //Get the format from the file extension 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(); }