public void MoveEntry(int from, int to)
{
if (UseMaFiles)
{
if (from < 0 || to < 0 || from > Entries.Count || to > Entries.Count - 1)
{
return;
}
ManifestEntry sel = Entries[from];
Entries.RemoveAt(from);
Entries.Insert(to, sel);
Save();
}
else
{
credMan = CredManifest.GetManifest();
if (from < 0 || to < 0 || from > credMan.Entries.Count || to > credMan.Entries.Count - 1)
{
return;
}
CredManifestEntry sel = credMan.Entries[from];
credMan.Entries.RemoveAt(from);
credMan.Entries.Insert(to, sel);
credMan.Save();
}
}
/// <summary>
/// Decrypts/Encrypts all account files (depending on DPAPI setting)
/// </summary>
/// <returns></returns>
public bool UpdateDPAPI()
{
credMan = CredManifest.GetManifest();
if (UseMaFiles)
{
string maDir = GetExecutableDir() + "/maFiles/";
for (int i = 0; i < Entries.Count; i++)
{
ManifestEntry entry = Entries[i];
string filename = maDir + entry.FileName;
if (!File.Exists(filename))
{
continue;
}
string fileContents = File.ReadAllText(filename);
fileContents = Encryptor.DPAPIUnprotect(fileContents, Encryptor.AccountEntropy);
string toWriteFileContents = fileContents;
if (UseDPAPI == true)
{
toWriteFileContents = Encryptor.DPAPIProtect(toWriteFileContents, Encryptor.AccountEntropy);
}
File.WriteAllText(filename, toWriteFileContents);
if (UseWindowsFileEncryption)
{
File.Encrypt(filename);
}
else
{
File.Decrypt(filename);
}
}
}
else
{
foreach (CredManifestEntry entry in credMan.Entries)
{
string fileContents = entry.Contents;
string toWriteFileContents = Encryptor.DPAPIUnprotect(fileContents, Encryptor.AccountEntropy);
if (UseDPAPI)
{
toWriteFileContents = Encryptor.DPAPIProtect(toWriteFileContents, Encryptor.AccountEntropy);
}
entry.Contents = toWriteFileContents;
}
credMan.Save();
}
Save();
return(true);
}
public SecureString PromptForPasskey()
{
if (!Encrypted)
{
throw new ManifestNotEncryptedException();
}
bool passkeyValid = false;
SecureString passkey = null;
try
{
if (CredentialLocker)
{
credMan = CredManifest.GetManifest();
if (credMan.Key.Length >= 1)
{
if (VerifyPasskey(credMan.Key))
{
passkeyValid = true;
passkey = credMan.Key;
}
}
}
}
catch (Exception) { }
while (!passkeyValid)
{
InputForm passkeyForm = new InputForm(Properties.strings.ManifestEnterKey, true);
passkeyForm.ShowDialog(Application.Current.Windows.OfType <Window>().SingleOrDefault(x => x.IsActive)); // Gets the current active window and passes that to the input form (so it can center)
if (!passkeyForm.Canceled)
{
passkey = passkeyForm.txtPass.SecurePassword;
if (!VerifyPasskey(passkey))
{
MessageBox.Show(Properties.strings.ManifestKeyInvalid);
}
else
{
passkeyValid = true;
if (CredentialLocker)
{
credMan = CredManifest.GetManifest();
credMan.Key = passkey;
credMan.Save();
}
}
}
else
{
return(null);
}
}
return(passkey);
}
private static CredManifest _generateNewManifest(SecureString key)
{
// No directory means no manifest file anyways.
CredManifest newManifest = new CredManifest
{
Key = key,
Entries = new List <CredManifestEntry>()
};
if (newManifest.Save())
{
return(newManifest);
}
return(null);
}
public bool RemoveAccount(SteamGuardAccount account, bool deleteMaFile = true)
{
if (UseMaFiles)
{
ManifestEntry entry = (from e in this.Entries where e.SteamID == account.Session.SteamID select e).FirstOrDefault();
if (entry == null)
{
return(true); // If something never existed, did you do what they asked?
}
string maDir = GetExecutableDir() + "/maFiles/";
string filename = maDir + entry.FileName;
this.Entries.Remove(entry);
if (Entries.Count == 0)
{
Encrypted = false;
}
if (Save() && deleteMaFile)
{
try
{
File.Delete(filename);
return(true);
}
catch (Exception)
{
return(false);
}
}
}
else
{
credMan = CredManifest.GetManifest();
CredManifestEntry entry = (from e in credMan.Entries where e.SteamID == account.Session.SteamID select e).FirstOrDefault();
if (entry == null)
{
return(true);
}
credMan.Entries.Remove(entry);
if (credMan.Entries.Count == 0)
{
Encrypted = false;
}
return(credMan.Save());
}
return(false);
}
public bool SaveAccount(SteamGuardAccount account, bool encrypt, SecureString passkey = null)
{
if (encrypt && passkey != null && passkey.Length >= 1)
{
return(false);
}
if (!encrypt && this.Encrypted)
{
return(false);
}
if (account == null)
{
return(false);
}
if (UseMaFiles)
{
string salt = null;
string iV = null;
string jsonAccount = JsonConvert.SerializeObject(account);
if (encrypt)
{
salt = Encryptor.GetRandomSalt();
iV = Encryptor.GetInitializationVector();
string encrypted = "Encrypted" + Encryptor.EncryptData(passkey, salt, iV, jsonAccount);
if (encrypted == null)
{
return(false);
}
jsonAccount = encrypted;
}
if (UseDPAPI)
{
jsonAccount = Encryptor.DPAPIProtect(jsonAccount, Encryptor.AccountEntropy);
}
string maDir = GetExecutableDir() + "/maFiles/";
string filename = account.Session.SteamID.ToString() + ".maFile";
ManifestEntry newEntry = new ManifestEntry()
{
SteamID = account.Session.SteamID,
IV = iV,
Salt = salt,
FileName = filename,
};
bool foundExistingEntry = false;
for (int i = 0; i < this.Entries.Count; i++)
{
if (Entries[i].SteamID == account.Session.SteamID)
{
Entries[i] = newEntry;
foundExistingEntry = true;
break;
}
}
if (!foundExistingEntry)
{
Entries.Add(newEntry);
}
bool wasEncrypted = Encrypted;
Encrypted = encrypt || Encrypted;
if (!Save())
{
Encrypted = wasEncrypted;
return(false);
}
try
{
File.WriteAllText(maDir + filename, jsonAccount);
if (UseWindowsFileEncryption)
{
File.Encrypt(maDir + filename);
}
else
{
File.Decrypt(maDir + filename);
}
return(true);
}
catch (Exception)
{
return(false);
}
}
else
{
try
{
credMan = CredManifest.GetManifest();
string salt = null; string iV = null;
string jsonAccount = JsonConvert.SerializeObject(account);
bool fileEncrypted = false;
if (encrypt)
{
salt = Encryptor.GetRandomSalt();
iV = Encryptor.GetInitializationVector();
string encrypted = "Encrypted" + Encryptor.EncryptData(passkey, salt, iV, jsonAccount);
if (encrypted == null)
{
return(false);
}
jsonAccount = encrypted;
fileEncrypted = true;
}
if (UseDPAPI)
{
jsonAccount = Encryptor.DPAPIProtect(jsonAccount, Encryptor.AccountEntropy);
}
CredManifestEntry newEntry = new CredManifestEntry()
{
SteamID = account.Session.SteamID,
IV = iV,
Salt = salt,
Contents = jsonAccount,
Encrypted = fileEncrypted,
};
bool foundExistingEntry = false;
for (int i = 0; i < credMan.Entries.Count; i++)
{
if (credMan.Entries[i].SteamID == account.Session.SteamID)
{
credMan.Entries[i] = newEntry;
foundExistingEntry = true;
break;
}
}
if (!foundExistingEntry)
{
credMan.Entries.Add(newEntry);
}
credMan.Save();
bool wasEncrypted = Encrypted;
Encrypted = encrypt || Encrypted;
if (!Save())
{
Encrypted = wasEncrypted;
return(false);
}
return(true);
}
catch (Exception) { return(false); }
}
}
public bool ChangeEncryptionKey(SecureString oldKey, SecureString newKey)
{
if (Encrypted)
{
if (!VerifyPasskey(oldKey))
{
return(false);
}
}
bool toEncrypt = newKey != null;
credMan = CredManifest.GetManifest();
if (UseMaFiles)
{
string maDir = GetExecutableDir() + "/maFiles/";
for (int i = 0; i < Entries.Count; i++)
{
ManifestEntry entry = Entries[i];
string filename = maDir + entry.FileName;
if (!File.Exists(filename))
{
continue;
}
string fileContents = File.ReadAllText(filename);
fileContents = Encryptor.DPAPIUnprotect(fileContents, Encryptor.AccountEntropy);
if (fileContents.StartsWith("Encrypted"))
{
fileContents = Encryptor.DecryptData(oldKey, entry.Salt, entry.IV, fileContents.Remove(0, 9));
}
string newSalt = null;
string newIV = null;
string toWriteFileContents = fileContents;
if (toEncrypt)
{
newSalt = Encryptor.GetRandomSalt();
newIV = Encryptor.GetInitializationVector();
toWriteFileContents = "Encrypted" + Encryptor.EncryptData(newKey, newSalt, newIV, fileContents);
}
if (UseDPAPI)
{
toWriteFileContents = Encryptor.DPAPIProtect(toWriteFileContents, Encryptor.AccountEntropy);
}
File.WriteAllText(filename, toWriteFileContents);
if (UseWindowsFileEncryption)
{
File.Encrypt(filename);
}
else
{
File.Decrypt(filename);
}
entry.IV = newIV;
entry.Salt = newSalt;
}
}
else
{
foreach (CredManifestEntry entry in credMan.Entries)
{
string fileContents = entry.Contents;
fileContents = Encryptor.DPAPIUnprotect(fileContents, Encryptor.AccountEntropy);
if (fileContents.StartsWith("Encrypted"))
{
fileContents = Encryptor.DecryptData(oldKey, entry.Salt, entry.IV, fileContents.Remove(0, 9));
}
string newSalt = null;
string newIV = null;
string toWriteFileContents = fileContents;
if (toEncrypt)
{
newSalt = Encryptor.GetRandomSalt();
newIV = Encryptor.GetInitializationVector();
toWriteFileContents = "Encrypted" + Encryptor.EncryptData(newKey, newSalt, newIV, fileContents);
}
else
{
entry.Encrypted = false;
}
if (UseDPAPI)
{
toWriteFileContents = Encryptor.DPAPIProtect(toWriteFileContents, Encryptor.AccountEntropy);
}
entry.Contents = toWriteFileContents;
entry.IV = newIV;
entry.Salt = newSalt;
}
credMan.Key = newKey;
credMan.Save();
}
Encrypted = toEncrypt;
Save();
return(true);
}