public void Test2()
{
var(item1, item2) = AlgorithmUtility.Run <long, long>(InputFilePath("input2.txt"));
var result = RunTest(() => CountTriplets.countTriplets(item2[0], item1[1])).Item1;
Assert.Equal(4, result);
}
/// <summary>
/// Updates contents of encrypted file using another unencrypted file. Iv and signature of the file is also changed.
/// </summary>
/// <param name="updateFile">Unencrypted file used to update encrypted file.</param>
/// <param name="oldEncryptedFile">Encrypted file in its raw form that is being updated.</param>
/// <param name="userId">Id of the user updating the file. File can only be updated by a file owner.</param>
/// <param name="userPrivateKey">Private RSA key of the user updating the file.</param>
/// <returns>Updated encrypted file in its raw form.</returns>
public byte[] Update(OriginalFile updateFile, byte[] oldEncryptedFile, int userId, RSAParameters userPrivateKey)
{
if (userId != GetFileOwnerId(oldEncryptedFile))
{
throw new Exception("Only a file owner can modify its content.");
}
var offset = 0;
((StandardInformation)Headers[0]).ParseStandardInformation(oldEncryptedFile, offset);
// update altered and read time of the file
((StandardInformation)Headers[0]).AlteredTime = ((StandardInformation)Headers[0]).ReadTime = DateTime.Now;
// update id of the user who is updating file; ATimeUserId doesn't need to change since only a file owner can edit the file
((StandardInformation)Headers[0]).RTimeUserId = (uint)userId;
offset += (int)((StandardInformation)Headers[0]).GetSaveLength();
((SecurityDescriptor)Headers[1]).ParseSecurityDescriptor(oldEncryptedFile, ref offset);
// update file signature
SignFile(updateFile.FileContent, ref userPrivateKey);
// update IV value
new RNGCryptoServiceProvider().GetBytes(((SecurityDescriptor)Headers[1]).IV);
Headers[2] = new Data(updateFile.FileContent,
AlgorithmUtility.GetAlgorithmFromNameSignature(((SecurityDescriptor)Headers[1]).AlgorithmNameSignature,
((SecurityDescriptor)Headers[1]).GetKey(userId, userPrivateKey), ((SecurityDescriptor)Headers[1]).IV));
// update the file size
((StandardInformation)Headers[0]).TotalLength = (uint)((Data)Headers[2]).EncryptedData.Length;
return(Flush());
}
public void Test3()
{
var(item1, item2) = AlgorithmUtility.Run <int, string>(InputFilePath("input06.txt"));
var result = RunTest(() => SherlockAndAnagrams.sherlockAndAnagrams(item2[0][0])).Item1;
Assert.Equal(5, result);
}
public void Test3()
{
var(item1, item2) = AlgorithmUtility.Run <int, string>(InputFilePath("input21.txt"));
var result = RunTest(() => RansomeNote.checkMagazine(item2[0].ToArray(), item2[1].ToArray()));
Assert.Equal("No", result.Item1);
}
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);
}
public string ComputeHash(string password)
{
var buffer = _encoding.GetBytes(password);
buffer = AlgorithmUtility.RunSha384(algo => algo.ComputeHash(buffer));
return(Convert.ToBase64String(buffer));
}
public void Test1()
{
var(item1, item2) = AlgorithmUtility.Run <int, int>(InputFilePath("input.txt"));
var(result, time) = RunTest(() => BubbleSort.countSwaps(item2[0].ToArray()));
Assert.Equal("Array is sorted in 3 swaps.", $"Array is sorted in {result.Item1} swaps.");
Assert.Equal("First Element: 1", $"First Element: { result.Item2}");
Assert.Equal("Last Element: 3", $"Last Element: {result.Item3}");
}
public DecryptTab()
{
InitializeComponent();
algorithmsComboBox.ItemsSource = AlgorithmUtility.getList();
//NOTE make background transparent - color used only in designer
this.Background = System.Windows.Media.Brushes.Transparent;
Console.WriteLine("Selected index {0}", algorithmsComboBox.SelectedIndex.ToString());
}
private void CalculateImageDifference()
{
using (Bitmap image1 = new Bitmap(imageViewer1.filename))
using (Bitmap image2 = new Bitmap(imageViewer2.filename))
{
double imageSimilarity;
imageDifference.image.Source = AlgorithmUtility.BitmapToImageSource(ImageDifference.Instance.CalculateDifference(image1, image2, out imageSimilarity));
ImageDifferenceInfo.CalculateProperties(imageSimilarity, image1, image2);
}
}
public EncryptTab()
{
InitializeComponent();
algorithmsComboBox.ItemsSource = AlgorithmUtility.getList();
//NOTE make background transparent - color used only in designer
this.Background = System.Windows.Media.Brushes.Transparent;
// listeners
carrierViewer.PropertyChanged += carrierViewer_PropertyChanged;
}
/// <summary>
/// Initializes a new instance of the <see cref="SecurityDescriptor"/> class with the specified parameters.
/// This constructor is used when a file is first encrypted.
/// </summary>
/// <param name="ownerId">Users Id from the database.</param>
/// <param name="algorithmNameSignature">Full name of the used symmetric algorithm.</param>
/// <param name="hashAlgorithmName">Name of the hash algorithm used for file signing.</param>
/// <param name="ownerPublicKey">Users public RSA key.</param>
public SecurityDescriptor(int ownerId, string algorithmNameSignature, string hashAlgorithmName, RSAParameters ownerPublicKey) : base(AttributeType.SECURITY_DESCRIPTOR)
{
OwnerId = ownerId;
AlgorithmNameSignature = algorithmNameSignature;
HashAlgorithmName = hashAlgorithmName;
var algorithm = AlgorithmUtility.GetAlgorithmFromNameSignature(AlgorithmNameSignature);
IV = algorithm.AdditionalData;
Users.Add(ownerId, new FileEncryptionKey(algorithm.Key).UnparseFek(ownerPublicKey));
}
public void Test2()
{
var(item1, item2) = AlgorithmUtility.Run <int, string>(InputFilePath("input01.txt"));
var result = new List <int>();
for (var i = 0; i < item1[0]; i++)
{
result.Add(RunTest(() => SherlockAndAnagrams.sherlockAndAnagrams(item2[i][0])).Item1);
}
Assert.Equal(3, result[0]);
Assert.Equal(10, result[1]);
}
public void TestNaive()
{
var(item1, item2) = AlgorithmUtility.Run <int, string>(InputFilePath("input.txt"));
var result = new List <string>();
for (var i = 0; i < item2.Count - 1; i += 2)
{
result.Add(RunTest(() => TwoStrings.twoStringsNaive(item2[i][0], item2[i + 1][0])).Item1);
}
Assert.Equal("YES", result[0]);
Assert.Equal("NO", result[1]);
}
/// <summary>
/// Encrypts original file using set parameters.
/// </summary>
/// <param name="originalFile">Original, unencrypted file.</param>
/// <param name="userId">Id of the user who is encrypting original file.</param>
/// <param name="userPrivateKey">Private RSA key of the user encrypting the file.</param>
/// <returns>Encrypted file in its raw form.</returns>
public byte[] Encrypt(OriginalFile originalFile, int userId, RSAParameters userPrivateKey)
{
// create a file signature
SignFile(originalFile.FileContent, ref userPrivateKey);
Headers[2] = new Data(originalFile.FileContent,
AlgorithmUtility.GetAlgorithmFromNameSignature(((SecurityDescriptor)Headers[1]).AlgorithmNameSignature,
((SecurityDescriptor)Headers[1]).GetKey(userId, userPrivateKey), ((SecurityDescriptor)Headers[1]).IV));
((StandardInformation)Headers[0]).TotalLength = (uint)((Data)Headers[2]).EncryptedData.Length;
return(Flush());
}
/// <summary>
/// Checks if the file signature is valid.
/// </summary>
/// <param name="data">Original, decrypted file in raw format.</param>
/// <param name="userId">Id of the user decrypting the file.</param>
/// <param name="ownerPublicKey">Public RSA key of the file owner used to verify file signature.</param>
/// <returns>true if the signature is valid, otherwise false.</returns>
private bool CheckFileSignature(byte[] data, int userId, RSAParameters ownerPublicKey)
{
try
{
var hashAlgo = AlgorithmUtility.GetHashAlgoFromNameSignature(((SecurityDescriptor)Headers[1]).HashAlgorithmName);
return(CheckFileSignatureHelper(data, userId, ownerPublicKey, hashAlgo));
}
catch (CryptographicException)
{
var hashAlgo = AlgorithmUtility.GetHashSignerFromNameSignature(((SecurityDescriptor)Headers[1]).HashAlgorithmName);
return(CheckFileSignatureHelper(data, userId, ownerPublicKey, hashAlgo));
}
}
public void ShouldCalculateDifferencesOnHS(int payloadSize, string filename)
{
payloadSize = payloadSize / 8;
var message = GeneratePayload(payloadSize);
Bitmap cleanImage = new Bitmap(filename);
HSHeader header = new HSHeader(MessageType.Plaintext, message.Length);
string inputMeesageInBits = MessageConverter.Instance.TextToBit(message);
IInputMessage inputMessage = 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 + HSHeaderConstants.PlainTextHeaderLength);
Dictionary <int, int> histogram = HS.Instance.calculateHistogram(cleanImage);
Tuple <int, int, int, int> myTuple = HS.Instance.findMinAndMax(histogram);
int minIndex = myTuple.Item3;
int maxIndex = myTuple.Item4;
int maxIndexValue = myTuple.Item2;
var capacity = maxIndexValue;
Console.WriteLine("Image capacity is {0}", capacity);
Bitmap encryptedImage = HS.Instance.Encode(cleanImage, inputMessage);
OutputMessage imageMessageInBits = HS.Instance.Decode(encryptedImage, minIndex, maxIndex);
string imageMessage = AlgorithmUtility.bitMessageToText(imageMessageInBits.GetContent(), (int)HSHeaderConstants.PlainTextHeaderLength);
Assert.AreEqual(message, imageMessage);
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);
Bitmap cleanedImage = HS.Instance.Clean(encryptedImage, minIndex, maxIndex);
var error = MSE.Instance.CalculateDifference(cleanedImage, cleanImage);
Assert.AreEqual(0, error);
}
/// <summary>
/// Creates a file signature using the unencripted data and user private RSA key.
/// </summary>
/// <param name="data">Original, unencrypted file in raw format.</param>
/// <param name="userPrivateKey">Private RSA key of the user encrypting the file.</param>
private void SignFile(byte[] data, ref RSAParameters userPrivateKey)
{
try
{
// Exception will be thrown if the hashing algoritm is MD2, MD4, RIPEMD or SHA224.
var hashAlgo = AlgorithmUtility.GetHashAlgoFromNameSignature(((SecurityDescriptor)Headers[1]).HashAlgorithmName);
((SecurityDescriptor)Headers[1]).Signature = new RsaAlgorithm(userPrivateKey).CreateSignature(data, hashAlgo);
}
catch (CryptographicException)
{
var hashAlgo = AlgorithmUtility.GetHashSignerFromNameSignature(((SecurityDescriptor)Headers[1]).HashAlgorithmName);
((SecurityDescriptor)Headers[1]).Signature = new RsaAlgorithm(userPrivateKey).CreateSignature(data, hashAlgo);
}
}
public void GetsAlgorithmType()
{
var algorithmChecker = new AlgorithmUtility();
// Test algorithm name strings
var sha256 = algorithmChecker.GetAlgorithmType("sha256");
var sha384 = algorithmChecker.GetAlgorithmType("sha384");
var sha512 = algorithmChecker.GetAlgorithmType("sha512");
// Assert that correct HashAlgorithmType is returned
Assert.Equal(HashAlgorithmType.Sha256, sha256);
Assert.Equal(HashAlgorithmType.Sha384, sha384);
Assert.Equal(HashAlgorithmType.Sha512, sha512);
}
public void ShouldReadEncryptedTextInputMessageLeft(string message)
{
Bitmap cleanImage = new Bitmap(cleanImagePathLeft);
HSHeader header = new HSHeader(MessageType.Plaintext, message.Length, 0);
string inputMeesageInBits = MessageConverter.Instance.TextToBit(message);
IInputMessage inputMessage = new InputMessage(inputMeesageInBits, header);
Bitmap encryptedImage = HS.Instance.Encode(cleanImage, inputMessage);
Dictionary <int, int> histogram = HS.Instance.calculateHistogram(cleanImage);
Tuple <int, int, int, int> myTuple = HS.Instance.findMinAndMax(histogram);
int minIndex = myTuple.Item3;
int maxIndex = myTuple.Item4;
OutputMessage imageMessageInBits = HS.Instance.Decode(encryptedImage, minIndex, maxIndex);
string imageMessage = AlgorithmUtility.bitMessageToText(imageMessageInBits.GetContent(), (int)HSHeaderConstants.PlainTextHeaderLength);
Assert.AreEqual(message, imageMessage);
}
public byte[] Decrypt(byte[] data)
{
if (!ModeSignature.Equals("OFB"))
{
using var tdes = new TripleDESCryptoServiceProvider
{
Mode = AlgorithmUtility.GetCipherMode(ModeSignature)
};
using var decryptor = tdes.CreateDecryptor(Key, IV);
using var ms = new MemoryStream(data);
using var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read);
var decrypted = new byte[data.Length];
var bytesRead = cs.Read(decrypted, 0, data.Length);
return decrypted.Take(bytesRead).ToArray();
}
else
{
byte[] decrypted;
var tdes = CreateTripleDesCipher(false);
try
{
decrypted = new byte[tdes.GetOutputSize(data.Length)];
var len = tdes.ProcessBytes(data, 0, data.Length, decrypted, 0);
tdes.DoFinal(decrypted, len);
return decrypted;
}
catch (CryptoException)
{
}
}
return null;
}
public byte[] Decrypt(byte[] data)
{
if (ModeSignature.Equals("CBC") || ModeSignature.Equals("ECB"))
{
using var aes = new AesManaged
{
Mode = AlgorithmUtility.GetCipherMode(ModeSignature)
};
using var decryptor = aes.CreateDecryptor(Key, IV);
using var ms = new MemoryStream(data);
using var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read);
var decrypted = new byte[data.Length];
var bytesRead = cs.Read(decrypted, 0, decrypted.Length);
return(decrypted.Take(bytesRead).ToArray());
}
else // OFB or CFB
{
byte[] decrypted;
var aes = CreateAesCipher(false);
try
{
decrypted = new byte[aes.GetOutputSize(data.Length)];
var len = aes.ProcessBytes(data, 0, data.Length, decrypted, 0);
aes.DoFinal(decrypted, len);
return(decrypted);
}
catch (CryptoException)
{
}
}
return(null);
}
public byte[] Encrypt(byte[] data)
{
if (ModeSignature.Equals("CBC") || ModeSignature.Equals("ECB"))
{
using var aes = new AesManaged
{
Mode = AlgorithmUtility.GetCipherMode(ModeSignature)
};
using var encryptor = aes.CreateEncryptor(Key, IV);
using var ms = new MemoryStream();
using var writer = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
writer.Write(data, 0, data.Length);
writer.FlushFinalBlock();
return(ms.ToArray());
}
else // OFB or CFB
{
byte[] encrypted;
var aes = CreateAesCipher(true);
try
{
encrypted = new byte[aes.GetOutputSize(data.Length)];
var len = aes.ProcessBytes(data, 0, data.Length, encrypted, 0);
aes.DoFinal(encrypted, len);
return(encrypted);
}
catch (CryptoException)
{
}
return(null);
}
}
/// <summary>
/// Decrypts encrypted file using parameters contained inside headers of the encrypted file.
/// </summary>
/// <param name="encryptedFile">Encrypted file in its raw form.</param>
/// <param name="userId">Id of the user decrypting the file.</param>
/// <param name="userPrivateKey">Private RSA key of the user decrypting the file.</param>
/// <param name="ownerPublicKey">Public RSA key of the file owner used to verify file signature.</param>
/// <returns>Decrypted file.</returns>
public OriginalFile Decrypt(byte[] encryptedFile, int userId, RSAParameters userPrivateKey, RSAParameters ownerPublicKey)
{
var offset = 0;
((StandardInformation)Headers[0]).ParseStandardInformation(encryptedFile, offset);
// update id of the user who is accessing the file
((StandardInformation)Headers[0]).ReadTime = DateTime.Now;
((StandardInformation)Headers[0]).RTimeUserId = (uint)userId;
offset += (int)((StandardInformation)Headers[0]).GetSaveLength();
((SecurityDescriptor)Headers[1]).ParseSecurityDescriptor(encryptedFile, ref offset);
((Data)Headers[2]).ParseData(encryptedFile, offset, (int)((StandardInformation)Headers[0]).TotalLength);
var fileKey = ((SecurityDescriptor)Headers[1]).GetKey(userId, userPrivateKey);
var fileName = NameDecryption(new AesAlgorithm(fileKey, ((SecurityDescriptor)Headers[1]).IV, "OFB"));
byte[] fileContent;
// Try to decrypt encrypted file. Exception will be thrown if Key, Iv or algorithm signature is changed.
// Unauthorised algorithm change doesn't always have to trigger this exception and file decryption will be successful.
// Such file will fail signature check test below.
try
{
fileContent = ((Data)Headers[2]).Decrypt(AlgorithmUtility.GetAlgorithmFromNameSignature(((SecurityDescriptor)Headers[1]).AlgorithmNameSignature, fileKey, ((SecurityDescriptor)Headers[1]).IV));
}
catch (Exception e)
{
throw new CryptographicException("Unsuccessful decryption. File has been compromised.", e);
}
// if file signature isn't valid Exception will be thrown!
return(CheckFileSignature(fileContent, userId, ownerPublicKey)
? new OriginalFile(fileContent, fileName)
: throw new CryptographicException("File integrity has been compromised."));
}
public byte[] Encrypt(byte[] data)
{
if (!ModeSignature.Equals("OFB"))
{
using var tdes = new TripleDESCryptoServiceProvider
{
Mode = AlgorithmUtility.GetCipherMode(ModeSignature)
};
//tdes.Padding = PaddingMode.PKCS7;
using var encryptor = tdes.CreateEncryptor(Key, IV);
using var ms = new MemoryStream();
using var writer = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
writer.Write(data, 0, data.Length);
writer.FlushFinalBlock();
return ms.ToArray();
}
else
{
byte[] encrypted;
var tdes = CreateTripleDesCipher(true);
try
{
encrypted = new byte[tdes.GetOutputSize(data.Length)];
var len = tdes.ProcessBytes(data, 0, data.Length, encrypted, 0);
tdes.DoFinal(encrypted, len);
return encrypted;
}
catch (CryptoException)
{
}
}
return null;
}
public void Test2()
{
var(item1, item2) = AlgorithmUtility.Run <int, int>(InputFilePath("input2.txt"));
var(result, time) = RunTest(() => MarkAndToys.maximumToys(item2[0].ToArray(), item1[1]));
Assert.Equal(3, result);
}
private void decryptButton_Click(object sender, RoutedEventArgs e)
{
string message = null;
int imageHeight = 0;
int imageWidth = 0;
Bitmap drawnImage = null;
MessageType messageType = MessageType.Plaintext;
if (algorithmsComboBox.SelectedItem.ToString() == "LSB")
{
IOutputMessage messageInBits = LSB.Instance.Decode(new Bitmap(carrierViewer.filename));
messageType = messageInBits.GetHeaderData().GetMessageType();
string outputMessage = messageInBits.GetContent();
switch (messageType)
{
case MessageType.Plaintext:
message = AlgorithmUtility.bitMessageToText(outputMessage, (int)LSBHeaderConstants.PlainTextHeaderLength);
break;
case MessageType.BinaryImage:
message = outputMessage.Substring((int)LSBHeaderConstants.BinaryImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawBinaryImage(message, imageWidth, imageHeight);
break;
case MessageType.GrayscaleImage:
message = outputMessage.Substring((int)LSBHeaderConstants.GrayscaleImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawGrayscaleImage(message, imageWidth, imageHeight);
break;
case MessageType.ColorImage:
message = outputMessage.Substring((int)LSBHeaderConstants.ColorImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawColorImage(message, imageWidth, imageHeight);
break;
}
}
else if (algorithmsComboBox.SelectedItem.ToString() == "Histogram shifting")
{
HSSettings tab = settingsTabControl.SelectedContent as HSSettings;
int minIndex = tab.getMinIndex();
int maxIndex = tab.getMaxIndex();
IOutputMessage messageInBits = HS.Instance.Decode(new Bitmap(carrierViewer.filename), minIndex, maxIndex);
messageType = messageInBits.GetHeaderData().GetMessageType();
string outputMessage = messageInBits.GetContent();
switch (messageType)
{
case MessageType.Plaintext:
message = AlgorithmUtility.bitMessageToText(outputMessage, (int)HSHeaderConstants.PlainTextHeaderLength);
break;
case MessageType.BinaryImage:
message = outputMessage.Substring((int)HSHeaderConstants.BinaryImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawBinaryImage(message, imageWidth, imageHeight);
break;
case MessageType.GrayscaleImage:
message = outputMessage.Substring((int)HSHeaderConstants.GrayscaleImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawGrayscaleImage(message, imageWidth, imageHeight);
break;
case MessageType.ColorImage:
message = outputMessage.Substring((int)HSHeaderConstants.ColorImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawColorImage(message, imageWidth, imageHeight);
break;
}
}
// need to change this dynamically
if (messageType == MessageType.Plaintext)
{
messageTabControl.SelectedItem = messageTextBox;
TextBox tab = messageTabControl.SelectedContent as TextBox;
tab.Text = message;
//messageTextBox.selec = message;
}
else
{
messageTabControl.SelectedItem = messageImage;
Image tab = messageTabControl.SelectedContent as Image;
tab.Source = ToBitmapImage(drawnImage);
}
}
/// <summary>
/// Returns a random positive integer between the specified inclusive start
/// value and the exclusive end value.
/// </summary>
public int GetRandomRange(long x, long y, long z, int start, int end, long modifier)
{
return(AlgorithmUtility.GetRandomRange(this.Seed, x, y, z, start, end, modifier));
}
/// <summary>
/// Returns a random double between the range of 0.0 and 1.0 based on
/// the provided X and Y position, and the specified modifier.
/// </summary>
public double GetRandomDouble(long x, long y, long z, long modifier = 0)
{
return(AlgorithmUtility.GetRandomDouble(this.Seed, x, y, z, modifier));
}
/// <summary>
/// Returns a random long integer over the range of valid long integers based
/// on the provided X and Y position, and the specified modifier.
/// </summary>
public long GetRandomLong(long x, long y, long z, long modifier = 0)
{
return(AlgorithmUtility.GetRandomLong(this.Seed, x, y, z, modifier));
}
/// <summary>
/// Returns a random integer over the range of valid integers based
/// on the provided X and Y position, and the specified modifier.
/// </summary>
public int GetRandomInt(long x, long y, long z, long modifier = 0)
{
return(AlgorithmUtility.GetRandomInt(this.Seed, x, y, z, modifier));
}
