public byte[] GenerateBinaryKey()
{
const string originalLookupIndex = "SecureMemo";
using var secureRnd = new SecureRandomGenerator();
MemoryStream ms = new MemoryStream();
byte[] buffer = secureRnd.GetRandomData(secureRnd.GetRandomInt(29, 221));
ms.Write(buffer, 0, buffer.Length);
buffer = GeneralConverters.ConvertStringToByteArray(Encoding.ASCII, originalLookupIndex);
ms.Write(buffer, 0, buffer.Length);
buffer = secureRnd.GetRandomData(secureRnd.GetRandomInt(29, 221));
ms.Write(buffer, 0, buffer.Length);
buffer = ms.ToArray();
// ReSharper disable once SuggestVarOrType_Elsewhere
for (int i = 0; i < secureRnd.GetRandomInt(83, 101); i++)
{
// Tick count being tracked by .Net using 32 bit integers for some strange reason when the WIN_API CALL uses ulong and thus not overflowing in 24 days and 20 hours.
int tickCount = Environment.TickCount;
// Just inject a small amount of noise for each iteration
int pos = tickCount % buffer.Length;
buffer[pos] ^= (byte)(tickCount % byte.MaxValue);
buffer = SHA512.GetSHA512HashAsByteArray(buffer);
}
buffer = SHA256.GetSHA256HashAsByteArray(buffer);
return(buffer);
}
public bool SaveToFile(string filename, string password)
{
try
{
//Make a copy of the original file if the original file is above 1 kb
if (File.Exists(filename) && SystemIOHelper.GetFileSize(filename) > 1024)
{
string copyFilename = GeneralConverters.GetDirectoryNameFromPath(filename, true) + "BookmarksCopy.dat";
if (File.Exists(copyFilename))
{
File.Delete(copyFilename);
}
File.Copy(filename, copyFilename);
}
var settings = new StorageManagerSettings(false, Environment.ProcessorCount, true, password);
var storageManager = new StorageManager(settings);
bool successful = storageManager.SerializeObjectToFile(_bookmarkContainer, filename, null);
if (successful)
{
IsModified = false;
}
return(successful);
}
catch (Exception ex)
{
Log.Error(ex, "BookmarkManager.SaveToFile(string filename, string password) : " + ex.Message, ex);
return(false);
}
}
public bool HasAccessToDirectory(string directory)
{
if (_directoryAccessDictionary.ContainsKey(directory))
{
return(_directoryAccessDictionary[directory]);
}
string volume = GeneralConverters.GetVolumeLabelFromPath(directory);
var drives = DriveInfo.GetDrives().ToList();
if (drives.Any(d => d.IsReady && d.Name.Equals(volume, StringComparison.CurrentCultureIgnoreCase)))
{
try
{
var directoryInfo = new DirectoryInfo(directory);
directoryInfo.EnumerateFiles();
_directoryAccessDictionary.Add(directory, true);
return(true);
}
catch (Exception)
{
// ignored
}
}
_directoryAccessDictionary.Add(directory, false);
return(false);
}
private void UpdateInformationLabels()
{
lblCurrentDbSize.Text = GeneralConverters.FormatFileSizeToString(_thumbnailService.GetThumbnailDbSize());
int thumbnailItems = _thumbnailService.GetNumberOfCachedThumbnails();
lblCachedItems.Text = thumbnailItems > 0 ? _thumbnailService.GetNumberOfCachedThumbnails().ToString() : "n/a";
}
public string GenerateKey()
{
const string originalLookupIndex = "SecureMemo";
string key;
using var secureRnd = new SecureRandomGenerator();
string tmp = secureRnd.GetPasswordString(secureRnd.GetRandomInt(29, 221)) + originalLookupIndex + secureRnd.GetPasswordString(secureRnd.GetRandomInt(29, 221));
// ReSharper disable once SuggestVarOrType_Elsewhere
byte[] buffer = GeneralConverters.ConvertStringToByteArray(Encoding.ASCII, tmp);
for (int i = 0; i < secureRnd.GetRandomInt(83, 101); i++)
{
// Tick count being tracked by .Net using 32 bit integers for some strange reason when the WIN_API CALL uses ulong and thus not overflowing in 24 days and 20 hours.
int tickCount = Environment.TickCount;
// Just inject a small amount of noise for each iteration
int pos = tickCount % buffer.Length;
buffer[pos] ^= (byte)(tickCount % byte.MaxValue);
buffer = SHA512.GetSHA512HashAsByteArray(buffer);
}
buffer = SHA256.GetSHA256HashAsByteArray(buffer);
key = Convert.ToBase64String(buffer, 0, buffer.Length, Base64FormattingOptions.None).Trim("=".ToCharArray());
return(key);
}
public static string GetCRC326HashAsHexString(byte[] data)
{
var crc32Implementation = new CRC32();
byte[] hashData = crc32Implementation.ComputeHash(data);
return(GeneralConverters.ByteArrayToHexString(hashData));
}
private void LoadNewImageFile(string imagePath)
{
try
{
pictureBox1.SizeMode = (PictureBoxSizeMode)_applicationSettingsService.Settings.PrimaryImageSizeMode;
if (_applicationSettingsService.Settings.NextImageAnimation == ImageViewApplicationSettings.ChangeImageAnimation.None)
{
_changeImageAnimation = ImageViewApplicationSettings.ChangeImageAnimation.None;
}
_pictureBoxAnimation.ImageLocation = null;
if (pictureBox1.Image != null && _changeImageAnimation != ImageViewApplicationSettings.ChangeImageAnimation.None)
{
_pictureBoxAnimation.Image = _imageCacheService.GetImageFromCache(imagePath);
_pictureBoxAnimation.Refresh();
}
else
{
pictureBox1.Image = _imageCacheService.GetImageFromCache(imagePath);
pictureBox1.Refresh();
}
Text = _windowTitle + @" | " + GeneralConverters.GetFileNameFromPath(imagePath);
}
catch (Exception ex)
{
Log.Error(ex, "FormMain.LoadNewImageFile(string imagePath) Error when trying to load file: {imagePath} : {Message}", imagePath, ex.Message);
}
}
public static string GetMD5HashAsHexString(byte[] data)
{
var md5Implementation = System.Security.Cryptography.MD5.Create();
byte[] hashData = md5Implementation.ComputeHash(data);
return(GeneralConverters.ByteArrayToHexString(hashData));
}
private void UpdateHashTextField(object sender, EventArgs e)
{
if (hashBytes != null)
{
currentHashOutputTextBox.Text = GeneralConverters.ByteArrayToHexString(hashBytes);
}
}
public static string GetSHA512HashAsHexString(byte[] data)
{
System.Security.Cryptography.SHA256 sha512Implementation = System.Security.Cryptography.SHA256.Create();
var hashData = sha512Implementation.ComputeHash(data);
return(GeneralConverters.ByteArrayToHexString(hashData));
}
public void EnablePasswordProtectBookmarks(string verifiedPassword)
{
if (verifiedPassword != null)
{
PasswordProtectBookmarks = true;
PasswordDerivedString = GeneralConverters.GeneratePasswordDerivedString(verifiedPassword);
}
}
public bool SaveSettings(string filename, string password)
{
if (_otpSettings == null)
{
return(false);
}
FileStream fs = null;
try
{
if (File.Exists(filename))
{
File.Delete(filename);
}
fs = File.OpenWrite(filename);
fs.Seek(4, 0);
fs.Write(_otpSettings.Salt1, 0, _otpSettings.Salt1.Length);
fs.Write(_otpSettings.Salt2, 0, _otpSettings.Salt2.Length);
byte[] passwordBytes = GeneralConverters.GetByteArrayFromString(password);
string passwordHash = CreatePasswordHash(_otpSettings.Salt1, _otpSettings.Salt2, passwordBytes);
passwordBytes = GeneralConverters.GetByteArrayFromString(passwordHash);
fs.Write(passwordBytes, 0, passwordBytes.Length);
byte[] encodedBytes = _otpSettings.Encode(password);
int encodedBlockSize = encodedBytes.Length;
byte[] buffer = BitConverter.GetBytes(encodedBlockSize);
fs.Write(buffer, 0, buffer.Length);
fs.Write(encodedBytes, 0, encodedBytes.Length);
// Write configOffsetBytes
fs.Seek(0, SeekOrigin.Begin);
int configOffsetBytes = _otpSettings.Salt1.Length + _otpSettings.Salt2.Length + passwordBytes.Length;
buffer = BitConverter.GetBytes(configOffsetBytes);
fs.Write(buffer, 0, buffer.Length);
fs.Seek(0, SeekOrigin.End);
}
catch (Exception ex)
{
Log.Error(ex, "Exception in SaveSettings()");
if (File.Exists(filename))
{
File.Delete(filename);
}
}
finally
{
fs?.Close();
}
return(true);
}
private string CreateRegistrationKey(byte[] licenceBytes)
{
string regKeyData = GeneralConverters.ByteArrayToBase64(licenceBytes);
regKeyData = SerialNumbersSettings.ProtectedApplications.SaltData.GeneralToolkit + regKeyData + SerialNumbersSettings.ProtectedApplications.SaltData.GeneralToolkit + _app;
byte[] buffer = null;
EncryptionManager.EncodeString(ref buffer, regKeyData, "064lMPnLyjI6sqfXm5KhSE4R0FDU0AchClDyxpAWKkJgFyih59IkhX598sveO7vdbuEKgbEQjDRcLtx0FbcJtASEqHZE8bLX2CIq2LwYZC4OWZGWzx7dv0dxp1h6dcck");
return(ConvertToBase32SerialNumber(buffer));
}
private void createMD5FileToolStripMenuItem_Click(object sender, EventArgs e)
{
if (FileListDataGridView.SelectedRows.Count == 0)
{
return;
}
var fileSystemFileWrapper = (FileListDataGridView.SelectedRows[0].DataBoundItem as FileSystemFileWrapper);
if (fileSystemFileWrapper == null)
{
MessageBox.Show("Unexprected error in createMD5File. DataBoundItem is " + FileListDataGridView.SelectedRows[0].DataBoundItem.GetType());
return;
}
// Root folder?
string sfvFilename = fileSystemFileWrapper.FilePath ?? _currentFileSystemDrive.DriveLetter + fileSystemFileWrapper.Name;
int fileExtensionDelimiter = sfvFilename.LastIndexOf('.');
if (fileExtensionDelimiter > 0)
{
sfvFilename = sfvFilename.Substring(0, fileExtensionDelimiter) + ".md5";
}
else
{
sfvFilename += ".md5";
}
LoadAndSaveProgressBar.Visible = true;
ChecksumFileGenerationLabel.Visible = true;
Action <ChecksumProgress> checksumProgressLamdaFunction = progress =>
{
ChecksumFileGenerationLabel.Text = GeneralConverters.GetFileNameFromPath(progress.Text).PadLeft(5);
LoadAndSaveProgressBar.Value = progress.TotalProgress;
if (progress.Completed)
{
LoadAndSaveProgressBar.Visible = false;
ChecksumFileGenerationLabel.Visible = false;
MessageBox.Show("Successfully created MD5 file");
}
};
var checksumFileGenerator = new ChecksumFileGenerator(Application.ProductName + " " + Application.ProductVersion, new Progress <ChecksumProgress>(checksumProgressLamdaFunction));
var paths = new StringCollection();
foreach (DataGridViewRow selectedRow in FileListDataGridView.SelectedRows)
{
var selectedFile = selectedRow.DataBoundItem as FileSystemFileWrapper;
if (selectedFile != null && selectedFile.FilePath != null)
{
paths.Add(selectedFile.FilePath);
}
}
checksumFileGenerator.GenrateMD5FileAsync(paths, sfvFilename);
}
private string CreateRegistrationKey(byte[] licenseBytes)
{
string regKeyData = GeneralConverters.ByteArrayToBase64(licenseBytes);
regKeyData = LicenseGeneratorStaticData.SaltData.GeneralToolkit + regKeyData + LicenseGeneratorStaticData.SaltData.GeneralToolkit + this._app;
byte[] buffer = new byte[0];
EncryptionManager.EncodeString(ref buffer, regKeyData, regKeyData);
return(this.ConvertToBase32SerialNumber(buffer));
}
public bool ValidatePassword(string password)
{
if (_otpSettings == null)
{
throw new InvalidOperationException("OTPConfigService must be Initialized before password validation");
}
byte[] passwordBytes = GeneralConverters.GetByteArrayFromString(password);
return(CreatePasswordHash(_otpSettings.Salt1, _otpSettings.Salt2, passwordBytes) == PasswordHash);
}
private static string CreateApplicationSalt()
{
var randomBytes = new byte[512];
using (RandomNumberGenerator random = RandomNumberGenerator.Create())
{
random.GetBytes(randomBytes);
return(GeneralConverters.ByteArrayToHexString(randomBytes));
}
}
public bool Decode(byte[] data, string password)
{
var msEncoded = new MemoryStream(data);
byte[] buffer = new byte[4];
msEncoded.Read(buffer, 0, 4);
int encodedBytes = BitConverter.ToInt32(buffer, 0);
buffer = new byte[encodedBytes];
msEncoded.Read(buffer, 0, buffer.Length);
byte[] decodedBytes = EncryptionManager.DecryptData(buffer, password);
msEncoded.Read(buffer, 0, 4);
int hashByteLength = BitConverter.ToInt32(buffer, 0);
if (hashByteLength > 512)
{
return(false);
}
byte[] hashBytesFromData = new byte[hashByteLength];
msEncoded.Read(hashBytesFromData, 0, hashBytesFromData.Length);
byte[] hashBytesFromDecodedDataBytes = SHA512.Create().ComputeHash(decodedBytes, 0, decodedBytes.Length);
bool hashCompareResult = GeneralConverters.ByteArrayToBase64(hashBytesFromData) == GeneralConverters.ByteArrayToBase64(hashBytesFromDecodedDataBytes);
if (!hashCompareResult)
{
return(false);
}
var msDecoded = new MemoryStream(decodedBytes);
buffer = new byte[4];
msDecoded.Read(buffer, 0, buffer.Length);
int leftPaddingLength = BitConverter.ToInt32(buffer, 0);
msDecoded.Read(buffer, 0, buffer.Length);
int rightPaddingLength = BitConverter.ToInt32(buffer, 0);
msDecoded.Read(buffer, 0, buffer.Length);
int totalLength = BitConverter.ToInt32(buffer, 0);
byte[] decodedDataBlock = new byte[totalLength];
msDecoded.Read(decodedDataBlock, 0, decodedDataBlock.Length);
byte[] sharedSecretBytes = new byte[totalLength - leftPaddingLength - rightPaddingLength];
Buffer.BlockCopy(decodedDataBlock, leftPaddingLength, sharedSecretBytes, 0, sharedSecretBytes.Length);
SharedSecret = GeneralConverters.GetStringFromByteArray(sharedSecretBytes);
return(true);
}
public bool SynchronizeTime()
{
TcpClient tcpClient = new TcpClient();
long ticks = DateTime.Now.Ticks;
try
{
tcpClient.Connect(TimeServerUrl, 37);
}
catch (Exception ex)
{
LogWriter.WriteLog("Connection to time server failed - " + ex.Message);
return(false);
}
if (!tcpClient.Connected)
{
tcpClient.Close();
return(false);
}
NetworkStream ns = tcpClient.GetStream();
byte[] bTime = new byte[8];
int bytesRead = ns.Read(bTime, 0, 8);
tcpClient.Close();
if (bytesRead != 4)
{
return(false);
}
if (BitConverter.IsLittleEndian)
{
Array.Reverse(bTime);
}
UInt32 u32Time = BitConverter.ToUInt32(bTime, 4);
DateTime presentDate = GeneralConverters.GetDateTimeFromUInt(u32Time);
UpdateSystemClock.SystemTime updatedTime = new UpdateSystemClock.SystemTime
{
Year = Convert.ToUInt16(presentDate.Year),
Month = Convert.ToUInt16(presentDate.Month),
Day = Convert.ToUInt16(presentDate.Day),
DayOfWeek = Convert.ToUInt16(presentDate.DayOfWeek),
Hour = Convert.ToUInt16(presentDate.Hour),
Minute = Convert.ToUInt16(presentDate.Minute),
Second = Convert.ToUInt16(presentDate.Second),
Millisecond = 0
};
return(UpdateSystemClock.Win32SetSystemTime(ref updatedTime));
}
private void UpdateFileHashStatus(object sender, FileHashEventArgs e)
{
lblFileHashesRunning.Text = Math.Max(0, _hashComputeCount).ToString();
if (e.FileName == null)
{
lblFileHashInfo.Text = "";
}
else
{
lblFileHashInfo.Text = GeneralConverters.GetFileNameFromPath(e.FileName) + " - " + GeneralConverters.FormatFileSizeToString(e.FileSize);
}
}
private void HandleOkClick()
{
if (this.UseDerivedPassword && this.PasswordDerivedString != GeneralConverters.GeneratePasswordDerivedString(this.txtPassword.Text))
{
MessageBox.Show(this, "Invalid password");
return;
}
this.PasswordString = this.txtPassword.Text;
this.PasswordVerified = true;
DialogResult = DialogResult.OK;
this.Close();
}
private void HandleOkClick()
{
if (UsePasswordValidation && PasswordDerivedString != GeneralConverters.GeneratePasswordDerivedString(PasswordSalt + txtPassword.Text + PasswordSalt))
{
MessageBox.Show(this, "Invalid password");
return;
}
PasswordString = txtPassword.Text;
PasswordVerified = true;
DialogResult = DialogResult.OK;
Close();
}
private void Initialize()
{
settingsFilePath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\" + Assembly.GetExecutingAssembly().GetName().Name + "\\SecureChatAppSettings.dat";
settingsDirectoryPath = GeneralConverters.GetDirectoryNameFromPath(settingsFilePath);
try
{
if (!Directory.Exists(settingsDirectoryPath))
{
Directory.CreateDirectory(settingsDirectoryPath);
}
}
catch (Exception ex)
{
LogWriter.WriteLog(ex.Message);
}
}
/// <summary>
/// Create a new instance of otpSettings
/// </summary>
/// <param name="password"></param>
/// <returns>Password hash</returns>
public string Create(string password, Authenticator.SecretKeyLength keyLength)
{
using (var randomNumberGenerator = RandomNumberGenerator.Create())
{
byte[] salt1Bytes = new byte[SaltByteLength];
byte[] salt2Bytes = new byte[SaltByteLength];
byte[] passwordBytes = GeneralConverters.GetByteArrayFromString(password);
randomNumberGenerator.GetBytes(salt1Bytes);
randomNumberGenerator.GetBytes(salt2Bytes);
PasswordHash = CreatePasswordHash(salt1Bytes, salt2Bytes, passwordBytes);
_otpSettings = new OTPSettings(Authenticator.GenerateKey(keyLength), salt1Bytes, salt2Bytes);
Initialized = true;
return(PasswordHash);
}
}
public void TestPasswordDerivates()
{
RandomNumberGenerator rng = RandomNumberGenerator.Create();
byte[] salt = new byte[32];
rng.GetBytes(salt);
string password = SHA256.GetSHA256HashAsHexString(GeneralConverters.StringToByteArray("MartinDahl"));
Rfc2898DeriveBytes pDeriveBytes = new Rfc2898DeriveBytes(password, salt, 1000);
Rfc2898DeriveBytes pDeriveBytes2 = new Rfc2898DeriveBytes(password, salt, 1000);
string a1 = GeneralConverters.ByteArrayToHexString(pDeriveBytes.GetBytes(16));
string a2 = GeneralConverters.ByteArrayToHexString(pDeriveBytes2.GetBytes(16));
Assert.IsTrue(a1 == a2, "Passwords derived was not correct");
}
private string GetDriveInfoListItemText(DriveInfo driveInfo)
{
string driveInfoText = driveInfo.VolumeLabel ?? "";
if (!string.IsNullOrEmpty(driveInfo.Name))
{
driveInfoText += string.Format(" ({0}) ", driveInfo.Name.Replace("\\", ""));
}
else
{
driveInfoText += " [" + driveInfo.VolumeLabel + "]";
}
driveInfoText += string.Format("{0} free of {1} [{2}, {3}]", GeneralConverters.FormatFileSizeToString(driveInfo.TotalFreeSpace), GeneralConverters.FormatFileSizeToString(driveInfo.TotalSize),
driveInfo.DriveType, driveInfo.DriveFormat);
return(driveInfoText);
}
private void UpdateCacheStats()
{
long cacheSize = _selectedCacheSize;
long cacheUsage = _imageCacheService.CacheSize;
const long maxSize = ImageCacheService.MaxCacheSize;
const long minSize = ImageCacheService.MinCacheSize;
pbarPercentUsed.Maximum = (int)cacheSize;
lblCacheItems.Text = _imageCacheService.CachedImages.ToString();
lblUsedSpace.Text = GeneralConverters.FormatFileSizeToString(cacheUsage, 2);
lblFreeSpace.Text = GeneralConverters.FormatFileSizeToString(cacheSize - cacheUsage);
pbarPercentUsed.Value = Convert.ToInt32((double)cacheUsage / cacheSize * 100);
trackBarCacheSize.Minimum = Convert.ToInt32(minSize / TrackbarDivider);
trackBarCacheSize.Maximum = Convert.ToInt32(maxSize / TrackbarDivider);
trackBarCacheSize.Value = Convert.ToInt32(cacheSize / TrackbarDivider);
UpdateCacheSizeLabel();
}
public T DeserializeObjectFromString(string data, StringSerializationFormat format, bool useProtobuffer)
{
byte[] byteData = null;
switch (format)
{
case StringSerializationFormat.Base64:
byteData = Convert.FromBase64String(data);
break;
case StringSerializationFormat.Hex:
byteData = GeneralConverters.HexStringToByteArray(data);
break;
default:
throw new ArgumentOutOfRangeException("format");
}
return(useProtobuffer ? this.DeserializeProtoBufferObjectDataInternal(byteData) : this.DeserializeBinaryFormatterObjectDataInternal(byteData));
}
public void SaveConfigFile(string path)
{
try
{
if (!GeneralConverters.GetFileNameFromPath(path).EndsWith(".ini"))
{
throw new ArgumentException("Invalid filename. Filename must end with .ini");
}
if (File.Exists(path))
{
File.Delete(path);
}
FileStream fs = File.Create(path);
TextWriter tw = new StreamWriter(fs);
foreach (string rootItemName in _iniFileData.ConfigItems.AllKeys)
{
tw.WriteLine(rootItemName + "=" + _iniFileData.ConfigItems[rootItemName]);
}
foreach (string sectionName in _iniFileData.ConfigSections.Keys)
{
IniConfigFileSection section = _iniFileData.ConfigSections[sectionName];
tw.WriteLine("[" + sectionName + "]");
foreach (string itemName in section.ConfigItems.AllKeys)
{
tw.WriteLine(itemName + "=" + section.ConfigItems[itemName]);
}
}
tw.Flush();
fs.Flush();
fs.Close();
}
catch (Exception ex)
{
Log.Error(ex, "IniConfigFileManager->SaveConfigFile");
}
}
private SerialNumberGenerator CreateSerialNumberGenerator()
{
var rsaPublicKeyIdentity = new RsaKeySetIdentity(null, RSAKeys.PublicKeys.GetKeyString());
RsaAsymetricEncryption rsaAsymmetricEncryption = new RsaAsymetricEncryption();
RSAParameters pubKeyParams = rsaAsymmetricEncryption.ParseRsaPublicKeyOnlyInfo(rsaPublicKeyIdentity);
SerialNumberGenerator serialNumberGenerator = new SerialNumberGenerator(pubKeyParams, SerialNumbersSettings.ProtectedApp.SecureMemo);
RegistrationDataModel registrationData = new RegistrationDataModel
{
Company = "Doe",
Salt = GeneralConverters.GetRandomHexValue(256),
ValidTo = DateTime.Now.AddYears(1),
VersionName = LicenseGeneratorStaticData.SecureMemo.Versions.First()
};
serialNumberGenerator.LicenseData.RegistrationData = registrationData;
return(serialNumberGenerator);
}
